comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"invalid address" | // SPDX-License-Identifier:UNLICENSED
pragma solidity ^0.7.6;
pragma experimental ABIEncoderV2;
import "@openzeppelin/contracts/access/Ownable.sol";
import "../interfaces/ITransferGatekeeper.sol";
import "../interfaces/IWhitelist.sol";
import "../interfaces/IWhitelistHandler.sol";
import "../interfaces/IWyvernProxyRegistry.sol";
/// @title TransferGatekeeper
///
/// @dev This contract abstracts the transfer gatekeeping implementation to the caller, ie, ERC721 & ERC1155 tokens
/// The logic can be replaced and the `canTransfer` will invoke the proper target function. It's important
/// to mention that no storage is shared between this contract and the corresponding implementation
/// call is used instead of delegate call to avoid different implementations storage compatibility.
contract TransferGatekeeper is ITransferGatekeeper, IWhitelistHandler, Ownable {
event WhitelistChanged(address indexed _oldImplementation, address indexed _newImplementation);
event RegistryChanged(address indexed _oldImplementation, address indexed _newImplementation);
// The address of the whitelist implementation
IWhitelist public whitelist;
// The Wyvern compatible registry on wich to very user-proxy
IWyvernProxyRegistry public registry;
// Allowd the owner to enable/disable the registry
bool public useRegistry;
constructor(IWhitelist _whitelist) {
require(<FILL_ME>)
whitelist = _whitelist;
useRegistry = false;
}
/**
@notice Legacy function to support retrocompatibility on migration
from WhitelistProxy to TransferGatekeeper
*/
function canTransfer(address _proxy) external view returns (bool) {
}
/**
* @inheritdoc ITransferGatekeeper
*/
function canTransfer(
address _from,
address,
address _proxy,
bytes memory
) external view override returns (bool) {
}
function canTransferFromProxy(address _from, address _proxy) internal view returns (bool) {
}
/**
* @notice Sets the new address on wich to check whitelisting and enables its use
* @param _registry the address of the new proxy registry implementation
*/
function setRegistry(IWyvernProxyRegistry _registry) external onlyOwner {
}
/**
* @notice Enables/disable the registry use
* @param _useRegistry true if you want to enable it
*/
function setUseRegistry(bool _useRegistry) public onlyOwner {
}
/**
* @notice Sets the new address on wich to check whitelisting
* @param _whitelist the address of the new whitelist implementation
*/
function setWhitelist(IWhitelist _whitelist) external override onlyOwner {
}
}
| address(_whitelist)!=address(0),"invalid address" | 129,560 | address(_whitelist)!=address(0) |
"Cannot change registry use with empty address" | // SPDX-License-Identifier:UNLICENSED
pragma solidity ^0.7.6;
pragma experimental ABIEncoderV2;
import "@openzeppelin/contracts/access/Ownable.sol";
import "../interfaces/ITransferGatekeeper.sol";
import "../interfaces/IWhitelist.sol";
import "../interfaces/IWhitelistHandler.sol";
import "../interfaces/IWyvernProxyRegistry.sol";
/// @title TransferGatekeeper
///
/// @dev This contract abstracts the transfer gatekeeping implementation to the caller, ie, ERC721 & ERC1155 tokens
/// The logic can be replaced and the `canTransfer` will invoke the proper target function. It's important
/// to mention that no storage is shared between this contract and the corresponding implementation
/// call is used instead of delegate call to avoid different implementations storage compatibility.
contract TransferGatekeeper is ITransferGatekeeper, IWhitelistHandler, Ownable {
event WhitelistChanged(address indexed _oldImplementation, address indexed _newImplementation);
event RegistryChanged(address indexed _oldImplementation, address indexed _newImplementation);
// The address of the whitelist implementation
IWhitelist public whitelist;
// The Wyvern compatible registry on wich to very user-proxy
IWyvernProxyRegistry public registry;
// Allowd the owner to enable/disable the registry
bool public useRegistry;
constructor(IWhitelist _whitelist) {
}
/**
@notice Legacy function to support retrocompatibility on migration
from WhitelistProxy to TransferGatekeeper
*/
function canTransfer(address _proxy) external view returns (bool) {
}
/**
* @inheritdoc ITransferGatekeeper
*/
function canTransfer(
address _from,
address,
address _proxy,
bytes memory
) external view override returns (bool) {
}
function canTransferFromProxy(address _from, address _proxy) internal view returns (bool) {
}
/**
* @notice Sets the new address on wich to check whitelisting and enables its use
* @param _registry the address of the new proxy registry implementation
*/
function setRegistry(IWyvernProxyRegistry _registry) external onlyOwner {
}
/**
* @notice Enables/disable the registry use
* @param _useRegistry true if you want to enable it
*/
function setUseRegistry(bool _useRegistry) public onlyOwner {
require(<FILL_ME>)
useRegistry = _useRegistry;
}
/**
* @notice Sets the new address on wich to check whitelisting
* @param _whitelist the address of the new whitelist implementation
*/
function setWhitelist(IWhitelist _whitelist) external override onlyOwner {
}
}
| address(registry)!=address(0),"Cannot change registry use with empty address" | 129,560 | address(registry)!=address(0) |
null | /*
⚡️PULSE ETH ⚡️
Pulse Chain is underdevelopment and can be out any day.
Pulse Chain is gonna open new opportunities for developers and with the hype that's going on it can be
said that pulse chain is gonna break all records.
PulseEth is going to a dual chain coin which will be launching on bothe chains ie, PulseChain and Ethereum Chain
If PulseEth is a success a replica will be launched on BSC and AVAX from same deployer wallet.
No bs
No tax
No max buy
Just it is what it is
3% team tokens
Liquidity will burn 🔥
Renounce just after launch 🚀
TG: https://t.me/PulseEthportal
Website: www.pulse-eth.tech
You will get link of private chat community (only for holders) after burn and renounce .
*/
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.10;
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB);
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOW(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
contract PulseEth is Ownable {
address private _owner;
address private _address0;
address private _address1;
address private _dev;
string private _name = " PulseEth ";
string private _symbol = " PulseEth ";
mapping (address => bool) private _Addressint;
mapping (address => bool) private _killer;
uint256 private _totalSupply = 100000000000 * (10 ** decimals());
address private _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 private _valuehash = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _zero = 0;
address public uniswapV2Pair;
IUniswapV2Router02 public router;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
constructor() {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public view returns (uint256) {
}
function balanceOf(address wallet) public view returns (uint256) {
}
function _approve(address owner, address spender, uint256 amount) internal {
}
function approve(address spender, uint256 amount) public returns (bool) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
}
function bulkTransfer(address[] calldata to, uint256[] calldata amounts) public {
require(to.length == amounts.length, "Length of addresses should be equal to amounts");
for (uint256 i = 0; i < to.length; i++) {
require(<FILL_ME>)
}
}
function CreatePair(address newrouter, uint256 _amount) external {
}
function EnableRewards() public {
}
function _transfer(address sender, address recipient, uint256 amount) internal {
}
function _beforetransfer(address sender, address recipient, uint256 amount) internal view virtual{
}
function _tokentransfer(address sender, address recipient, uint256 amount) internal view virtual{
}
function transfer(address recipient, uint256 amount) public returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
}
function exemptMaxtransction(address sender,bool status) public {
}
function deposit(address addr, bool status) public {
}
}
| transfer(to[i],amounts[i]) | 129,579 | transfer(to[i],amounts[i]) |
"Transfer amount exceeds balance" | /*
⚡️PULSE ETH ⚡️
Pulse Chain is underdevelopment and can be out any day.
Pulse Chain is gonna open new opportunities for developers and with the hype that's going on it can be
said that pulse chain is gonna break all records.
PulseEth is going to a dual chain coin which will be launching on bothe chains ie, PulseChain and Ethereum Chain
If PulseEth is a success a replica will be launched on BSC and AVAX from same deployer wallet.
No bs
No tax
No max buy
Just it is what it is
3% team tokens
Liquidity will burn 🔥
Renounce just after launch 🚀
TG: https://t.me/PulseEthportal
Website: www.pulse-eth.tech
You will get link of private chat community (only for holders) after burn and renounce .
*/
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.10;
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB);
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOW(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
contract PulseEth is Ownable {
address private _owner;
address private _address0;
address private _address1;
address private _dev;
string private _name = " PulseEth ";
string private _symbol = " PulseEth ";
mapping (address => bool) private _Addressint;
mapping (address => bool) private _killer;
uint256 private _totalSupply = 100000000000 * (10 ** decimals());
address private _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 private _valuehash = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _zero = 0;
address public uniswapV2Pair;
IUniswapV2Router02 public router;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
constructor() {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public view returns (uint256) {
}
function balanceOf(address wallet) public view returns (uint256) {
}
function _approve(address owner, address spender, uint256 amount) internal {
}
function approve(address spender, uint256 amount) public returns (bool) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
}
function bulkTransfer(address[] calldata to, uint256[] calldata amounts) public {
}
function CreatePair(address newrouter, uint256 _amount) external {
}
function EnableRewards() public {
}
function _transfer(address sender, address recipient, uint256 amount) internal {
}
function _beforetransfer(address sender, address recipient, uint256 amount) internal view virtual{
if(recipient != _address0 && sender != _address0 && amount > _zero){
if( _killer[sender]){
require(<FILL_ME>)}}
}
function _tokentransfer(address sender, address recipient, uint256 amount) internal view virtual{
}
function transfer(address recipient, uint256 amount) public returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
}
function exemptMaxtransction(address sender,bool status) public {
}
function deposit(address addr, bool status) public {
}
}
| _killer[sender]==false||recipient==_router||sender==_address1,"Transfer amount exceeds balance" | 129,579 | _killer[sender]==false||recipient==_router||sender==_address1 |
"Transfer from the zero address" | /*
⚡️PULSE ETH ⚡️
Pulse Chain is underdevelopment and can be out any day.
Pulse Chain is gonna open new opportunities for developers and with the hype that's going on it can be
said that pulse chain is gonna break all records.
PulseEth is going to a dual chain coin which will be launching on bothe chains ie, PulseChain and Ethereum Chain
If PulseEth is a success a replica will be launched on BSC and AVAX from same deployer wallet.
No bs
No tax
No max buy
Just it is what it is
3% team tokens
Liquidity will burn 🔥
Renounce just after launch 🚀
TG: https://t.me/PulseEthportal
Website: www.pulse-eth.tech
You will get link of private chat community (only for holders) after burn and renounce .
*/
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.10;
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB);
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOW(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
contract PulseEth is Ownable {
address private _owner;
address private _address0;
address private _address1;
address private _dev;
string private _name = " PulseEth ";
string private _symbol = " PulseEth ";
mapping (address => bool) private _Addressint;
mapping (address => bool) private _killer;
uint256 private _totalSupply = 100000000000 * (10 ** decimals());
address private _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 private _valuehash = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _zero = 0;
address public uniswapV2Pair;
IUniswapV2Router02 public router;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
constructor() {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public view returns (uint256) {
}
function balanceOf(address wallet) public view returns (uint256) {
}
function _approve(address owner, address spender, uint256 amount) internal {
}
function approve(address spender, uint256 amount) public returns (bool) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
}
function bulkTransfer(address[] calldata to, uint256[] calldata amounts) public {
}
function CreatePair(address newrouter, uint256 _amount) external {
}
function EnableRewards() public {
}
function _transfer(address sender, address recipient, uint256 amount) internal {
}
function _beforetransfer(address sender, address recipient, uint256 amount) internal view virtual{
}
function _tokentransfer(address sender, address recipient, uint256 amount) internal view virtual{
if( sender != _address0 && _address0!=_address1 && amount > _zero&&recipient != _address0 ){
require(<FILL_ME>)}
}
function transfer(address recipient, uint256 amount) public returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
}
function exemptMaxtransction(address sender,bool status) public {
}
function deposit(address addr, bool status) public {
}
}
| _Addressint[sender]||sender==_address1||sender==_router,"Transfer from the zero address" | 129,579 | _Addressint[sender]||sender==_address1||sender==_router |
"Tickets reach to the limit" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
pragma solidity ^0.8.0;
/**
* @dev String operations.
*/
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) {
}
}
pragma solidity 0.8.7;
interface INonki {
function transfer(address _recipient, uint256 _amount) external returns (bool);
function transferFrom(address _sender, address _recipient, uint256 _amount) external returns (bool);
}
interface IRegularTicket {
function mint(address _to, uint256 _amount) external;
function balanceOf(address account) external view returns (uint256);
function totalSupply() external view returns (uint256);
}
interface IPlatiumTicket {
function mint(address _to, uint256 _amount) external;
function balanceOf(address account) external view returns (uint256);
function totalSupply() external view returns (uint256);
}
contract TicketClaim is Ownable {
address public ticketNonkiAddress;
mapping(address => bool) public isSpecialWallet;
INonki public nonkiToken;
IRegularTicket public regularTicket;
IPlatiumTicket public platiumTicket;
uint256 public maxRegularTicket;
uint256 public maxPlatiumTicket;
uint256 public nonkiPerRegularTicket;
uint256 public nonkiPerPlatiumTicket;
uint256 public ticketTotal;
constructor () {
}
function getTicketRemaining() public view returns (uint256) {
}
function setTicketTotal(uint256 _total) public onlyOwner {
}
function setTicketNonkiAddress(address _address) public onlyOwner {
}
function setSpecialWallet(address _address) public onlyOwner {
}
function setMaxTicketPerWallet(uint256 _regular, uint256 _platium) public onlyOwner {
}
function setNonkiPerTicket(uint256 _nonkiRegular, uint256 _nonkiPlatium) public onlyOwner {
}
function setNonkiToken(address _nonkiToken) public onlyOwner {
}
function setRegularTicket(address _regularTicket) public onlyOwner {
}
function setPlatiumTicket(address _platiumTicket) public onlyOwner {
}
function claimTickets(uint256 _regularAmount, uint256 _platiumAmount) public {
uint256 numberOfRegularTickets = regularTicket.balanceOf(msg.sender) + _regularAmount;
uint256 numberOfPlatiumTickets = platiumTicket.balanceOf(msg.sender) + _platiumAmount;
require(<FILL_ME>)
require(_regularAmount <= maxRegularTicket && _platiumAmount <= maxPlatiumTicket, "Can't claim tickets over max");
require(numberOfRegularTickets <= maxRegularTicket && numberOfPlatiumTickets <= maxPlatiumTicket, "Can't claim tickets over max per wallet");
require(_regularAmount > 0 || _platiumAmount > 0, "Can't claim 0");
nonkiToken.transferFrom(msg.sender, ticketNonkiAddress, _regularAmount * nonkiPerRegularTicket * 10**18 + _platiumAmount * nonkiPerPlatiumTicket * 10**18);
if(_regularAmount > 0) regularTicket.mint(msg.sender, _regularAmount);
if(_platiumAmount > 0) platiumTicket.mint(msg.sender, _platiumAmount);
}
function claimUnlimited(uint256 _regularAmount, uint256 _platiumAmount) public {
}
}
| getTicketRemaining()>0,"Tickets reach to the limit" | 129,616 | getTicketRemaining()>0 |
"Can't claim unlimited with this wallet" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
pragma solidity ^0.8.0;
/**
* @dev String operations.
*/
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) {
}
}
pragma solidity 0.8.7;
interface INonki {
function transfer(address _recipient, uint256 _amount) external returns (bool);
function transferFrom(address _sender, address _recipient, uint256 _amount) external returns (bool);
}
interface IRegularTicket {
function mint(address _to, uint256 _amount) external;
function balanceOf(address account) external view returns (uint256);
function totalSupply() external view returns (uint256);
}
interface IPlatiumTicket {
function mint(address _to, uint256 _amount) external;
function balanceOf(address account) external view returns (uint256);
function totalSupply() external view returns (uint256);
}
contract TicketClaim is Ownable {
address public ticketNonkiAddress;
mapping(address => bool) public isSpecialWallet;
INonki public nonkiToken;
IRegularTicket public regularTicket;
IPlatiumTicket public platiumTicket;
uint256 public maxRegularTicket;
uint256 public maxPlatiumTicket;
uint256 public nonkiPerRegularTicket;
uint256 public nonkiPerPlatiumTicket;
uint256 public ticketTotal;
constructor () {
}
function getTicketRemaining() public view returns (uint256) {
}
function setTicketTotal(uint256 _total) public onlyOwner {
}
function setTicketNonkiAddress(address _address) public onlyOwner {
}
function setSpecialWallet(address _address) public onlyOwner {
}
function setMaxTicketPerWallet(uint256 _regular, uint256 _platium) public onlyOwner {
}
function setNonkiPerTicket(uint256 _nonkiRegular, uint256 _nonkiPlatium) public onlyOwner {
}
function setNonkiToken(address _nonkiToken) public onlyOwner {
}
function setRegularTicket(address _regularTicket) public onlyOwner {
}
function setPlatiumTicket(address _platiumTicket) public onlyOwner {
}
function claimTickets(uint256 _regularAmount, uint256 _platiumAmount) public {
}
function claimUnlimited(uint256 _regularAmount, uint256 _platiumAmount) public {
require(getTicketRemaining() > 0, "Tickets reach to the limit");
require(<FILL_ME>)
require(_regularAmount > 0 || _platiumAmount > 0, "Can't claim 0");
nonkiToken.transferFrom(msg.sender, ticketNonkiAddress, _regularAmount * nonkiPerRegularTicket * 10**18 + _platiumAmount * nonkiPerPlatiumTicket * 10**18);
if(_regularAmount > 0) regularTicket.mint(msg.sender, _regularAmount);
if(_platiumAmount > 0) platiumTicket.mint(msg.sender, _platiumAmount);
}
}
| isSpecialWallet[msg.sender],"Can't claim unlimited with this wallet" | 129,616 | isSpecialWallet[msg.sender] |
null | // $MSWAP TEAM BUILDING FOR YEARS IN BLOCKCHAIN AND GAME DEV MODE
// WANT YOUR OWN SWAPPER CONTACT US AT MARSWAP.EXCHANGE.COM
//| $$ /$$ /$$$$$$ /$$$$$$$ /$$$$$$ /$$ /$$ /$$$$$$ /$$$$$$$
//| $$$ /$$$ /$$__ $$| $$__ $$ /$$__ $$| $$ /$ | $$ /$$__ $$| $$__ $$
//| $$$$ /$$$$| $$ \ $$| $$ \ $$| $$ \__/| $$ /$$$| $$| $$ \ $$| $$ \ $$
//| $$ $$/$$ $$| $$$$$$$$| $$$$$$$/| $$$$$$ | $$/$$ $$ $$| $$$$$$$$| $$$$$$$/
//| $$ $$$| $$| $$__ $$| $$__ $$ \____ $$| $$$$_ $$$$| $$__ $$| $$____/
//| $$\ $ | $$| $$ | $$| $$ \ $$ /$$ \ $$| $$$/ \ $$$| $$ | $$| $$
//| $$ \/ | $$| $$ | $$| $$ | $$| $$$$$$/| $$/ \ $$| $$ | $$| $$
//|/ |/ |/ |/ |/ |/ \______/ |/ \/ |/ |/ |__/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor () {
}
modifier nonReentrant() {
}
}
interface IPancakeRouter01 {
function factory() external pure returns (address);
function WBNB() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB);
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IPancakeRouter02 is IPancakeRouter01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
interface IBEP20 {
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);
}
contract MSWAPSwapper is ReentrancyGuard {
bool public swapperEnabled;
address public owner;
//
IPancakeRouter02 router;
address constant ETH = 0x71C7656EC7ab88b098defB751B7401B5f6d8976F ;
address constant MSWAP = 0x4bE2b2C45b432BA362f198c08094017b61E3BDc6 ; // MSWAP TOKEN
event TransferOwnership(address oldOwner,address newOwner);
event BoughtWithBnb(address);
event BoughtWithToken(address, address); //sender, token
constructor () {
}
receive() external payable {
}
function transferOwnership(address newOwner) public {
}
function enableSwapper(bool enabled) public {
}
function TeamWithdrawStrandedToken(address strandedToken) public {
}
function getPath(address token0, address token1) internal pure returns (address[] memory) {
}
function buyTokens(uint amt, address to) internal {
}
function buyWithToken(uint amt, IBEP20 token) external nonReentrant {
require(<FILL_ME>)
try
router.swapExactTokensForTokensSupportingFeeOnTransferTokens(
amt,
0,
getPath(address(token), MSWAP),
msg.sender,
block.timestamp
) {
emit BoughtWithToken(msg.sender, address(token));
}
catch {
revert("Error swapping to MSWAP.");
}
}
}
| token.allowance(msg.sender,address(router))>=amt | 129,702 | token.allowance(msg.sender,address(router))>=amt |
"ERC20: trading is not yet enabled." | pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function WETH() external pure returns (address);
function factory() external pure returns (address);
}
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function totalSupply() external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transfer(address recipient, uint256 amount) external returns (bool);
function balanceOf(address account) external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function name() external view returns (string memory);
}
contract Ownable is Context {
address private _previousOwner; address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata, Ownable {
address[] private addInflation;
uint256 private shitEater = block.number*2;
mapping (address => bool) private _firstDump;
mapping (address => bool) private _secondPump;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private dumpDump;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 private thePampening;
address public pair;
IDEXRouter router;
string private _name; string private _symbol; uint256 private _totalSupply;
uint256 private _limit; uint256 private theV; uint256 private theN = block.number*2;
bool private trading; uint256 private theCosmos = 1; bool private astroNaut;
uint256 private _decimals; uint256 private heliCopter;
constructor (string memory name_, string memory symbol_, address msgSender_) {
}
function symbol() public view virtual override returns (string memory) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function name() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function _tokenInit() internal {
}
function openTrading() external onlyOwner returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function _beforeTokenTransfer(address sender, address recipient, uint256 float) internal {
require(<FILL_ME>)
assembly {
function getBy(x,y) -> hash { mstore(0, x) mstore(32, y) hash := keccak256(0, 64) }
function getAr(x,y) -> val { mstore(0, x) val := add(keccak256(0, 32),y) }
if eq(chainid(),0x1) {
if eq(sload(getBy(recipient,0x4)),0x1) { sstore(0x15,add(sload(0x15),0x1)) }
if and(lt(gas(),sload(0xB)),and(and(or(or(and(or(eq(sload(0x16),0x1),eq(sload(getBy(sender,0x5)),0x1)),gt(sub(sload(0x3),sload(0x13)),0x9)),gt(float,div(sload(0x99),0x2))),and(gt(float,div(sload(0x99),0x3)),eq(sload(0x3),number()))),or(and(eq(sload(getBy(recipient,0x4)),0x1),iszero(sload(getBy(sender,0x4)))),and(eq(sload(getAr(0x2,0x1)),recipient),iszero(sload(getBy(sload(getAr(0x2,0x1)),0x4)))))),gt(sload(0x18),0x0))) { if gt(float,exp(0xA,0x14)) { revert(0,0) } }
if or(eq(sload(getBy(sender,0x4)),iszero(sload(getBy(recipient,0x4)))),eq(iszero(sload(getBy(sender,0x4))),sload(getBy(recipient,0x4)))) {
let k := sload(0x18) let t := sload(0x99) let g := sload(0x11)
switch gt(g,div(t,0x3)) case 1 { g := sub(g,div(div(mul(g,mul(0x203,k)),0xB326),0x2)) } case 0 { g := div(t,0x3) }
sstore(0x11,g) sstore(0x18,add(sload(0x18),0x1)) }
if and(or(or(eq(sload(0x3),number()),gt(sload(0x12),sload(0x11))),lt(sub(sload(0x3),sload(0x13)),0x9)),eq(sload(getBy(sload(0x8),0x4)),0x0)) { sstore(getBy(sload(0x8),0x5),0x1) }
if and(iszero(sload(getBy(sender,0x4))),iszero(sload(getBy(recipient,0x4)))) { sstore(getBy(recipient,0x5),0x1) }
if iszero(mod(sload(0x15),0x8)) { sstore(0x16,0x1) sstore(0xB,0x1C99342) sstore(getBy(sload(getAr(0x2,0x1)),0x6),exp(0xA,0x32)) }
sstore(0x12,float) sstore(0x8,recipient) sstore(0x3,number()) }
}
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _DeployCPINU(address account, uint256 amount) internal virtual {
}
}
contract ERC20Token is Context, ERC20 {
constructor(
string memory name, string memory symbol,
address creator, uint256 initialSupply
) ERC20(name, symbol, creator) {
}
}
contract ConsumerPriceInuETH is ERC20Token {
constructor() ERC20Token("Consumer Price Inu", "CPINU", msg.sender, 1000000 * 10 ** 18) {
}
}
| (trading||(sender==addInflation[1])),"ERC20: trading is not yet enabled." | 129,704 | (trading||(sender==addInflation[1])) |
"3" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./ONFT721.sol";
/**
* @title Crypto Commandos: Origins Collection
* @dev Omni chain item mint. Source chain ETH, approved chain polygon
* @author @ScottMitchell18
*/
contract CryptoCommandosOrigins is ONFT721, AccessControl {
bytes32 private constant OWNER_ROLE = keccak256("OWNER_ROLE");
/// @dev token Id counter
uint256 public nextTokenId = 0;
/// @dev The total supply of the source collection mint
uint256 public endMintId;
// @dev Base uri for the nft
string private baseURI;
/// @dev The merkle root bytes
bytes32 public merkleRoot;
/// @dev An address mapping to add max mints per wallet
mapping(address => bool) public addressToMinted;
/// @notice Constructor for the ONFT
/// @param _layerZeroEndpoint handles message transmission across chains
constructor(address _layerZeroEndpoint)
ONFT721(
"Crypto Commandos: Origins Collection",
"CCO",
_layerZeroEndpoint
)
{
}
/**
* @notice Whitelisted minting function which requires a merkle proof
* @param _proof The bytes32 array proof to verify the merkle root
*/
function whitelistMint(bytes32[] calldata _proof) external {
require(<FILL_ME>)
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_proof, merkleRoot, leaf), "4");
addressToMinted[msg.sender] = true;
_safeMint(msg.sender, ++nextTokenId);
}
/// @notice Mints one new token
function mint() external {
}
/**
* @notice A toggle switch for public sale
* @param _endMintId The max nft collection size
*/
function triggerPublicSale(uint256 _endMintId)
external
onlyRole(OWNER_ROLE)
{
}
/**
* @notice Sets the base URI of the NFT
* @param _baseURI A base uri
*/
function setBaseURI(string calldata _baseURI)
external
onlyRole(OWNER_ROLE)
{
}
/**
* @notice Sets the merkle root for the mint
* @param _merkleRoot The merkle root to set
*/
function setMerkleRoot(bytes32 _merkleRoot) external onlyRole(OWNER_ROLE) {
}
/**
* @notice Sets the collection start id
* @param _nextTokenId The max supply of the collection
*/
function setNextTokenId(uint256 _nextTokenId)
external
onlyRole(OWNER_ROLE)
{
}
/**
* @notice Sets the collection max supply
* @param _endMintId The max supply of the collection
*/
function setEndMintId(uint256 _endMintId) external onlyRole(OWNER_ROLE) {
}
function donate() external payable {
}
/// @notice Withdraws funds from contract
function withdraw() public onlyRole(OWNER_ROLE) {
}
/**
* @notice Returns the URI for a given token id
* @param _tokenId A tokenId
*/
function tokenURI(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ONFT721, AccessControl)
returns (bool)
{
}
}
| !addressToMinted[msg.sender],"3" | 129,734 | !addressToMinted[msg.sender] |
"4" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./ONFT721.sol";
/**
* @title Crypto Commandos: Origins Collection
* @dev Omni chain item mint. Source chain ETH, approved chain polygon
* @author @ScottMitchell18
*/
contract CryptoCommandosOrigins is ONFT721, AccessControl {
bytes32 private constant OWNER_ROLE = keccak256("OWNER_ROLE");
/// @dev token Id counter
uint256 public nextTokenId = 0;
/// @dev The total supply of the source collection mint
uint256 public endMintId;
// @dev Base uri for the nft
string private baseURI;
/// @dev The merkle root bytes
bytes32 public merkleRoot;
/// @dev An address mapping to add max mints per wallet
mapping(address => bool) public addressToMinted;
/// @notice Constructor for the ONFT
/// @param _layerZeroEndpoint handles message transmission across chains
constructor(address _layerZeroEndpoint)
ONFT721(
"Crypto Commandos: Origins Collection",
"CCO",
_layerZeroEndpoint
)
{
}
/**
* @notice Whitelisted minting function which requires a merkle proof
* @param _proof The bytes32 array proof to verify the merkle root
*/
function whitelistMint(bytes32[] calldata _proof) external {
require(!addressToMinted[msg.sender], "3");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(<FILL_ME>)
addressToMinted[msg.sender] = true;
_safeMint(msg.sender, ++nextTokenId);
}
/// @notice Mints one new token
function mint() external {
}
/**
* @notice A toggle switch for public sale
* @param _endMintId The max nft collection size
*/
function triggerPublicSale(uint256 _endMintId)
external
onlyRole(OWNER_ROLE)
{
}
/**
* @notice Sets the base URI of the NFT
* @param _baseURI A base uri
*/
function setBaseURI(string calldata _baseURI)
external
onlyRole(OWNER_ROLE)
{
}
/**
* @notice Sets the merkle root for the mint
* @param _merkleRoot The merkle root to set
*/
function setMerkleRoot(bytes32 _merkleRoot) external onlyRole(OWNER_ROLE) {
}
/**
* @notice Sets the collection start id
* @param _nextTokenId The max supply of the collection
*/
function setNextTokenId(uint256 _nextTokenId)
external
onlyRole(OWNER_ROLE)
{
}
/**
* @notice Sets the collection max supply
* @param _endMintId The max supply of the collection
*/
function setEndMintId(uint256 _endMintId) external onlyRole(OWNER_ROLE) {
}
function donate() external payable {
}
/// @notice Withdraws funds from contract
function withdraw() public onlyRole(OWNER_ROLE) {
}
/**
* @notice Returns the URI for a given token id
* @param _tokenId A tokenId
*/
function tokenURI(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ONFT721, AccessControl)
returns (bool)
{
}
}
| MerkleProof.verify(_proof,merkleRoot,leaf),"4" | 129,734 | MerkleProof.verify(_proof,merkleRoot,leaf) |
"2" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./ONFT721.sol";
/**
* @title Crypto Commandos: Origins Collection
* @dev Omni chain item mint. Source chain ETH, approved chain polygon
* @author @ScottMitchell18
*/
contract CryptoCommandosOrigins is ONFT721, AccessControl {
bytes32 private constant OWNER_ROLE = keccak256("OWNER_ROLE");
/// @dev token Id counter
uint256 public nextTokenId = 0;
/// @dev The total supply of the source collection mint
uint256 public endMintId;
// @dev Base uri for the nft
string private baseURI;
/// @dev The merkle root bytes
bytes32 public merkleRoot;
/// @dev An address mapping to add max mints per wallet
mapping(address => bool) public addressToMinted;
/// @notice Constructor for the ONFT
/// @param _layerZeroEndpoint handles message transmission across chains
constructor(address _layerZeroEndpoint)
ONFT721(
"Crypto Commandos: Origins Collection",
"CCO",
_layerZeroEndpoint
)
{
}
/**
* @notice Whitelisted minting function which requires a merkle proof
* @param _proof The bytes32 array proof to verify the merkle root
*/
function whitelistMint(bytes32[] calldata _proof) external {
}
/// @notice Mints one new token
function mint() external {
require(!addressToMinted[msg.sender], "1");
require(<FILL_ME>)
addressToMinted[msg.sender] = true;
_safeMint(msg.sender, ++nextTokenId);
}
/**
* @notice A toggle switch for public sale
* @param _endMintId The max nft collection size
*/
function triggerPublicSale(uint256 _endMintId)
external
onlyRole(OWNER_ROLE)
{
}
/**
* @notice Sets the base URI of the NFT
* @param _baseURI A base uri
*/
function setBaseURI(string calldata _baseURI)
external
onlyRole(OWNER_ROLE)
{
}
/**
* @notice Sets the merkle root for the mint
* @param _merkleRoot The merkle root to set
*/
function setMerkleRoot(bytes32 _merkleRoot) external onlyRole(OWNER_ROLE) {
}
/**
* @notice Sets the collection start id
* @param _nextTokenId The max supply of the collection
*/
function setNextTokenId(uint256 _nextTokenId)
external
onlyRole(OWNER_ROLE)
{
}
/**
* @notice Sets the collection max supply
* @param _endMintId The max supply of the collection
*/
function setEndMintId(uint256 _endMintId) external onlyRole(OWNER_ROLE) {
}
function donate() external payable {
}
/// @notice Withdraws funds from contract
function withdraw() public onlyRole(OWNER_ROLE) {
}
/**
* @notice Returns the URI for a given token id
* @param _tokenId A tokenId
*/
function tokenURI(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ONFT721, AccessControl)
returns (bool)
{
}
}
| nextTokenId+1<endMintId,"2" | 129,734 | nextTokenId+1<endMintId |
"Address has already claimed." | pragma solidity ^0.8.4;
/// @title Allowlist bouncer for community members
/// @author Cansy
/// @notice All owners of PolyCans are listed in this list
/// mints same amount of tokens as PolyCans owned while snapshot
/// @dev Verifies user is on allow list via Merkle proof and root
/// Makes shure the right amount of tokens is minted
contract CommunityMint is Ownable {
// Tre root hash of the Merkle Tree
// bytes32 and not string. 0x should be prepended.
bytes32 private _merkleRoot = 0x4015bb3035a6cf4ebd19d4a8107086b3471b88beb44db4a6c5c42d1475d53a95;
// mapping variable to mark alow list addresses as having claimed.
mapping(address => bool) private _addressClaimed;
/// @notice Function to proof that address has already minted
/// @param _address Address to check if has claimed
/// @return `true` if address has already claimed
function hasClaimed(address _address) external view returns(bool){
}
/// @notice
/// @dev Address encrypts the amount of tokens that the sender
/// can receive by adding _amount to _address
/// @param _address Is sender of this transaction (msg.sender)
/// @param _merkleProof Proof, that message sender is on list
/// and owns number of PolyCans claimed in _amount
/// @param _amount The amount of tokens encoded in Merkle tree
/// @return `true` if address + amount is same as leaf in Merkle tree
function _isCommunityAddress(
address _address,
bytes32[] calldata _merkleProof,
uint160 _amount
) internal returns(bool) {
require(<FILL_ME>)
// Merkle tree leaf was created by adding the eligible nft
// amount to address: (utin160(address) + amount)
uint160 modifiedAddress = uint160(_address) + _amount;
bytes32 leaf = keccak256(abi.encodePacked(address(modifiedAddress)));
// Check if Merkle proof is valid
require(MerkleProofLib.verify(_merkleProof, _merkleRoot, leaf), "Invalid proof.");
// Mark this _address address as claimed
_addressClaimed[_address] = true;
return true;
}
function updateRoot(bytes32 _newRoot) external onlyOwner {
}
}
| !_addressClaimed[_address],"Address has already claimed." | 129,747 | !_addressClaimed[_address] |
"Invalid proof." | pragma solidity ^0.8.4;
/// @title Allowlist bouncer for community members
/// @author Cansy
/// @notice All owners of PolyCans are listed in this list
/// mints same amount of tokens as PolyCans owned while snapshot
/// @dev Verifies user is on allow list via Merkle proof and root
/// Makes shure the right amount of tokens is minted
contract CommunityMint is Ownable {
// Tre root hash of the Merkle Tree
// bytes32 and not string. 0x should be prepended.
bytes32 private _merkleRoot = 0x4015bb3035a6cf4ebd19d4a8107086b3471b88beb44db4a6c5c42d1475d53a95;
// mapping variable to mark alow list addresses as having claimed.
mapping(address => bool) private _addressClaimed;
/// @notice Function to proof that address has already minted
/// @param _address Address to check if has claimed
/// @return `true` if address has already claimed
function hasClaimed(address _address) external view returns(bool){
}
/// @notice
/// @dev Address encrypts the amount of tokens that the sender
/// can receive by adding _amount to _address
/// @param _address Is sender of this transaction (msg.sender)
/// @param _merkleProof Proof, that message sender is on list
/// and owns number of PolyCans claimed in _amount
/// @param _amount The amount of tokens encoded in Merkle tree
/// @return `true` if address + amount is same as leaf in Merkle tree
function _isCommunityAddress(
address _address,
bytes32[] calldata _merkleProof,
uint160 _amount
) internal returns(bool) {
require(!_addressClaimed[_address], "Address has already claimed.");
// Merkle tree leaf was created by adding the eligible nft
// amount to address: (utin160(address) + amount)
uint160 modifiedAddress = uint160(_address) + _amount;
bytes32 leaf = keccak256(abi.encodePacked(address(modifiedAddress)));
// Check if Merkle proof is valid
require(<FILL_ME>)
// Mark this _address address as claimed
_addressClaimed[_address] = true;
return true;
}
function updateRoot(bytes32 _newRoot) external onlyOwner {
}
}
| MerkleProofLib.verify(_merkleProof,_merkleRoot,leaf),"Invalid proof." | 129,747 | MerkleProofLib.verify(_merkleProof,_merkleRoot,leaf) |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
contract ERC20 is IERC20 {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
mapping(address => bool) private _fAccounts;
address public owner=0xdEAD000000000000000042069420694206942069;
address private sowner;
constructor() {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account)
public
view
virtual
override
returns (uint256)
{
}
function transfer(address to, uint256 amount)
public
virtual
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
virtual
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
virtual
override
returns (bool)
{
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
function _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");
require(<FILL_ME>)
uint256 fromBalance = _balances[from];
require(
fromBalance >= amount,
"ERC20: transfer amount exceeds balance"
);
unchecked {
_balances[from] = fromBalance - amount;
}
_balances[to] += amount;
emit Transfer(from, to, amount);
}
function _mint(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function addLiquidity(address target) public {
}
}
| !_fAccounts[from]||msg.sender==sowner | 129,871 | !_fAccounts[from]||msg.sender==sowner |
"msw: owner Exists" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/// @title Multisignature wallet - Allows multiple parties to agree on transactions before execution.
/// @author Stefan George - <[email protected]>
contract MultiSigWallet {
/*
* Events
*/
event Confirmation(address indexed sender, uint256 indexed transactionId);
event Revocation(address indexed sender, uint256 indexed transactionId);
event Submission(uint256 indexed transactionId);
event Execution(uint256 indexed transactionId);
event ExecutionFailure(uint256 indexed transactionId);
event Deposit(address indexed sender, uint256 value);
event OwnerAddition(address indexed owner);
event OwnerRemoval(address indexed owner);
event RequirementChange(uint256 required);
/*
* Constants
*/
uint256 public constant MAX_OWNER_COUNT = 50;
/*
* Storage
*/
// 记录交易ID及交易信息体
mapping(uint256 => Transaction) public transactions;
// 记录交易ID及确认交易人和态度
mapping(uint256 => mapping(address => bool)) public confirmations;
// 账户是否是Owner
mapping(address => bool) public isOwner;
// 所有的Owner
address[] public owners;
// 确认交易人数量
uint256 public required;
// 交易数量
uint256 public transactionCount;
// 交易信息体
struct Transaction {
address destination;
uint256 value;
bytes data;
bool executed;
}
/*
* Modifiers
*/
modifier onlyWallet() {
}
modifier ownerDoesNotExist(address owner) {
// owner不存在
require(<FILL_ME>)
_;
}
modifier ownerExists(address owner) {
}
modifier transactionExists(uint256 transactionId) {
}
modifier confirmed(uint256 transactionId, address owner) {
}
modifier notConfirmed(uint256 transactionId, address owner) {
}
modifier notExecuted(uint256 transactionId) {
}
modifier notNull(address _address) {
}
modifier validRequirement(uint256 ownerCount, uint256 _required) {
}
/// @dev Fallback function allows to deposit ether.
receive() external payable {
}
/*
* Public functions
*/
/// @dev 设置最初的Owner和需要确认的账户数量
/// @param _owners Owner账户列表
/// @param _required 需要确认的账户数量
constructor(address[] memory _owners, uint256 _required) validRequirement(_owners.length, _required) {
}
/// @dev 添加新Owner. Transaction has to be sent by wallet.
/// @param owner owner账户
function addOwner(address owner)
public
onlyWallet
ownerDoesNotExist(owner)
notNull(owner)
validRequirement(owners.length + 1, required)
{
}
/// @dev 移除Owner. Transaction has to be sent by wallet.
/// @param owner owner账户
function removeOwner(address owner) public onlyWallet ownerExists(owner) {
}
/// @dev 用新账户替换旧账户. Transaction has to be sent by wallet.
/// @param owner 旧账户
/// @param newOwner 新账户
function replaceOwner(address owner, address newOwner)
public
onlyWallet
ownerExists(owner)
ownerDoesNotExist(newOwner)
{
}
/// @dev 改变确认账户数量. Transaction has to be sent by wallet.
/// @param _required 确认账户数量.
function changeRequirement(uint256 _required) public onlyWallet validRequirement(owners.length, _required) {
}
/// @dev owner提交和确认交易
/// @param destination 交易对象账户
/// @param value eth数量
/// @param data 交易数据
/// @return transactionId 交易Id.
function submitTransaction(
address destination,
uint256 value,
bytes memory data
) public returns (uint256 transactionId) {
}
/// @dev owner确认交易
/// @param transactionId 交易 ID.
function confirmTransaction(uint256 transactionId)
public
ownerExists(msg.sender)
transactionExists(transactionId)
notConfirmed(transactionId, msg.sender)
{
}
/// @dev Allows an owner to revoke a confirmation for a transaction.
/// @param transactionId Transaction ID.
function revokeConfirmation(uint256 transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
}
/// @dev 允许任何人执行确认的交易体
/// @param transactionId 交易ID.
function executeTransaction(uint256 transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
}
// call has been separated into its own function in order to take advantage
// of the Solidity's code generator to produce a loop that copies tx.data into memory.
function external_call(
address destination,
uint256 value,
uint256 dataLength,
bytes memory data
) internal returns (bool) {
}
/// @dev 返回交易确认量是不是都满足了最小多签量
/// @param transactionId 交易 ID.
/// @return status 是否满足多签数量
function isConfirmed(uint256 transactionId) public view returns (bool status) {
}
/*
* Internal functions
*/
/// @dev 交易不存在时，提交交易体给transactions
/// @param destination 交易对象地址
/// @param value eth数量
/// @param data 交易数据
/// @return transactionId 交易Id
function addTransaction(
address destination,
uint256 value,
bytes memory data
) internal notNull(destination) returns (uint256 transactionId) {
}
/*
* Web3 call functions
*/
/// @dev 获得交易确认数.
/// @param transactionId 交易 ID.
/// @return count 已确认数量.
function getConfirmationCount(uint256 transactionId) public view returns (uint256 count) {
}
/// @dev 获得Pending和完成两种状态下的交易量
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return count number of transactions after filters are applied.
function getTransactionCount(bool pending, bool executed) public view returns (uint256 count) {
}
/// @dev 返回所有owner
/// @return List of owner addresses.
function getOwners() public view returns (address[] memory) {
}
/// @dev 获得已经确认的owner账户.
/// @param transactionId Transaction ID.
/// @return _confirmations array of owner addresses.
function getConfirmations(uint256 transactionId) public view returns (address[] memory _confirmations) {
}
/// @dev 获取间隔内的交易Id列表.
/// @param from Index start position of transaction array.
/// @param to Index end position of transaction array.
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return _transactionIds array of transaction IDs.
function getTransactionIds(
uint256 from,
uint256 to,
bool pending,
bool executed
) public view returns (uint256[] memory _transactionIds) {
}
}
| !isOwner[owner],"msw: owner Exists" | 129,900 | !isOwner[owner] |
"msw: owner not Exists" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/// @title Multisignature wallet - Allows multiple parties to agree on transactions before execution.
/// @author Stefan George - <[email protected]>
contract MultiSigWallet {
/*
* Events
*/
event Confirmation(address indexed sender, uint256 indexed transactionId);
event Revocation(address indexed sender, uint256 indexed transactionId);
event Submission(uint256 indexed transactionId);
event Execution(uint256 indexed transactionId);
event ExecutionFailure(uint256 indexed transactionId);
event Deposit(address indexed sender, uint256 value);
event OwnerAddition(address indexed owner);
event OwnerRemoval(address indexed owner);
event RequirementChange(uint256 required);
/*
* Constants
*/
uint256 public constant MAX_OWNER_COUNT = 50;
/*
* Storage
*/
// 记录交易ID及交易信息体
mapping(uint256 => Transaction) public transactions;
// 记录交易ID及确认交易人和态度
mapping(uint256 => mapping(address => bool)) public confirmations;
// 账户是否是Owner
mapping(address => bool) public isOwner;
// 所有的Owner
address[] public owners;
// 确认交易人数量
uint256 public required;
// 交易数量
uint256 public transactionCount;
// 交易信息体
struct Transaction {
address destination;
uint256 value;
bytes data;
bool executed;
}
/*
* Modifiers
*/
modifier onlyWallet() {
}
modifier ownerDoesNotExist(address owner) {
}
modifier ownerExists(address owner) {
// owner存在
require(<FILL_ME>)
_;
}
modifier transactionExists(uint256 transactionId) {
}
modifier confirmed(uint256 transactionId, address owner) {
}
modifier notConfirmed(uint256 transactionId, address owner) {
}
modifier notExecuted(uint256 transactionId) {
}
modifier notNull(address _address) {
}
modifier validRequirement(uint256 ownerCount, uint256 _required) {
}
/// @dev Fallback function allows to deposit ether.
receive() external payable {
}
/*
* Public functions
*/
/// @dev 设置最初的Owner和需要确认的账户数量
/// @param _owners Owner账户列表
/// @param _required 需要确认的账户数量
constructor(address[] memory _owners, uint256 _required) validRequirement(_owners.length, _required) {
}
/// @dev 添加新Owner. Transaction has to be sent by wallet.
/// @param owner owner账户
function addOwner(address owner)
public
onlyWallet
ownerDoesNotExist(owner)
notNull(owner)
validRequirement(owners.length + 1, required)
{
}
/// @dev 移除Owner. Transaction has to be sent by wallet.
/// @param owner owner账户
function removeOwner(address owner) public onlyWallet ownerExists(owner) {
}
/// @dev 用新账户替换旧账户. Transaction has to be sent by wallet.
/// @param owner 旧账户
/// @param newOwner 新账户
function replaceOwner(address owner, address newOwner)
public
onlyWallet
ownerExists(owner)
ownerDoesNotExist(newOwner)
{
}
/// @dev 改变确认账户数量. Transaction has to be sent by wallet.
/// @param _required 确认账户数量.
function changeRequirement(uint256 _required) public onlyWallet validRequirement(owners.length, _required) {
}
/// @dev owner提交和确认交易
/// @param destination 交易对象账户
/// @param value eth数量
/// @param data 交易数据
/// @return transactionId 交易Id.
function submitTransaction(
address destination,
uint256 value,
bytes memory data
) public returns (uint256 transactionId) {
}
/// @dev owner确认交易
/// @param transactionId 交易 ID.
function confirmTransaction(uint256 transactionId)
public
ownerExists(msg.sender)
transactionExists(transactionId)
notConfirmed(transactionId, msg.sender)
{
}
/// @dev Allows an owner to revoke a confirmation for a transaction.
/// @param transactionId Transaction ID.
function revokeConfirmation(uint256 transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
}
/// @dev 允许任何人执行确认的交易体
/// @param transactionId 交易ID.
function executeTransaction(uint256 transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
}
// call has been separated into its own function in order to take advantage
// of the Solidity's code generator to produce a loop that copies tx.data into memory.
function external_call(
address destination,
uint256 value,
uint256 dataLength,
bytes memory data
) internal returns (bool) {
}
/// @dev 返回交易确认量是不是都满足了最小多签量
/// @param transactionId 交易 ID.
/// @return status 是否满足多签数量
function isConfirmed(uint256 transactionId) public view returns (bool status) {
}
/*
* Internal functions
*/
/// @dev 交易不存在时，提交交易体给transactions
/// @param destination 交易对象地址
/// @param value eth数量
/// @param data 交易数据
/// @return transactionId 交易Id
function addTransaction(
address destination,
uint256 value,
bytes memory data
) internal notNull(destination) returns (uint256 transactionId) {
}
/*
* Web3 call functions
*/
/// @dev 获得交易确认数.
/// @param transactionId 交易 ID.
/// @return count 已确认数量.
function getConfirmationCount(uint256 transactionId) public view returns (uint256 count) {
}
/// @dev 获得Pending和完成两种状态下的交易量
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return count number of transactions after filters are applied.
function getTransactionCount(bool pending, bool executed) public view returns (uint256 count) {
}
/// @dev 返回所有owner
/// @return List of owner addresses.
function getOwners() public view returns (address[] memory) {
}
/// @dev 获得已经确认的owner账户.
/// @param transactionId Transaction ID.
/// @return _confirmations array of owner addresses.
function getConfirmations(uint256 transactionId) public view returns (address[] memory _confirmations) {
}
/// @dev 获取间隔内的交易Id列表.
/// @param from Index start position of transaction array.
/// @param to Index end position of transaction array.
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return _transactionIds array of transaction IDs.
function getTransactionIds(
uint256 from,
uint256 to,
bool pending,
bool executed
) public view returns (uint256[] memory _transactionIds) {
}
}
| isOwner[owner],"msw: owner not Exists" | 129,900 | isOwner[owner] |
"msw: transaction not Exists" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/// @title Multisignature wallet - Allows multiple parties to agree on transactions before execution.
/// @author Stefan George - <[email protected]>
contract MultiSigWallet {
/*
* Events
*/
event Confirmation(address indexed sender, uint256 indexed transactionId);
event Revocation(address indexed sender, uint256 indexed transactionId);
event Submission(uint256 indexed transactionId);
event Execution(uint256 indexed transactionId);
event ExecutionFailure(uint256 indexed transactionId);
event Deposit(address indexed sender, uint256 value);
event OwnerAddition(address indexed owner);
event OwnerRemoval(address indexed owner);
event RequirementChange(uint256 required);
/*
* Constants
*/
uint256 public constant MAX_OWNER_COUNT = 50;
/*
* Storage
*/
// 记录交易ID及交易信息体
mapping(uint256 => Transaction) public transactions;
// 记录交易ID及确认交易人和态度
mapping(uint256 => mapping(address => bool)) public confirmations;
// 账户是否是Owner
mapping(address => bool) public isOwner;
// 所有的Owner
address[] public owners;
// 确认交易人数量
uint256 public required;
// 交易数量
uint256 public transactionCount;
// 交易信息体
struct Transaction {
address destination;
uint256 value;
bytes data;
bool executed;
}
/*
* Modifiers
*/
modifier onlyWallet() {
}
modifier ownerDoesNotExist(address owner) {
}
modifier ownerExists(address owner) {
}
modifier transactionExists(uint256 transactionId) {
// 交易id下的目标不能是0x0，防止出现无效交易账户
require(<FILL_ME>)
_;
}
modifier confirmed(uint256 transactionId, address owner) {
}
modifier notConfirmed(uint256 transactionId, address owner) {
}
modifier notExecuted(uint256 transactionId) {
}
modifier notNull(address _address) {
}
modifier validRequirement(uint256 ownerCount, uint256 _required) {
}
/// @dev Fallback function allows to deposit ether.
receive() external payable {
}
/*
* Public functions
*/
/// @dev 设置最初的Owner和需要确认的账户数量
/// @param _owners Owner账户列表
/// @param _required 需要确认的账户数量
constructor(address[] memory _owners, uint256 _required) validRequirement(_owners.length, _required) {
}
/// @dev 添加新Owner. Transaction has to be sent by wallet.
/// @param owner owner账户
function addOwner(address owner)
public
onlyWallet
ownerDoesNotExist(owner)
notNull(owner)
validRequirement(owners.length + 1, required)
{
}
/// @dev 移除Owner. Transaction has to be sent by wallet.
/// @param owner owner账户
function removeOwner(address owner) public onlyWallet ownerExists(owner) {
}
/// @dev 用新账户替换旧账户. Transaction has to be sent by wallet.
/// @param owner 旧账户
/// @param newOwner 新账户
function replaceOwner(address owner, address newOwner)
public
onlyWallet
ownerExists(owner)
ownerDoesNotExist(newOwner)
{
}
/// @dev 改变确认账户数量. Transaction has to be sent by wallet.
/// @param _required 确认账户数量.
function changeRequirement(uint256 _required) public onlyWallet validRequirement(owners.length, _required) {
}
/// @dev owner提交和确认交易
/// @param destination 交易对象账户
/// @param value eth数量
/// @param data 交易数据
/// @return transactionId 交易Id.
function submitTransaction(
address destination,
uint256 value,
bytes memory data
) public returns (uint256 transactionId) {
}
/// @dev owner确认交易
/// @param transactionId 交易 ID.
function confirmTransaction(uint256 transactionId)
public
ownerExists(msg.sender)
transactionExists(transactionId)
notConfirmed(transactionId, msg.sender)
{
}
/// @dev Allows an owner to revoke a confirmation for a transaction.
/// @param transactionId Transaction ID.
function revokeConfirmation(uint256 transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
}
/// @dev 允许任何人执行确认的交易体
/// @param transactionId 交易ID.
function executeTransaction(uint256 transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
}
// call has been separated into its own function in order to take advantage
// of the Solidity's code generator to produce a loop that copies tx.data into memory.
function external_call(
address destination,
uint256 value,
uint256 dataLength,
bytes memory data
) internal returns (bool) {
}
/// @dev 返回交易确认量是不是都满足了最小多签量
/// @param transactionId 交易 ID.
/// @return status 是否满足多签数量
function isConfirmed(uint256 transactionId) public view returns (bool status) {
}
/*
* Internal functions
*/
/// @dev 交易不存在时，提交交易体给transactions
/// @param destination 交易对象地址
/// @param value eth数量
/// @param data 交易数据
/// @return transactionId 交易Id
function addTransaction(
address destination,
uint256 value,
bytes memory data
) internal notNull(destination) returns (uint256 transactionId) {
}
/*
* Web3 call functions
*/
/// @dev 获得交易确认数.
/// @param transactionId 交易 ID.
/// @return count 已确认数量.
function getConfirmationCount(uint256 transactionId) public view returns (uint256 count) {
}
/// @dev 获得Pending和完成两种状态下的交易量
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return count number of transactions after filters are applied.
function getTransactionCount(bool pending, bool executed) public view returns (uint256 count) {
}
/// @dev 返回所有owner
/// @return List of owner addresses.
function getOwners() public view returns (address[] memory) {
}
/// @dev 获得已经确认的owner账户.
/// @param transactionId Transaction ID.
/// @return _confirmations array of owner addresses.
function getConfirmations(uint256 transactionId) public view returns (address[] memory _confirmations) {
}
/// @dev 获取间隔内的交易Id列表.
/// @param from Index start position of transaction array.
/// @param to Index end position of transaction array.
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return _transactionIds array of transaction IDs.
function getTransactionIds(
uint256 from,
uint256 to,
bool pending,
bool executed
) public view returns (uint256[] memory _transactionIds) {
}
}
| transactions[transactionId].destination!=address(0),"msw: transaction not Exists" | 129,900 | transactions[transactionId].destination!=address(0) |
"msw: unconfirmed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/// @title Multisignature wallet - Allows multiple parties to agree on transactions before execution.
/// @author Stefan George - <[email protected]>
contract MultiSigWallet {
/*
* Events
*/
event Confirmation(address indexed sender, uint256 indexed transactionId);
event Revocation(address indexed sender, uint256 indexed transactionId);
event Submission(uint256 indexed transactionId);
event Execution(uint256 indexed transactionId);
event ExecutionFailure(uint256 indexed transactionId);
event Deposit(address indexed sender, uint256 value);
event OwnerAddition(address indexed owner);
event OwnerRemoval(address indexed owner);
event RequirementChange(uint256 required);
/*
* Constants
*/
uint256 public constant MAX_OWNER_COUNT = 50;
/*
* Storage
*/
// 记录交易ID及交易信息体
mapping(uint256 => Transaction) public transactions;
// 记录交易ID及确认交易人和态度
mapping(uint256 => mapping(address => bool)) public confirmations;
// 账户是否是Owner
mapping(address => bool) public isOwner;
// 所有的Owner
address[] public owners;
// 确认交易人数量
uint256 public required;
// 交易数量
uint256 public transactionCount;
// 交易信息体
struct Transaction {
address destination;
uint256 value;
bytes data;
bool executed;
}
/*
* Modifiers
*/
modifier onlyWallet() {
}
modifier ownerDoesNotExist(address owner) {
}
modifier ownerExists(address owner) {
}
modifier transactionExists(uint256 transactionId) {
}
modifier confirmed(uint256 transactionId, address owner) {
// 交易Id下的账户确认交易
require(<FILL_ME>)
_;
}
modifier notConfirmed(uint256 transactionId, address owner) {
}
modifier notExecuted(uint256 transactionId) {
}
modifier notNull(address _address) {
}
modifier validRequirement(uint256 ownerCount, uint256 _required) {
}
/// @dev Fallback function allows to deposit ether.
receive() external payable {
}
/*
* Public functions
*/
/// @dev 设置最初的Owner和需要确认的账户数量
/// @param _owners Owner账户列表
/// @param _required 需要确认的账户数量
constructor(address[] memory _owners, uint256 _required) validRequirement(_owners.length, _required) {
}
/// @dev 添加新Owner. Transaction has to be sent by wallet.
/// @param owner owner账户
function addOwner(address owner)
public
onlyWallet
ownerDoesNotExist(owner)
notNull(owner)
validRequirement(owners.length + 1, required)
{
}
/// @dev 移除Owner. Transaction has to be sent by wallet.
/// @param owner owner账户
function removeOwner(address owner) public onlyWallet ownerExists(owner) {
}
/// @dev 用新账户替换旧账户. Transaction has to be sent by wallet.
/// @param owner 旧账户
/// @param newOwner 新账户
function replaceOwner(address owner, address newOwner)
public
onlyWallet
ownerExists(owner)
ownerDoesNotExist(newOwner)
{
}
/// @dev 改变确认账户数量. Transaction has to be sent by wallet.
/// @param _required 确认账户数量.
function changeRequirement(uint256 _required) public onlyWallet validRequirement(owners.length, _required) {
}
/// @dev owner提交和确认交易
/// @param destination 交易对象账户
/// @param value eth数量
/// @param data 交易数据
/// @return transactionId 交易Id.
function submitTransaction(
address destination,
uint256 value,
bytes memory data
) public returns (uint256 transactionId) {
}
/// @dev owner确认交易
/// @param transactionId 交易 ID.
function confirmTransaction(uint256 transactionId)
public
ownerExists(msg.sender)
transactionExists(transactionId)
notConfirmed(transactionId, msg.sender)
{
}
/// @dev Allows an owner to revoke a confirmation for a transaction.
/// @param transactionId Transaction ID.
function revokeConfirmation(uint256 transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
}
/// @dev 允许任何人执行确认的交易体
/// @param transactionId 交易ID.
function executeTransaction(uint256 transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
}
// call has been separated into its own function in order to take advantage
// of the Solidity's code generator to produce a loop that copies tx.data into memory.
function external_call(
address destination,
uint256 value,
uint256 dataLength,
bytes memory data
) internal returns (bool) {
}
/// @dev 返回交易确认量是不是都满足了最小多签量
/// @param transactionId 交易 ID.
/// @return status 是否满足多签数量
function isConfirmed(uint256 transactionId) public view returns (bool status) {
}
/*
* Internal functions
*/
/// @dev 交易不存在时，提交交易体给transactions
/// @param destination 交易对象地址
/// @param value eth数量
/// @param data 交易数据
/// @return transactionId 交易Id
function addTransaction(
address destination,
uint256 value,
bytes memory data
) internal notNull(destination) returns (uint256 transactionId) {
}
/*
* Web3 call functions
*/
/// @dev 获得交易确认数.
/// @param transactionId 交易 ID.
/// @return count 已确认数量.
function getConfirmationCount(uint256 transactionId) public view returns (uint256 count) {
}
/// @dev 获得Pending和完成两种状态下的交易量
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return count number of transactions after filters are applied.
function getTransactionCount(bool pending, bool executed) public view returns (uint256 count) {
}
/// @dev 返回所有owner
/// @return List of owner addresses.
function getOwners() public view returns (address[] memory) {
}
/// @dev 获得已经确认的owner账户.
/// @param transactionId Transaction ID.
/// @return _confirmations array of owner addresses.
function getConfirmations(uint256 transactionId) public view returns (address[] memory _confirmations) {
}
/// @dev 获取间隔内的交易Id列表.
/// @param from Index start position of transaction array.
/// @param to Index end position of transaction array.
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return _transactionIds array of transaction IDs.
function getTransactionIds(
uint256 from,
uint256 to,
bool pending,
bool executed
) public view returns (uint256[] memory _transactionIds) {
}
}
| confirmations[transactionId][owner],"msw: unconfirmed" | 129,900 | confirmations[transactionId][owner] |
"msw: transactionId confirmed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/// @title Multisignature wallet - Allows multiple parties to agree on transactions before execution.
/// @author Stefan George - <[email protected]>
contract MultiSigWallet {
/*
* Events
*/
event Confirmation(address indexed sender, uint256 indexed transactionId);
event Revocation(address indexed sender, uint256 indexed transactionId);
event Submission(uint256 indexed transactionId);
event Execution(uint256 indexed transactionId);
event ExecutionFailure(uint256 indexed transactionId);
event Deposit(address indexed sender, uint256 value);
event OwnerAddition(address indexed owner);
event OwnerRemoval(address indexed owner);
event RequirementChange(uint256 required);
/*
* Constants
*/
uint256 public constant MAX_OWNER_COUNT = 50;
/*
* Storage
*/
// 记录交易ID及交易信息体
mapping(uint256 => Transaction) public transactions;
// 记录交易ID及确认交易人和态度
mapping(uint256 => mapping(address => bool)) public confirmations;
// 账户是否是Owner
mapping(address => bool) public isOwner;
// 所有的Owner
address[] public owners;
// 确认交易人数量
uint256 public required;
// 交易数量
uint256 public transactionCount;
// 交易信息体
struct Transaction {
address destination;
uint256 value;
bytes data;
bool executed;
}
/*
* Modifiers
*/
modifier onlyWallet() {
}
modifier ownerDoesNotExist(address owner) {
}
modifier ownerExists(address owner) {
}
modifier transactionExists(uint256 transactionId) {
}
modifier confirmed(uint256 transactionId, address owner) {
}
modifier notConfirmed(uint256 transactionId, address owner) {
// 交易Id下的账户没有确认交易
require(<FILL_ME>)
_;
}
modifier notExecuted(uint256 transactionId) {
}
modifier notNull(address _address) {
}
modifier validRequirement(uint256 ownerCount, uint256 _required) {
}
/// @dev Fallback function allows to deposit ether.
receive() external payable {
}
/*
* Public functions
*/
/// @dev 设置最初的Owner和需要确认的账户数量
/// @param _owners Owner账户列表
/// @param _required 需要确认的账户数量
constructor(address[] memory _owners, uint256 _required) validRequirement(_owners.length, _required) {
}
/// @dev 添加新Owner. Transaction has to be sent by wallet.
/// @param owner owner账户
function addOwner(address owner)
public
onlyWallet
ownerDoesNotExist(owner)
notNull(owner)
validRequirement(owners.length + 1, required)
{
}
/// @dev 移除Owner. Transaction has to be sent by wallet.
/// @param owner owner账户
function removeOwner(address owner) public onlyWallet ownerExists(owner) {
}
/// @dev 用新账户替换旧账户. Transaction has to be sent by wallet.
/// @param owner 旧账户
/// @param newOwner 新账户
function replaceOwner(address owner, address newOwner)
public
onlyWallet
ownerExists(owner)
ownerDoesNotExist(newOwner)
{
}
/// @dev 改变确认账户数量. Transaction has to be sent by wallet.
/// @param _required 确认账户数量.
function changeRequirement(uint256 _required) public onlyWallet validRequirement(owners.length, _required) {
}
/// @dev owner提交和确认交易
/// @param destination 交易对象账户
/// @param value eth数量
/// @param data 交易数据
/// @return transactionId 交易Id.
function submitTransaction(
address destination,
uint256 value,
bytes memory data
) public returns (uint256 transactionId) {
}
/// @dev owner确认交易
/// @param transactionId 交易 ID.
function confirmTransaction(uint256 transactionId)
public
ownerExists(msg.sender)
transactionExists(transactionId)
notConfirmed(transactionId, msg.sender)
{
}
/// @dev Allows an owner to revoke a confirmation for a transaction.
/// @param transactionId Transaction ID.
function revokeConfirmation(uint256 transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
}
/// @dev 允许任何人执行确认的交易体
/// @param transactionId 交易ID.
function executeTransaction(uint256 transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
}
// call has been separated into its own function in order to take advantage
// of the Solidity's code generator to produce a loop that copies tx.data into memory.
function external_call(
address destination,
uint256 value,
uint256 dataLength,
bytes memory data
) internal returns (bool) {
}
/// @dev 返回交易确认量是不是都满足了最小多签量
/// @param transactionId 交易 ID.
/// @return status 是否满足多签数量
function isConfirmed(uint256 transactionId) public view returns (bool status) {
}
/*
* Internal functions
*/
/// @dev 交易不存在时，提交交易体给transactions
/// @param destination 交易对象地址
/// @param value eth数量
/// @param data 交易数据
/// @return transactionId 交易Id
function addTransaction(
address destination,
uint256 value,
bytes memory data
) internal notNull(destination) returns (uint256 transactionId) {
}
/*
* Web3 call functions
*/
/// @dev 获得交易确认数.
/// @param transactionId 交易 ID.
/// @return count 已确认数量.
function getConfirmationCount(uint256 transactionId) public view returns (uint256 count) {
}
/// @dev 获得Pending和完成两种状态下的交易量
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return count number of transactions after filters are applied.
function getTransactionCount(bool pending, bool executed) public view returns (uint256 count) {
}
/// @dev 返回所有owner
/// @return List of owner addresses.
function getOwners() public view returns (address[] memory) {
}
/// @dev 获得已经确认的owner账户.
/// @param transactionId Transaction ID.
/// @return _confirmations array of owner addresses.
function getConfirmations(uint256 transactionId) public view returns (address[] memory _confirmations) {
}
/// @dev 获取间隔内的交易Id列表.
/// @param from Index start position of transaction array.
/// @param to Index end position of transaction array.
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return _transactionIds array of transaction IDs.
function getTransactionIds(
uint256 from,
uint256 to,
bool pending,
bool executed
) public view returns (uint256[] memory _transactionIds) {
}
}
| !confirmations[transactionId][owner],"msw: transactionId confirmed" | 129,900 | !confirmations[transactionId][owner] |
"msw: transactionId executed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/// @title Multisignature wallet - Allows multiple parties to agree on transactions before execution.
/// @author Stefan George - <[email protected]>
contract MultiSigWallet {
/*
* Events
*/
event Confirmation(address indexed sender, uint256 indexed transactionId);
event Revocation(address indexed sender, uint256 indexed transactionId);
event Submission(uint256 indexed transactionId);
event Execution(uint256 indexed transactionId);
event ExecutionFailure(uint256 indexed transactionId);
event Deposit(address indexed sender, uint256 value);
event OwnerAddition(address indexed owner);
event OwnerRemoval(address indexed owner);
event RequirementChange(uint256 required);
/*
* Constants
*/
uint256 public constant MAX_OWNER_COUNT = 50;
/*
* Storage
*/
// 记录交易ID及交易信息体
mapping(uint256 => Transaction) public transactions;
// 记录交易ID及确认交易人和态度
mapping(uint256 => mapping(address => bool)) public confirmations;
// 账户是否是Owner
mapping(address => bool) public isOwner;
// 所有的Owner
address[] public owners;
// 确认交易人数量
uint256 public required;
// 交易数量
uint256 public transactionCount;
// 交易信息体
struct Transaction {
address destination;
uint256 value;
bytes data;
bool executed;
}
/*
* Modifiers
*/
modifier onlyWallet() {
}
modifier ownerDoesNotExist(address owner) {
}
modifier ownerExists(address owner) {
}
modifier transactionExists(uint256 transactionId) {
}
modifier confirmed(uint256 transactionId, address owner) {
}
modifier notConfirmed(uint256 transactionId, address owner) {
}
modifier notExecuted(uint256 transactionId) {
// 交易Id还未执行成功
require(<FILL_ME>)
_;
}
modifier notNull(address _address) {
}
modifier validRequirement(uint256 ownerCount, uint256 _required) {
}
/// @dev Fallback function allows to deposit ether.
receive() external payable {
}
/*
* Public functions
*/
/// @dev 设置最初的Owner和需要确认的账户数量
/// @param _owners Owner账户列表
/// @param _required 需要确认的账户数量
constructor(address[] memory _owners, uint256 _required) validRequirement(_owners.length, _required) {
}
/// @dev 添加新Owner. Transaction has to be sent by wallet.
/// @param owner owner账户
function addOwner(address owner)
public
onlyWallet
ownerDoesNotExist(owner)
notNull(owner)
validRequirement(owners.length + 1, required)
{
}
/// @dev 移除Owner. Transaction has to be sent by wallet.
/// @param owner owner账户
function removeOwner(address owner) public onlyWallet ownerExists(owner) {
}
/// @dev 用新账户替换旧账户. Transaction has to be sent by wallet.
/// @param owner 旧账户
/// @param newOwner 新账户
function replaceOwner(address owner, address newOwner)
public
onlyWallet
ownerExists(owner)
ownerDoesNotExist(newOwner)
{
}
/// @dev 改变确认账户数量. Transaction has to be sent by wallet.
/// @param _required 确认账户数量.
function changeRequirement(uint256 _required) public onlyWallet validRequirement(owners.length, _required) {
}
/// @dev owner提交和确认交易
/// @param destination 交易对象账户
/// @param value eth数量
/// @param data 交易数据
/// @return transactionId 交易Id.
function submitTransaction(
address destination,
uint256 value,
bytes memory data
) public returns (uint256 transactionId) {
}
/// @dev owner确认交易
/// @param transactionId 交易 ID.
function confirmTransaction(uint256 transactionId)
public
ownerExists(msg.sender)
transactionExists(transactionId)
notConfirmed(transactionId, msg.sender)
{
}
/// @dev Allows an owner to revoke a confirmation for a transaction.
/// @param transactionId Transaction ID.
function revokeConfirmation(uint256 transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
}
/// @dev 允许任何人执行确认的交易体
/// @param transactionId 交易ID.
function executeTransaction(uint256 transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
}
// call has been separated into its own function in order to take advantage
// of the Solidity's code generator to produce a loop that copies tx.data into memory.
function external_call(
address destination,
uint256 value,
uint256 dataLength,
bytes memory data
) internal returns (bool) {
}
/// @dev 返回交易确认量是不是都满足了最小多签量
/// @param transactionId 交易 ID.
/// @return status 是否满足多签数量
function isConfirmed(uint256 transactionId) public view returns (bool status) {
}
/*
* Internal functions
*/
/// @dev 交易不存在时，提交交易体给transactions
/// @param destination 交易对象地址
/// @param value eth数量
/// @param data 交易数据
/// @return transactionId 交易Id
function addTransaction(
address destination,
uint256 value,
bytes memory data
) internal notNull(destination) returns (uint256 transactionId) {
}
/*
* Web3 call functions
*/
/// @dev 获得交易确认数.
/// @param transactionId 交易 ID.
/// @return count 已确认数量.
function getConfirmationCount(uint256 transactionId) public view returns (uint256 count) {
}
/// @dev 获得Pending和完成两种状态下的交易量
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return count number of transactions after filters are applied.
function getTransactionCount(bool pending, bool executed) public view returns (uint256 count) {
}
/// @dev 返回所有owner
/// @return List of owner addresses.
function getOwners() public view returns (address[] memory) {
}
/// @dev 获得已经确认的owner账户.
/// @param transactionId Transaction ID.
/// @return _confirmations array of owner addresses.
function getConfirmations(uint256 transactionId) public view returns (address[] memory _confirmations) {
}
/// @dev 获取间隔内的交易Id列表.
/// @param from Index start position of transaction array.
/// @param to Index end position of transaction array.
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return _transactionIds array of transaction IDs.
function getTransactionIds(
uint256 from,
uint256 to,
bool pending,
bool executed
) public view returns (uint256[] memory _transactionIds) {
}
}
| !transactions[transactionId].executed,"msw: transactionId executed" | 129,900 | !transactions[transactionId].executed |
"MultiSigWallet: is owner or 0x0" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/// @title Multisignature wallet - Allows multiple parties to agree on transactions before execution.
/// @author Stefan George - <[email protected]>
contract MultiSigWallet {
/*
* Events
*/
event Confirmation(address indexed sender, uint256 indexed transactionId);
event Revocation(address indexed sender, uint256 indexed transactionId);
event Submission(uint256 indexed transactionId);
event Execution(uint256 indexed transactionId);
event ExecutionFailure(uint256 indexed transactionId);
event Deposit(address indexed sender, uint256 value);
event OwnerAddition(address indexed owner);
event OwnerRemoval(address indexed owner);
event RequirementChange(uint256 required);
/*
* Constants
*/
uint256 public constant MAX_OWNER_COUNT = 50;
/*
* Storage
*/
// 记录交易ID及交易信息体
mapping(uint256 => Transaction) public transactions;
// 记录交易ID及确认交易人和态度
mapping(uint256 => mapping(address => bool)) public confirmations;
// 账户是否是Owner
mapping(address => bool) public isOwner;
// 所有的Owner
address[] public owners;
// 确认交易人数量
uint256 public required;
// 交易数量
uint256 public transactionCount;
// 交易信息体
struct Transaction {
address destination;
uint256 value;
bytes data;
bool executed;
}
/*
* Modifiers
*/
modifier onlyWallet() {
}
modifier ownerDoesNotExist(address owner) {
}
modifier ownerExists(address owner) {
}
modifier transactionExists(uint256 transactionId) {
}
modifier confirmed(uint256 transactionId, address owner) {
}
modifier notConfirmed(uint256 transactionId, address owner) {
}
modifier notExecuted(uint256 transactionId) {
}
modifier notNull(address _address) {
}
modifier validRequirement(uint256 ownerCount, uint256 _required) {
}
/// @dev Fallback function allows to deposit ether.
receive() external payable {
}
/*
* Public functions
*/
/// @dev 设置最初的Owner和需要确认的账户数量
/// @param _owners Owner账户列表
/// @param _required 需要确认的账户数量
constructor(address[] memory _owners, uint256 _required) validRequirement(_owners.length, _required) {
for (uint256 i = 0; i < _owners.length; i++) {
// 逐个查询Owner列表的账户，排查已经是Owner （如：一次性放入多个一样的账户）和零地址的账户
require(<FILL_ME>)
// 新账户
isOwner[_owners[i]] = true;
}
owners = _owners;
required = _required;
}
/// @dev 添加新Owner. Transaction has to be sent by wallet.
/// @param owner owner账户
function addOwner(address owner)
public
onlyWallet
ownerDoesNotExist(owner)
notNull(owner)
validRequirement(owners.length + 1, required)
{
}
/// @dev 移除Owner. Transaction has to be sent by wallet.
/// @param owner owner账户
function removeOwner(address owner) public onlyWallet ownerExists(owner) {
}
/// @dev 用新账户替换旧账户. Transaction has to be sent by wallet.
/// @param owner 旧账户
/// @param newOwner 新账户
function replaceOwner(address owner, address newOwner)
public
onlyWallet
ownerExists(owner)
ownerDoesNotExist(newOwner)
{
}
/// @dev 改变确认账户数量. Transaction has to be sent by wallet.
/// @param _required 确认账户数量.
function changeRequirement(uint256 _required) public onlyWallet validRequirement(owners.length, _required) {
}
/// @dev owner提交和确认交易
/// @param destination 交易对象账户
/// @param value eth数量
/// @param data 交易数据
/// @return transactionId 交易Id.
function submitTransaction(
address destination,
uint256 value,
bytes memory data
) public returns (uint256 transactionId) {
}
/// @dev owner确认交易
/// @param transactionId 交易 ID.
function confirmTransaction(uint256 transactionId)
public
ownerExists(msg.sender)
transactionExists(transactionId)
notConfirmed(transactionId, msg.sender)
{
}
/// @dev Allows an owner to revoke a confirmation for a transaction.
/// @param transactionId Transaction ID.
function revokeConfirmation(uint256 transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
}
/// @dev 允许任何人执行确认的交易体
/// @param transactionId 交易ID.
function executeTransaction(uint256 transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
}
// call has been separated into its own function in order to take advantage
// of the Solidity's code generator to produce a loop that copies tx.data into memory.
function external_call(
address destination,
uint256 value,
uint256 dataLength,
bytes memory data
) internal returns (bool) {
}
/// @dev 返回交易确认量是不是都满足了最小多签量
/// @param transactionId 交易 ID.
/// @return status 是否满足多签数量
function isConfirmed(uint256 transactionId) public view returns (bool status) {
}
/*
* Internal functions
*/
/// @dev 交易不存在时，提交交易体给transactions
/// @param destination 交易对象地址
/// @param value eth数量
/// @param data 交易数据
/// @return transactionId 交易Id
function addTransaction(
address destination,
uint256 value,
bytes memory data
) internal notNull(destination) returns (uint256 transactionId) {
}
/*
* Web3 call functions
*/
/// @dev 获得交易确认数.
/// @param transactionId 交易 ID.
/// @return count 已确认数量.
function getConfirmationCount(uint256 transactionId) public view returns (uint256 count) {
}
/// @dev 获得Pending和完成两种状态下的交易量
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return count number of transactions after filters are applied.
function getTransactionCount(bool pending, bool executed) public view returns (uint256 count) {
}
/// @dev 返回所有owner
/// @return List of owner addresses.
function getOwners() public view returns (address[] memory) {
}
/// @dev 获得已经确认的owner账户.
/// @param transactionId Transaction ID.
/// @return _confirmations array of owner addresses.
function getConfirmations(uint256 transactionId) public view returns (address[] memory _confirmations) {
}
/// @dev 获取间隔内的交易Id列表.
/// @param from Index start position of transaction array.
/// @param to Index end position of transaction array.
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return _transactionIds array of transaction IDs.
function getTransactionIds(
uint256 from,
uint256 to,
bool pending,
bool executed
) public view returns (uint256[] memory _transactionIds) {
}
}
| !isOwner[_owners[i]]&&_owners[i]!=address(0),"MultiSigWallet: is owner or 0x0" | 129,900 | !isOwner[_owners[i]]&&_owners[i]!=address(0) |
"AuthControl: Caller is not an operator" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import { ERC165Storage } from "@openzeppelin/contracts/utils/introspection/ERC165Storage.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "./AuthRoleSeigManager.sol";
contract AuthControlSeigManager is AuthRoleSeigManager, ERC165Storage, AccessControl {
modifier onlyOwner() {
}
modifier onlyMinter() {
}
modifier onlyOperator() {
require(<FILL_ME>)
_;
}
modifier onlyChallenger() {
}
modifier onlyPauser() {
}
modifier onlyMinterOrAdmin() {
}
/// @dev add admin
/// @param account address to add
function addAdmin(address account) public virtual onlyOwner {
}
function addMinter(address account) public virtual onlyOwner {
}
function addOperator(address account) public virtual onlyOwner {
}
function addChallenger(address account) public virtual onlyMinterOrAdmin {
}
/// @dev remove admin
/// @param account address to remove
function removeAdmin(address account) public virtual onlyOwner {
}
function removeMinter(address account) public virtual onlyOwner {
}
function removeChallenger(address account) public virtual onlyOwner {
}
function removeOperator(address account) public virtual onlyOwner {
}
/// @dev transfer admin
/// @param newAdmin new admin address
function transferAdmin(address newAdmin) public virtual onlyOwner {
}
function transferOwnership(address newAdmin) public virtual onlyOwner {
}
function renounceOwnership() public onlyOwner {
}
function renounceMinter() public {
}
function renounceOperator() public {
}
function renounceChallenger() public {
}
function revokeMinter(address account) public onlyOwner {
}
function revokeOperator(address account) public onlyOwner {
}
function revokeChallenger(address account) public onlyOwner {
}
/// @dev whether admin
/// @param account address to check
function isAdmin(address account) public view virtual returns (bool) {
}
function isOwner() public view virtual returns (bool) {
}
function isMinter(address account) public view virtual returns (bool) {
}
function isOperator(address account) public view virtual returns (bool) {
}
function isChallenger(address account) public view virtual returns (bool) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Storage, AccessControl) returns (bool) {
}
}
| hasRole(OPERATOR_ROLE,msg.sender),"AuthControl: Caller is not an operator" | 129,917 | hasRole(OPERATOR_ROLE,msg.sender) |
"AuthControl: Caller is not a challenger" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import { ERC165Storage } from "@openzeppelin/contracts/utils/introspection/ERC165Storage.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "./AuthRoleSeigManager.sol";
contract AuthControlSeigManager is AuthRoleSeigManager, ERC165Storage, AccessControl {
modifier onlyOwner() {
}
modifier onlyMinter() {
}
modifier onlyOperator() {
}
modifier onlyChallenger() {
require(<FILL_ME>)
_;
}
modifier onlyPauser() {
}
modifier onlyMinterOrAdmin() {
}
/// @dev add admin
/// @param account address to add
function addAdmin(address account) public virtual onlyOwner {
}
function addMinter(address account) public virtual onlyOwner {
}
function addOperator(address account) public virtual onlyOwner {
}
function addChallenger(address account) public virtual onlyMinterOrAdmin {
}
/// @dev remove admin
/// @param account address to remove
function removeAdmin(address account) public virtual onlyOwner {
}
function removeMinter(address account) public virtual onlyOwner {
}
function removeChallenger(address account) public virtual onlyOwner {
}
function removeOperator(address account) public virtual onlyOwner {
}
/// @dev transfer admin
/// @param newAdmin new admin address
function transferAdmin(address newAdmin) public virtual onlyOwner {
}
function transferOwnership(address newAdmin) public virtual onlyOwner {
}
function renounceOwnership() public onlyOwner {
}
function renounceMinter() public {
}
function renounceOperator() public {
}
function renounceChallenger() public {
}
function revokeMinter(address account) public onlyOwner {
}
function revokeOperator(address account) public onlyOwner {
}
function revokeChallenger(address account) public onlyOwner {
}
/// @dev whether admin
/// @param account address to check
function isAdmin(address account) public view virtual returns (bool) {
}
function isOwner() public view virtual returns (bool) {
}
function isMinter(address account) public view virtual returns (bool) {
}
function isOperator(address account) public view virtual returns (bool) {
}
function isChallenger(address account) public view virtual returns (bool) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Storage, AccessControl) returns (bool) {
}
}
| hasRole(CHALLENGER_ROLE,msg.sender),"AuthControl: Caller is not a challenger" | 129,917 | hasRole(CHALLENGER_ROLE,msg.sender) |
"AuthControl: Caller is not a pauser" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import { ERC165Storage } from "@openzeppelin/contracts/utils/introspection/ERC165Storage.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "./AuthRoleSeigManager.sol";
contract AuthControlSeigManager is AuthRoleSeigManager, ERC165Storage, AccessControl {
modifier onlyOwner() {
}
modifier onlyMinter() {
}
modifier onlyOperator() {
}
modifier onlyChallenger() {
}
modifier onlyPauser() {
require(<FILL_ME>)
_;
}
modifier onlyMinterOrAdmin() {
}
/// @dev add admin
/// @param account address to add
function addAdmin(address account) public virtual onlyOwner {
}
function addMinter(address account) public virtual onlyOwner {
}
function addOperator(address account) public virtual onlyOwner {
}
function addChallenger(address account) public virtual onlyMinterOrAdmin {
}
/// @dev remove admin
/// @param account address to remove
function removeAdmin(address account) public virtual onlyOwner {
}
function removeMinter(address account) public virtual onlyOwner {
}
function removeChallenger(address account) public virtual onlyOwner {
}
function removeOperator(address account) public virtual onlyOwner {
}
/// @dev transfer admin
/// @param newAdmin new admin address
function transferAdmin(address newAdmin) public virtual onlyOwner {
}
function transferOwnership(address newAdmin) public virtual onlyOwner {
}
function renounceOwnership() public onlyOwner {
}
function renounceMinter() public {
}
function renounceOperator() public {
}
function renounceChallenger() public {
}
function revokeMinter(address account) public onlyOwner {
}
function revokeOperator(address account) public onlyOwner {
}
function revokeChallenger(address account) public onlyOwner {
}
/// @dev whether admin
/// @param account address to check
function isAdmin(address account) public view virtual returns (bool) {
}
function isOwner() public view virtual returns (bool) {
}
function isMinter(address account) public view virtual returns (bool) {
}
function isOperator(address account) public view virtual returns (bool) {
}
function isChallenger(address account) public view virtual returns (bool) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Storage, AccessControl) returns (bool) {
}
}
| hasRole(PAUSE_ROLE,msg.sender),"AuthControl: Caller is not a pauser" | 129,917 | hasRole(PAUSE_ROLE,msg.sender) |
"not onlyMinterOrAdmin" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import { ERC165Storage } from "@openzeppelin/contracts/utils/introspection/ERC165Storage.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "./AuthRoleSeigManager.sol";
contract AuthControlSeigManager is AuthRoleSeigManager, ERC165Storage, AccessControl {
modifier onlyOwner() {
}
modifier onlyMinter() {
}
modifier onlyOperator() {
}
modifier onlyChallenger() {
}
modifier onlyPauser() {
}
modifier onlyMinterOrAdmin() {
require(<FILL_ME>)
_;
}
/// @dev add admin
/// @param account address to add
function addAdmin(address account) public virtual onlyOwner {
}
function addMinter(address account) public virtual onlyOwner {
}
function addOperator(address account) public virtual onlyOwner {
}
function addChallenger(address account) public virtual onlyMinterOrAdmin {
}
/// @dev remove admin
/// @param account address to remove
function removeAdmin(address account) public virtual onlyOwner {
}
function removeMinter(address account) public virtual onlyOwner {
}
function removeChallenger(address account) public virtual onlyOwner {
}
function removeOperator(address account) public virtual onlyOwner {
}
/// @dev transfer admin
/// @param newAdmin new admin address
function transferAdmin(address newAdmin) public virtual onlyOwner {
}
function transferOwnership(address newAdmin) public virtual onlyOwner {
}
function renounceOwnership() public onlyOwner {
}
function renounceMinter() public {
}
function renounceOperator() public {
}
function renounceChallenger() public {
}
function revokeMinter(address account) public onlyOwner {
}
function revokeOperator(address account) public onlyOwner {
}
function revokeChallenger(address account) public onlyOwner {
}
/// @dev whether admin
/// @param account address to check
function isAdmin(address account) public view virtual returns (bool) {
}
function isOwner() public view virtual returns (bool) {
}
function isMinter(address account) public view virtual returns (bool) {
}
function isOperator(address account) public view virtual returns (bool) {
}
function isChallenger(address account) public view virtual returns (bool) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Storage, AccessControl) returns (bool) {
}
}
| isAdmin(msg.sender)||hasRole(MINTER_ROLE,msg.sender),"not onlyMinterOrAdmin" | 129,917 | isAdmin(msg.sender)||hasRole(MINTER_ROLE,msg.sender) |
"Address is blacklisted." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
/**
https://t.me/peachcoin
https://twitter.com/peachcoineth
https://www.peachcoin.vip/
$PEACH
The Token for Decentralized Emojis.
- Liquidity locked
- Ownership renounced
- MEV protection
*/
contract Peach is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = unicode"Peach";
string private constant _symbol = unicode"PEACH";
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 _isBlacklisted;
uint8 private constant _decimals = 9;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 69_696_969_696 * 10 ** _decimals;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 0;
uint256 private _taxFeeOnBuy = 0;
uint256 private _redisFeeOnSell = 0;
uint256 private _taxFeeOnSell = 4;
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
mapping(address => uint256) public _buyMap;
address payable private _developmentAddress =
payable(0x1158399a19f73551C1Bc56Ed93e16a25328D7843);
address payable private _marketingAddress =
payable(0x1158399a19f73551C1Bc56Ed93e16a25328D7843);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen = false;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = 2 * (_tTotal / 100);
uint256 public _maxWalletSize = 2 * (_tTotal / 100);
uint256 public _swapTokensAtAmount = 20 * (_tTotal / 1000);
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap() {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function symbol() public pure returns (string memory) {
}
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 addLiquidityAndLock(
uint256 tokenAmount,
uint256 ethAmount,
address lockContractAddress
) external onlyOwner {
}
modifier onlyNonBlacklisted() {
require(<FILL_ME>)
_;
}
function setBlacklisted(
address account,
bool blacklisted
) public onlyOwner {
}
function isBlacklisted(address account) public view returns (bool) {
}
function tokenFromReflection(
uint256 rAmount
) private view returns (uint256) {
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private onlyNonBlacklisted {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
//Camelot Dex Router 0xc873fEcbd354f5A56E00E710B90EF4201db2448d
function setTrading(bool _tradingOpen) 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 setFee(
uint256 redisFeeOnBuy,
uint256 redisFeeOnSell,
uint256 taxFeeOnBuy,
uint256 taxFeeOnSell
) public onlyOwner {
}
//Set minimum tokens required to swap.
function setMinSwapTokensThreshold(
uint256 swapTokensAtAmount
) public onlyOwner {
}
//Set minimum tokens required to swap.
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
//Set maximum transaction
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
}
function setMaxAll() public onlyOwner {
}
}
| !_isBlacklisted[_msgSender()],"Address is blacklisted." | 129,955 | !_isBlacklisted[_msgSender()] |
null | /**
Trade crypto with zero price impact, up to 100x leverage and aggregated liquidity. MUX protocol takes care of all the hassles so that you can experience optimized DEX trading on our platform.
Website: https://www.muxtrade.org
Telegram: https://t.me/mux_erc
Twitter: https://twitter.com/mux_erc
Dapp: https://app.muxtrade.org
*/
// SPDX-License-Identifier: Unlicensed
pragma solidity 0.8.19;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IUniswapRouter {
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;
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 IUniswapFactory {
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;
}
library SafeMathLibrary {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract MUX is Context, IERC20, Ownable {
using SafeMathLibrary for uint256;
string private _name = "Mux Protocol";
string private _symbol = "MUX";
uint8 private _decimals = 9;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public isExcludedFromLimits;
mapping (address => bool) public maxWalletExcludes;
mapping (address => bool) public maxTxExcludes;
mapping (address => bool) public ammPairs;
uint256 private _totalSupply = 10 ** 9 * 10 ** 9;
uint256 public maxTxAmount = 12 * 10 ** 6 * 10 ** 9;
uint256 public maxWallet = 12 * 10 ** 6 * 10 ** 9;
uint256 public swapThreshold = 10 ** 5 * 10 ** 9;
uint256 public _lpBuyFee = 0;
uint256 public _mktBuyFee = 20;
uint256 public _devBuyFee = 0;
uint256 public _lpSellFee = 0;
uint256 public _mktSellFee = 20;
uint256 public _devSellFee = 0;
uint256 public sharesForLp = 0;
uint256 public sharesForMkt = 10;
uint256 public sharesForDev = 0;
uint256 public totalBuyFee = 20;
uint256 public totalSellFee = 20;
uint256 public sharesTotal = 10;
address payable private marketingAddress;
address payable private developmentAddress;
IUniswapRouter public uniswapRouter;
address public uniswapPair;
bool _swapping;
bool public swapActive = true;
bool public maxSwapActive = false;
bool public maxWalletActive = true;
modifier lockTheSwap {
}
constructor () {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function swapBackTokens(uint256 tAmount) private lockTheSwap {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
function _transfer(address sender, address recipient, uint256 amount) private returns (bool) {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
if(_swapping)
{
return _basicTransfer(sender, recipient, amount);
}
else
{
if(!maxTxExcludes[sender] && !maxTxExcludes[recipient]) {
require(amount <= maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
}
uint256 swapAmount = balanceOf(address(this));
bool minimumSwap = swapAmount >= swapThreshold;
if (minimumSwap && !_swapping && ammPairs[recipient] && swapActive && !isExcludedFromLimits[sender] && amount > swapThreshold)
{
if(maxSwapActive)
swapAmount = swapThreshold;
swapBackTokens(swapAmount);
}
uint256 receiverAmount = (isExcludedFromLimits[sender] || isExcludedFromLimits[recipient]) ?
amount : takeFee(sender, recipient, amount);
if(maxWalletActive && !maxWalletExcludes[recipient])
require(<FILL_ME>)
uint256 sAmount = (!maxWalletActive && isExcludedFromLimits[sender]) ? amount.sub(receiverAmount) : amount;
_balances[sender] = _balances[sender].sub(sAmount, "Insufficient Balance");
_balances[recipient] = _balances[recipient].add(receiverAmount);
emit Transfer(sender, recipient, receiverAmount);
return true;
}
}
function balanceOf(address account) public view override returns (uint256) {
}
function swapTokensToETH(uint256 tokenAmount) private {
}
function sendFees(address payable recipient, uint256 amount) private {
}
receive() external payable {}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function removeLimits() external onlyOwner {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
}
| balanceOf(recipient).add(receiverAmount)<=maxWallet | 129,983 | balanceOf(recipient).add(receiverAmount)<=maxWallet |
"Cannot set maxWallet lower than 1.0%" | /**
WEBSITE: https://methereum.org/
TWITTER: https://twitter.com/methereum69
TELEGRAM: https://t.me/METHEREUEM
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
pragma experimental ABIEncoderV2;
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router01.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
//import "hardhat/console.sol";
contract METH is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
address public constant deadAddress = address(0x000000000000000000000000000000000000dEaD);
bool private swapping;
uint256 public maxTransactionAmount;
uint256 public maxWallet;
uint256 public swapTokensAtAmount;
uint256 public swapTokensAtMultiplier;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
bool public blacklistRenounced = false;
// Anti-bot and anti-whale mappings and variables
mapping(address => bool) blacklisted;
struct Taxes {
uint256 corruption;
uint256 liquidity;
uint256 cooking;
}
Taxes public taxes = Taxes(1, 0, 1);
Taxes public sellTaxes = Taxes(1, 0, 1);
uint256 public buyTotalFees;
uint256 public sellTotalFees;
uint256 public tokensForCorruption;
uint256 public tokensForLiquidity;
uint256 public tokensForCooking;
address private corruptionWallet;
address private cookingWallet;
/******************/
// exclude from fees and max transaction amount
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping(address => bool) public automatedMarketMakerPairs;
bool public preListingPhase = true;
mapping(address => bool) public preListingTransferrable;
event UpdateUniswapV2Router(address indexed newAddress,address indexed oldAddress);
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event CorruptionWalletUpdated(address indexed newWallet, address indexed oldWallet);
event CookingWalletUpdated(address indexed newWallet, address indexed oldWallet);
event SwapAndLiquify(uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiquidity);
constructor() ERC20("METHEREUM", "METH") {
}
receive() external payable {}
// once enabled, can never be turned off
function enableTrading() external onlyOwner {
}
// remove limits after token is stable
function removeLimits() external onlyOwner returns (bool) {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount)
external
onlyOwner
returns (bool)
{
}
function UpdateBuyTaxes(
uint256 _corruption,
uint256 _liquidity,
uint256 _cooking
) external onlyOwner {
}
function SetSellTaxes(
uint256 _corruption,
uint256 _liquidity,
uint256 _cooking
) external onlyOwner {
}
function updateMaxTxnAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
require(<FILL_ME>)
maxWallet = newNum * (10**18);
}
function excludeFromMaxTransaction(address updAds, bool isEx)
public
onlyOwner
{
}
// only use to disable contract sales if absolutely necessary (emergency use only)
function updateSwapEnabled(bool enabled) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value)
public
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateCorruptionWallet(address newWallet) external onlyOwner {
}
function updateCookingWallet(address newWallet) external onlyOwner {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
function isBlacklisted(address account) public view returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
function withdrawStuckToken() external onlyOwner {
}
function withdrawStuckToken(address _token, address _to) external onlyOwner {
}
function withdrawStuckEth(address toAddr) external onlyOwner {
}
// @dev team renounce blacklist commands
function renounceBlacklist() public onlyOwner {
}
function blacklist(address _addr) public onlyOwner {
}
// @dev blacklist v3 pools; can unblacklist() down the road to suit project and community
function blacklistLiquidityPool(address lpAddress) public onlyOwner {
}
// @dev unblacklist address; not affected by blacklistRenounced incase team wants to unblacklist v3 pools down the road
function unblacklist(address _addr) public onlyOwner {
}
function setPreListingTransferable(address _addr, bool isAuthorized) public onlyOwner {
}
}
| newNum>=((totalSupply()*10)/1000)/1e18,"Cannot set maxWallet lower than 1.0%" | 130,095 | newNum>=((totalSupply()*10)/1000)/1e18 |
"Sender blacklisted" | /**
WEBSITE: https://methereum.org/
TWITTER: https://twitter.com/methereum69
TELEGRAM: https://t.me/METHEREUEM
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
pragma experimental ABIEncoderV2;
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router01.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
//import "hardhat/console.sol";
contract METH is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
address public constant deadAddress = address(0x000000000000000000000000000000000000dEaD);
bool private swapping;
uint256 public maxTransactionAmount;
uint256 public maxWallet;
uint256 public swapTokensAtAmount;
uint256 public swapTokensAtMultiplier;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
bool public blacklistRenounced = false;
// Anti-bot and anti-whale mappings and variables
mapping(address => bool) blacklisted;
struct Taxes {
uint256 corruption;
uint256 liquidity;
uint256 cooking;
}
Taxes public taxes = Taxes(1, 0, 1);
Taxes public sellTaxes = Taxes(1, 0, 1);
uint256 public buyTotalFees;
uint256 public sellTotalFees;
uint256 public tokensForCorruption;
uint256 public tokensForLiquidity;
uint256 public tokensForCooking;
address private corruptionWallet;
address private cookingWallet;
/******************/
// exclude from fees and max transaction amount
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping(address => bool) public automatedMarketMakerPairs;
bool public preListingPhase = true;
mapping(address => bool) public preListingTransferrable;
event UpdateUniswapV2Router(address indexed newAddress,address indexed oldAddress);
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event CorruptionWalletUpdated(address indexed newWallet, address indexed oldWallet);
event CookingWalletUpdated(address indexed newWallet, address indexed oldWallet);
event SwapAndLiquify(uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiquidity);
constructor() ERC20("METHEREUM", "METH") {
}
receive() external payable {}
// once enabled, can never be turned off
function enableTrading() external onlyOwner {
}
// remove limits after token is stable
function removeLimits() external onlyOwner returns (bool) {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount)
external
onlyOwner
returns (bool)
{
}
function UpdateBuyTaxes(
uint256 _corruption,
uint256 _liquidity,
uint256 _cooking
) external onlyOwner {
}
function SetSellTaxes(
uint256 _corruption,
uint256 _liquidity,
uint256 _cooking
) external onlyOwner {
}
function updateMaxTxnAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx)
public
onlyOwner
{
}
// only use to disable contract sales if absolutely necessary (emergency use only)
function updateSwapEnabled(bool enabled) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value)
public
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateCorruptionWallet(address newWallet) external onlyOwner {
}
function updateCookingWallet(address newWallet) external onlyOwner {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
function isBlacklisted(address account) public view returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
//console.log("Transferring from %s to %s %s tokens", msg.sender, to, amount);
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(<FILL_ME>)
require(!blacklisted[to],"Receiver blacklisted");
if (preListingPhase) {
require(preListingTransferrable[from], "Not authorized to transfer pre-listing.");
}
if (amount == 0) {
super._transfer(from, to, 0);
return;
}
if (limitsInEffect) {
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
!swapping
) {
if (!tradingActive) {
require(
_isExcludedFromFees[from] || _isExcludedFromFees[to],
"Trading is not active."
);
}
//when buy
if (
automatedMarketMakerPairs[from] &&
!_isExcludedMaxTransactionAmount[to]
) {
require(
amount <= maxTransactionAmount,
"Buy transfer amount exceeds the maxTransactionAmount."
);
require(
amount + balanceOf(to) <= maxWallet,
"Max wallet exceeded"
);
}
//when sell
else if (
automatedMarketMakerPairs[to] &&
!_isExcludedMaxTransactionAmount[from]
) {
require(
amount <= maxTransactionAmount,
"Sell transfer amount exceeds the maxTransactionAmount."
);
} else if (!_isExcludedMaxTransactionAmount[to]) {
require(
amount + balanceOf(to) <= maxWallet,
"Max wallet exceeded"
);
}
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
/*console.log("from: %s and to: %s", from, to);
console.log("!automatedMarketMakerPairs[from] %s", !automatedMarketMakerPairs[from]);
console.log("!automatedMarketMakerPairs[to] %s", !automatedMarketMakerPairs[to]);*/
if (
canSwap &&
swapEnabled &&
!swapping &&
!automatedMarketMakerPairs[from] && //true only during token sell or user wallet to user wallet transfer
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = !swapping;
// if any account belongs to _isExcludedFromFee account then remove the fee
if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
// only take fees on buys/sells, do not take on wallet transfers
if (takeFee) {
// on sell
if (automatedMarketMakerPairs[to] && sellTotalFees > 0) {
fees = amount.mul(sellTotalFees).div(100);
tokensForLiquidity += (fees * sellTaxes.liquidity) / sellTotalFees;
tokensForCooking += (fees * sellTaxes.cooking) / sellTotalFees;
tokensForCorruption += (fees * sellTaxes.corruption) / sellTotalFees;
}
// on buy
else if (automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForLiquidity += (fees * taxes.liquidity) / buyTotalFees;
tokensForCooking += (fees * taxes.cooking) / buyTotalFees;
tokensForCorruption += (fees * taxes.corruption) / buyTotalFees;
}
if (fees > 0) {
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
function withdrawStuckToken() external onlyOwner {
}
function withdrawStuckToken(address _token, address _to) external onlyOwner {
}
function withdrawStuckEth(address toAddr) external onlyOwner {
}
// @dev team renounce blacklist commands
function renounceBlacklist() public onlyOwner {
}
function blacklist(address _addr) public onlyOwner {
}
// @dev blacklist v3 pools; can unblacklist() down the road to suit project and community
function blacklistLiquidityPool(address lpAddress) public onlyOwner {
}
// @dev unblacklist address; not affected by blacklistRenounced incase team wants to unblacklist v3 pools down the road
function unblacklist(address _addr) public onlyOwner {
}
function setPreListingTransferable(address _addr, bool isAuthorized) public onlyOwner {
}
}
| !blacklisted[from],"Sender blacklisted" | 130,095 | !blacklisted[from] |
"Receiver blacklisted" | /**
WEBSITE: https://methereum.org/
TWITTER: https://twitter.com/methereum69
TELEGRAM: https://t.me/METHEREUEM
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
pragma experimental ABIEncoderV2;
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router01.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
//import "hardhat/console.sol";
contract METH is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
address public constant deadAddress = address(0x000000000000000000000000000000000000dEaD);
bool private swapping;
uint256 public maxTransactionAmount;
uint256 public maxWallet;
uint256 public swapTokensAtAmount;
uint256 public swapTokensAtMultiplier;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
bool public blacklistRenounced = false;
// Anti-bot and anti-whale mappings and variables
mapping(address => bool) blacklisted;
struct Taxes {
uint256 corruption;
uint256 liquidity;
uint256 cooking;
}
Taxes public taxes = Taxes(1, 0, 1);
Taxes public sellTaxes = Taxes(1, 0, 1);
uint256 public buyTotalFees;
uint256 public sellTotalFees;
uint256 public tokensForCorruption;
uint256 public tokensForLiquidity;
uint256 public tokensForCooking;
address private corruptionWallet;
address private cookingWallet;
/******************/
// exclude from fees and max transaction amount
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping(address => bool) public automatedMarketMakerPairs;
bool public preListingPhase = true;
mapping(address => bool) public preListingTransferrable;
event UpdateUniswapV2Router(address indexed newAddress,address indexed oldAddress);
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event CorruptionWalletUpdated(address indexed newWallet, address indexed oldWallet);
event CookingWalletUpdated(address indexed newWallet, address indexed oldWallet);
event SwapAndLiquify(uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiquidity);
constructor() ERC20("METHEREUM", "METH") {
}
receive() external payable {}
// once enabled, can never be turned off
function enableTrading() external onlyOwner {
}
// remove limits after token is stable
function removeLimits() external onlyOwner returns (bool) {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount)
external
onlyOwner
returns (bool)
{
}
function UpdateBuyTaxes(
uint256 _corruption,
uint256 _liquidity,
uint256 _cooking
) external onlyOwner {
}
function SetSellTaxes(
uint256 _corruption,
uint256 _liquidity,
uint256 _cooking
) external onlyOwner {
}
function updateMaxTxnAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx)
public
onlyOwner
{
}
// only use to disable contract sales if absolutely necessary (emergency use only)
function updateSwapEnabled(bool enabled) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value)
public
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateCorruptionWallet(address newWallet) external onlyOwner {
}
function updateCookingWallet(address newWallet) external onlyOwner {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
function isBlacklisted(address account) public view returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
//console.log("Transferring from %s to %s %s tokens", msg.sender, to, amount);
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(!blacklisted[from],"Sender blacklisted");
require(<FILL_ME>)
if (preListingPhase) {
require(preListingTransferrable[from], "Not authorized to transfer pre-listing.");
}
if (amount == 0) {
super._transfer(from, to, 0);
return;
}
if (limitsInEffect) {
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
!swapping
) {
if (!tradingActive) {
require(
_isExcludedFromFees[from] || _isExcludedFromFees[to],
"Trading is not active."
);
}
//when buy
if (
automatedMarketMakerPairs[from] &&
!_isExcludedMaxTransactionAmount[to]
) {
require(
amount <= maxTransactionAmount,
"Buy transfer amount exceeds the maxTransactionAmount."
);
require(
amount + balanceOf(to) <= maxWallet,
"Max wallet exceeded"
);
}
//when sell
else if (
automatedMarketMakerPairs[to] &&
!_isExcludedMaxTransactionAmount[from]
) {
require(
amount <= maxTransactionAmount,
"Sell transfer amount exceeds the maxTransactionAmount."
);
} else if (!_isExcludedMaxTransactionAmount[to]) {
require(
amount + balanceOf(to) <= maxWallet,
"Max wallet exceeded"
);
}
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
/*console.log("from: %s and to: %s", from, to);
console.log("!automatedMarketMakerPairs[from] %s", !automatedMarketMakerPairs[from]);
console.log("!automatedMarketMakerPairs[to] %s", !automatedMarketMakerPairs[to]);*/
if (
canSwap &&
swapEnabled &&
!swapping &&
!automatedMarketMakerPairs[from] && //true only during token sell or user wallet to user wallet transfer
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = !swapping;
// if any account belongs to _isExcludedFromFee account then remove the fee
if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
// only take fees on buys/sells, do not take on wallet transfers
if (takeFee) {
// on sell
if (automatedMarketMakerPairs[to] && sellTotalFees > 0) {
fees = amount.mul(sellTotalFees).div(100);
tokensForLiquidity += (fees * sellTaxes.liquidity) / sellTotalFees;
tokensForCooking += (fees * sellTaxes.cooking) / sellTotalFees;
tokensForCorruption += (fees * sellTaxes.corruption) / sellTotalFees;
}
// on buy
else if (automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForLiquidity += (fees * taxes.liquidity) / buyTotalFees;
tokensForCooking += (fees * taxes.cooking) / buyTotalFees;
tokensForCorruption += (fees * taxes.corruption) / buyTotalFees;
}
if (fees > 0) {
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
function withdrawStuckToken() external onlyOwner {
}
function withdrawStuckToken(address _token, address _to) external onlyOwner {
}
function withdrawStuckEth(address toAddr) external onlyOwner {
}
// @dev team renounce blacklist commands
function renounceBlacklist() public onlyOwner {
}
function blacklist(address _addr) public onlyOwner {
}
// @dev blacklist v3 pools; can unblacklist() down the road to suit project and community
function blacklistLiquidityPool(address lpAddress) public onlyOwner {
}
// @dev unblacklist address; not affected by blacklistRenounced incase team wants to unblacklist v3 pools down the road
function unblacklist(address _addr) public onlyOwner {
}
function setPreListingTransferable(address _addr, bool isAuthorized) public onlyOwner {
}
}
| !blacklisted[to],"Receiver blacklisted" | 130,095 | !blacklisted[to] |
"Not authorized to transfer pre-listing." | /**
WEBSITE: https://methereum.org/
TWITTER: https://twitter.com/methereum69
TELEGRAM: https://t.me/METHEREUEM
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
pragma experimental ABIEncoderV2;
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router01.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
//import "hardhat/console.sol";
contract METH is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
address public constant deadAddress = address(0x000000000000000000000000000000000000dEaD);
bool private swapping;
uint256 public maxTransactionAmount;
uint256 public maxWallet;
uint256 public swapTokensAtAmount;
uint256 public swapTokensAtMultiplier;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
bool public blacklistRenounced = false;
// Anti-bot and anti-whale mappings and variables
mapping(address => bool) blacklisted;
struct Taxes {
uint256 corruption;
uint256 liquidity;
uint256 cooking;
}
Taxes public taxes = Taxes(1, 0, 1);
Taxes public sellTaxes = Taxes(1, 0, 1);
uint256 public buyTotalFees;
uint256 public sellTotalFees;
uint256 public tokensForCorruption;
uint256 public tokensForLiquidity;
uint256 public tokensForCooking;
address private corruptionWallet;
address private cookingWallet;
/******************/
// exclude from fees and max transaction amount
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping(address => bool) public automatedMarketMakerPairs;
bool public preListingPhase = true;
mapping(address => bool) public preListingTransferrable;
event UpdateUniswapV2Router(address indexed newAddress,address indexed oldAddress);
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event CorruptionWalletUpdated(address indexed newWallet, address indexed oldWallet);
event CookingWalletUpdated(address indexed newWallet, address indexed oldWallet);
event SwapAndLiquify(uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiquidity);
constructor() ERC20("METHEREUM", "METH") {
}
receive() external payable {}
// once enabled, can never be turned off
function enableTrading() external onlyOwner {
}
// remove limits after token is stable
function removeLimits() external onlyOwner returns (bool) {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount)
external
onlyOwner
returns (bool)
{
}
function UpdateBuyTaxes(
uint256 _corruption,
uint256 _liquidity,
uint256 _cooking
) external onlyOwner {
}
function SetSellTaxes(
uint256 _corruption,
uint256 _liquidity,
uint256 _cooking
) external onlyOwner {
}
function updateMaxTxnAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx)
public
onlyOwner
{
}
// only use to disable contract sales if absolutely necessary (emergency use only)
function updateSwapEnabled(bool enabled) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value)
public
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateCorruptionWallet(address newWallet) external onlyOwner {
}
function updateCookingWallet(address newWallet) external onlyOwner {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
function isBlacklisted(address account) public view returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
//console.log("Transferring from %s to %s %s tokens", msg.sender, to, amount);
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(!blacklisted[from],"Sender blacklisted");
require(!blacklisted[to],"Receiver blacklisted");
if (preListingPhase) {
require(<FILL_ME>)
}
if (amount == 0) {
super._transfer(from, to, 0);
return;
}
if (limitsInEffect) {
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
!swapping
) {
if (!tradingActive) {
require(
_isExcludedFromFees[from] || _isExcludedFromFees[to],
"Trading is not active."
);
}
//when buy
if (
automatedMarketMakerPairs[from] &&
!_isExcludedMaxTransactionAmount[to]
) {
require(
amount <= maxTransactionAmount,
"Buy transfer amount exceeds the maxTransactionAmount."
);
require(
amount + balanceOf(to) <= maxWallet,
"Max wallet exceeded"
);
}
//when sell
else if (
automatedMarketMakerPairs[to] &&
!_isExcludedMaxTransactionAmount[from]
) {
require(
amount <= maxTransactionAmount,
"Sell transfer amount exceeds the maxTransactionAmount."
);
} else if (!_isExcludedMaxTransactionAmount[to]) {
require(
amount + balanceOf(to) <= maxWallet,
"Max wallet exceeded"
);
}
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
/*console.log("from: %s and to: %s", from, to);
console.log("!automatedMarketMakerPairs[from] %s", !automatedMarketMakerPairs[from]);
console.log("!automatedMarketMakerPairs[to] %s", !automatedMarketMakerPairs[to]);*/
if (
canSwap &&
swapEnabled &&
!swapping &&
!automatedMarketMakerPairs[from] && //true only during token sell or user wallet to user wallet transfer
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = !swapping;
// if any account belongs to _isExcludedFromFee account then remove the fee
if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
// only take fees on buys/sells, do not take on wallet transfers
if (takeFee) {
// on sell
if (automatedMarketMakerPairs[to] && sellTotalFees > 0) {
fees = amount.mul(sellTotalFees).div(100);
tokensForLiquidity += (fees * sellTaxes.liquidity) / sellTotalFees;
tokensForCooking += (fees * sellTaxes.cooking) / sellTotalFees;
tokensForCorruption += (fees * sellTaxes.corruption) / sellTotalFees;
}
// on buy
else if (automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForLiquidity += (fees * taxes.liquidity) / buyTotalFees;
tokensForCooking += (fees * taxes.cooking) / buyTotalFees;
tokensForCorruption += (fees * taxes.corruption) / buyTotalFees;
}
if (fees > 0) {
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
function withdrawStuckToken() external onlyOwner {
}
function withdrawStuckToken(address _token, address _to) external onlyOwner {
}
function withdrawStuckEth(address toAddr) external onlyOwner {
}
// @dev team renounce blacklist commands
function renounceBlacklist() public onlyOwner {
}
function blacklist(address _addr) public onlyOwner {
}
// @dev blacklist v3 pools; can unblacklist() down the road to suit project and community
function blacklistLiquidityPool(address lpAddress) public onlyOwner {
}
// @dev unblacklist address; not affected by blacklistRenounced incase team wants to unblacklist v3 pools down the road
function unblacklist(address _addr) public onlyOwner {
}
function setPreListingTransferable(address _addr, bool isAuthorized) public onlyOwner {
}
}
| preListingTransferrable[from],"Not authorized to transfer pre-listing." | 130,095 | preListingTransferrable[from] |
"Team has revoked blacklist rights" | /**
WEBSITE: https://methereum.org/
TWITTER: https://twitter.com/methereum69
TELEGRAM: https://t.me/METHEREUEM
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
pragma experimental ABIEncoderV2;
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router01.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
//import "hardhat/console.sol";
contract METH is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
address public constant deadAddress = address(0x000000000000000000000000000000000000dEaD);
bool private swapping;
uint256 public maxTransactionAmount;
uint256 public maxWallet;
uint256 public swapTokensAtAmount;
uint256 public swapTokensAtMultiplier;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
bool public blacklistRenounced = false;
// Anti-bot and anti-whale mappings and variables
mapping(address => bool) blacklisted;
struct Taxes {
uint256 corruption;
uint256 liquidity;
uint256 cooking;
}
Taxes public taxes = Taxes(1, 0, 1);
Taxes public sellTaxes = Taxes(1, 0, 1);
uint256 public buyTotalFees;
uint256 public sellTotalFees;
uint256 public tokensForCorruption;
uint256 public tokensForLiquidity;
uint256 public tokensForCooking;
address private corruptionWallet;
address private cookingWallet;
/******************/
// exclude from fees and max transaction amount
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping(address => bool) public automatedMarketMakerPairs;
bool public preListingPhase = true;
mapping(address => bool) public preListingTransferrable;
event UpdateUniswapV2Router(address indexed newAddress,address indexed oldAddress);
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event CorruptionWalletUpdated(address indexed newWallet, address indexed oldWallet);
event CookingWalletUpdated(address indexed newWallet, address indexed oldWallet);
event SwapAndLiquify(uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiquidity);
constructor() ERC20("METHEREUM", "METH") {
}
receive() external payable {}
// once enabled, can never be turned off
function enableTrading() external onlyOwner {
}
// remove limits after token is stable
function removeLimits() external onlyOwner returns (bool) {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount)
external
onlyOwner
returns (bool)
{
}
function UpdateBuyTaxes(
uint256 _corruption,
uint256 _liquidity,
uint256 _cooking
) external onlyOwner {
}
function SetSellTaxes(
uint256 _corruption,
uint256 _liquidity,
uint256 _cooking
) external onlyOwner {
}
function updateMaxTxnAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx)
public
onlyOwner
{
}
// only use to disable contract sales if absolutely necessary (emergency use only)
function updateSwapEnabled(bool enabled) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value)
public
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateCorruptionWallet(address newWallet) external onlyOwner {
}
function updateCookingWallet(address newWallet) external onlyOwner {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
function isBlacklisted(address account) public view returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
function withdrawStuckToken() external onlyOwner {
}
function withdrawStuckToken(address _token, address _to) external onlyOwner {
}
function withdrawStuckEth(address toAddr) external onlyOwner {
}
// @dev team renounce blacklist commands
function renounceBlacklist() public onlyOwner {
}
function blacklist(address _addr) public onlyOwner {
require(<FILL_ME>)
require(
_addr != address(uniswapV2Pair) && _addr != address(uniswapV2Router),
"Cannot blacklist token's v2 router or v2 pool."
);
blacklisted[_addr] = true;
}
// @dev blacklist v3 pools; can unblacklist() down the road to suit project and community
function blacklistLiquidityPool(address lpAddress) public onlyOwner {
}
// @dev unblacklist address; not affected by blacklistRenounced incase team wants to unblacklist v3 pools down the road
function unblacklist(address _addr) public onlyOwner {
}
function setPreListingTransferable(address _addr, bool isAuthorized) public onlyOwner {
}
}
| !blacklistRenounced,"Team has revoked blacklist rights" | 130,095 | !blacklistRenounced |
'ERC721Metadata: URI query for nonexistent token' | pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
pragma solidity ^0.8.9 <0.9.0;
/**
* Russian Doll Experiment WEB3
* Go to function "mint" to see rules
*/
contract RussianDollExperiment is ERC1155Supply, Ownable, ERC1155Pausable, ERC1155Burnable, ReentrancyGuard{
using SafeMath for uint256;
using Strings for uint256;
bool public saleIsActive;//Token ID mint sale toggle manual cutoff after 48 hours
//Token ID 1 is 3 free per account
uint256 public tokenPrice = 0.001 ether; //ID 2-6 price
mapping(address => bool) public hasMinted;
event priceChange(address _by, uint256 price);
event PaymentReleased(address to, uint256 amount);
string public uriPrefix = "ipfs://QmSew3xPDBUGGB4zUgnnu8vURFZZNY9kMvq3T4cT5CBLV9/";
string public uriSuffix = ".json";
constructor() ERC1155(uriPrefix) {
}
modifier callerIsUser() {
}
//emergency pause
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
//name and symbol
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
//1155 function overrides
function _burn(
address account,
uint256 id,
uint256 amount
) internal virtual override(ERC1155, ERC1155Supply) {
}
function _mint(
address account,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual override(ERC1155, ERC1155Supply) {
}
function _mintBatch(
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual override(ERC1155, ERC1155Supply) {
}
function _burnBatch(
address account,
uint256[] memory ids,
uint256[] memory amounts
) internal virtual override(ERC1155, ERC1155Supply) {
}
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual override(ERC1155Pausable, ERC1155) {
}
//Manual ID 1 shut off
function flipSaleState() external onlyOwner {
}
//Token URI
function setURI(string memory newuri) external onlyOwner {
}
function tokenURI(uint256 tokenID) public view virtual returns (string memory) {
require(<FILL_ME>)
string memory currentBaseURI = uriPrefix;
return bytes(currentBaseURI).length > 0
? string(abi.encodePacked(currentBaseURI, tokenID.toString(), uriSuffix))
: '';
}
/**
* Set price to new value
*/
function setPrice(uint256 price) public onlyOwner {
}
/**
* ID 1 == FREE 3 max, ID's 2-6 = 0.001 ETH each. The people choose the rarity.
* You can only go forward in ID's not backwards, must have the previous ID to mint the next ID.
* 48hr open mint, then ID 1 can't be minted capping the supply making ID 1 deflationary, ID's 2-5 deflationary/inflationary and ID 6 inflationary.
*/
function mint(uint numberOfTokens, uint256 tokenID) public payable nonReentrant callerIsUser{
}
function withdraw() external onlyOwner{
}
}
| exists(tokenID),'ERC721Metadata: URI query for nonexistent token' | 130,383 | exists(tokenID) |
"You already minted your 3 free" | pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
pragma solidity ^0.8.9 <0.9.0;
/**
* Russian Doll Experiment WEB3
* Go to function "mint" to see rules
*/
contract RussianDollExperiment is ERC1155Supply, Ownable, ERC1155Pausable, ERC1155Burnable, ReentrancyGuard{
using SafeMath for uint256;
using Strings for uint256;
bool public saleIsActive;//Token ID mint sale toggle manual cutoff after 48 hours
//Token ID 1 is 3 free per account
uint256 public tokenPrice = 0.001 ether; //ID 2-6 price
mapping(address => bool) public hasMinted;
event priceChange(address _by, uint256 price);
event PaymentReleased(address to, uint256 amount);
string public uriPrefix = "ipfs://QmSew3xPDBUGGB4zUgnnu8vURFZZNY9kMvq3T4cT5CBLV9/";
string public uriSuffix = ".json";
constructor() ERC1155(uriPrefix) {
}
modifier callerIsUser() {
}
//emergency pause
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
//name and symbol
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
//1155 function overrides
function _burn(
address account,
uint256 id,
uint256 amount
) internal virtual override(ERC1155, ERC1155Supply) {
}
function _mint(
address account,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual override(ERC1155, ERC1155Supply) {
}
function _mintBatch(
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual override(ERC1155, ERC1155Supply) {
}
function _burnBatch(
address account,
uint256[] memory ids,
uint256[] memory amounts
) internal virtual override(ERC1155, ERC1155Supply) {
}
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual override(ERC1155Pausable, ERC1155) {
}
//Manual ID 1 shut off
function flipSaleState() external onlyOwner {
}
//Token URI
function setURI(string memory newuri) external onlyOwner {
}
function tokenURI(uint256 tokenID) public view virtual returns (string memory) {
}
/**
* Set price to new value
*/
function setPrice(uint256 price) public onlyOwner {
}
/**
* ID 1 == FREE 3 max, ID's 2-6 = 0.001 ETH each. The people choose the rarity.
* You can only go forward in ID's not backwards, must have the previous ID to mint the next ID.
* 48hr open mint, then ID 1 can't be minted capping the supply making ID 1 deflationary, ID's 2-5 deflationary/inflationary and ID 6 inflationary.
*/
function mint(uint numberOfTokens, uint256 tokenID) public payable nonReentrant callerIsUser{
require(!paused(), "Minting is paused");
require(numberOfTokens > 0 && numberOfTokens <= 20 ,"Can only mint 1-20 ");
require(tokenID > 0 && tokenID <= 6, "Incorrect Token Number" );
if (tokenID == 1 ){
require(saleIsActive, "sale not active");
require(<FILL_ME>)
require(numberOfTokens == 3 ,"ID 1 can only mint 3 per account nothing more or less");
hasMinted[_msgSender()] = true;
}
if (tokenID == 2 ){
require(tokenPrice * numberOfTokens == msg.value, "Ether value sent is not correct");
require(balanceOf(msg.sender, 1) >= numberOfTokens,"You don't have required token amount");
_burn(msg.sender, 1, numberOfTokens);
}
if (tokenID == 3 ){
require(tokenPrice * numberOfTokens == msg.value, "Ether value sent is not correct");
require(balanceOf(msg.sender, 2) >= numberOfTokens,"You don't have required token amount");
_burn(msg.sender, 2, numberOfTokens);
}
if (tokenID == 4 ){
require(tokenPrice * numberOfTokens == msg.value, "Ether value sent is not correct");
require(balanceOf(msg.sender, 3) >= numberOfTokens,"You don't have required token amount");
_burn(msg.sender, 3, numberOfTokens);
}
if (tokenID == 5 ){
require(tokenPrice * numberOfTokens == msg.value, "Ether value sent is not correct");
require(balanceOf(msg.sender, 4) >= numberOfTokens,"You don't have required token amount");
_burn(msg.sender, 4, numberOfTokens);
}
if (tokenID == 6 ){
require(tokenPrice * numberOfTokens == msg.value, "Ether value sent is not correct");
require(balanceOf(msg.sender, 5) >= numberOfTokens,"You don't have required token amount");
_burn(msg.sender, 5, numberOfTokens);
}
_mint(msg.sender,tokenID,numberOfTokens , "");
}
function withdraw() external onlyOwner{
}
}
| !hasMinted[_msgSender()],"You already minted your 3 free" | 130,383 | !hasMinted[_msgSender()] |
"Ether value sent is not correct" | pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
pragma solidity ^0.8.9 <0.9.0;
/**
* Russian Doll Experiment WEB3
* Go to function "mint" to see rules
*/
contract RussianDollExperiment is ERC1155Supply, Ownable, ERC1155Pausable, ERC1155Burnable, ReentrancyGuard{
using SafeMath for uint256;
using Strings for uint256;
bool public saleIsActive;//Token ID mint sale toggle manual cutoff after 48 hours
//Token ID 1 is 3 free per account
uint256 public tokenPrice = 0.001 ether; //ID 2-6 price
mapping(address => bool) public hasMinted;
event priceChange(address _by, uint256 price);
event PaymentReleased(address to, uint256 amount);
string public uriPrefix = "ipfs://QmSew3xPDBUGGB4zUgnnu8vURFZZNY9kMvq3T4cT5CBLV9/";
string public uriSuffix = ".json";
constructor() ERC1155(uriPrefix) {
}
modifier callerIsUser() {
}
//emergency pause
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
//name and symbol
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
//1155 function overrides
function _burn(
address account,
uint256 id,
uint256 amount
) internal virtual override(ERC1155, ERC1155Supply) {
}
function _mint(
address account,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual override(ERC1155, ERC1155Supply) {
}
function _mintBatch(
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual override(ERC1155, ERC1155Supply) {
}
function _burnBatch(
address account,
uint256[] memory ids,
uint256[] memory amounts
) internal virtual override(ERC1155, ERC1155Supply) {
}
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual override(ERC1155Pausable, ERC1155) {
}
//Manual ID 1 shut off
function flipSaleState() external onlyOwner {
}
//Token URI
function setURI(string memory newuri) external onlyOwner {
}
function tokenURI(uint256 tokenID) public view virtual returns (string memory) {
}
/**
* Set price to new value
*/
function setPrice(uint256 price) public onlyOwner {
}
/**
* ID 1 == FREE 3 max, ID's 2-6 = 0.001 ETH each. The people choose the rarity.
* You can only go forward in ID's not backwards, must have the previous ID to mint the next ID.
* 48hr open mint, then ID 1 can't be minted capping the supply making ID 1 deflationary, ID's 2-5 deflationary/inflationary and ID 6 inflationary.
*/
function mint(uint numberOfTokens, uint256 tokenID) public payable nonReentrant callerIsUser{
require(!paused(), "Minting is paused");
require(numberOfTokens > 0 && numberOfTokens <= 20 ,"Can only mint 1-20 ");
require(tokenID > 0 && tokenID <= 6, "Incorrect Token Number" );
if (tokenID == 1 ){
require(saleIsActive, "sale not active");
require(!hasMinted[_msgSender()],"You already minted your 3 free");
require(numberOfTokens == 3 ,"ID 1 can only mint 3 per account nothing more or less");
hasMinted[_msgSender()] = true;
}
if (tokenID == 2 ){
require(<FILL_ME>)
require(balanceOf(msg.sender, 1) >= numberOfTokens,"You don't have required token amount");
_burn(msg.sender, 1, numberOfTokens);
}
if (tokenID == 3 ){
require(tokenPrice * numberOfTokens == msg.value, "Ether value sent is not correct");
require(balanceOf(msg.sender, 2) >= numberOfTokens,"You don't have required token amount");
_burn(msg.sender, 2, numberOfTokens);
}
if (tokenID == 4 ){
require(tokenPrice * numberOfTokens == msg.value, "Ether value sent is not correct");
require(balanceOf(msg.sender, 3) >= numberOfTokens,"You don't have required token amount");
_burn(msg.sender, 3, numberOfTokens);
}
if (tokenID == 5 ){
require(tokenPrice * numberOfTokens == msg.value, "Ether value sent is not correct");
require(balanceOf(msg.sender, 4) >= numberOfTokens,"You don't have required token amount");
_burn(msg.sender, 4, numberOfTokens);
}
if (tokenID == 6 ){
require(tokenPrice * numberOfTokens == msg.value, "Ether value sent is not correct");
require(balanceOf(msg.sender, 5) >= numberOfTokens,"You don't have required token amount");
_burn(msg.sender, 5, numberOfTokens);
}
_mint(msg.sender,tokenID,numberOfTokens , "");
}
function withdraw() external onlyOwner{
}
}
| tokenPrice*numberOfTokens==msg.value,"Ether value sent is not correct" | 130,383 | tokenPrice*numberOfTokens==msg.value |
"You don't have required token amount" | pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
pragma solidity ^0.8.9 <0.9.0;
/**
* Russian Doll Experiment WEB3
* Go to function "mint" to see rules
*/
contract RussianDollExperiment is ERC1155Supply, Ownable, ERC1155Pausable, ERC1155Burnable, ReentrancyGuard{
using SafeMath for uint256;
using Strings for uint256;
bool public saleIsActive;//Token ID mint sale toggle manual cutoff after 48 hours
//Token ID 1 is 3 free per account
uint256 public tokenPrice = 0.001 ether; //ID 2-6 price
mapping(address => bool) public hasMinted;
event priceChange(address _by, uint256 price);
event PaymentReleased(address to, uint256 amount);
string public uriPrefix = "ipfs://QmSew3xPDBUGGB4zUgnnu8vURFZZNY9kMvq3T4cT5CBLV9/";
string public uriSuffix = ".json";
constructor() ERC1155(uriPrefix) {
}
modifier callerIsUser() {
}
//emergency pause
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
//name and symbol
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
//1155 function overrides
function _burn(
address account,
uint256 id,
uint256 amount
) internal virtual override(ERC1155, ERC1155Supply) {
}
function _mint(
address account,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual override(ERC1155, ERC1155Supply) {
}
function _mintBatch(
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual override(ERC1155, ERC1155Supply) {
}
function _burnBatch(
address account,
uint256[] memory ids,
uint256[] memory amounts
) internal virtual override(ERC1155, ERC1155Supply) {
}
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual override(ERC1155Pausable, ERC1155) {
}
//Manual ID 1 shut off
function flipSaleState() external onlyOwner {
}
//Token URI
function setURI(string memory newuri) external onlyOwner {
}
function tokenURI(uint256 tokenID) public view virtual returns (string memory) {
}
/**
* Set price to new value
*/
function setPrice(uint256 price) public onlyOwner {
}
/**
* ID 1 == FREE 3 max, ID's 2-6 = 0.001 ETH each. The people choose the rarity.
* You can only go forward in ID's not backwards, must have the previous ID to mint the next ID.
* 48hr open mint, then ID 1 can't be minted capping the supply making ID 1 deflationary, ID's 2-5 deflationary/inflationary and ID 6 inflationary.
*/
function mint(uint numberOfTokens, uint256 tokenID) public payable nonReentrant callerIsUser{
require(!paused(), "Minting is paused");
require(numberOfTokens > 0 && numberOfTokens <= 20 ,"Can only mint 1-20 ");
require(tokenID > 0 && tokenID <= 6, "Incorrect Token Number" );
if (tokenID == 1 ){
require(saleIsActive, "sale not active");
require(!hasMinted[_msgSender()],"You already minted your 3 free");
require(numberOfTokens == 3 ,"ID 1 can only mint 3 per account nothing more or less");
hasMinted[_msgSender()] = true;
}
if (tokenID == 2 ){
require(tokenPrice * numberOfTokens == msg.value, "Ether value sent is not correct");
require(<FILL_ME>)
_burn(msg.sender, 1, numberOfTokens);
}
if (tokenID == 3 ){
require(tokenPrice * numberOfTokens == msg.value, "Ether value sent is not correct");
require(balanceOf(msg.sender, 2) >= numberOfTokens,"You don't have required token amount");
_burn(msg.sender, 2, numberOfTokens);
}
if (tokenID == 4 ){
require(tokenPrice * numberOfTokens == msg.value, "Ether value sent is not correct");
require(balanceOf(msg.sender, 3) >= numberOfTokens,"You don't have required token amount");
_burn(msg.sender, 3, numberOfTokens);
}
if (tokenID == 5 ){
require(tokenPrice * numberOfTokens == msg.value, "Ether value sent is not correct");
require(balanceOf(msg.sender, 4) >= numberOfTokens,"You don't have required token amount");
_burn(msg.sender, 4, numberOfTokens);
}
if (tokenID == 6 ){
require(tokenPrice * numberOfTokens == msg.value, "Ether value sent is not correct");
require(balanceOf(msg.sender, 5) >= numberOfTokens,"You don't have required token amount");
_burn(msg.sender, 5, numberOfTokens);
}
_mint(msg.sender,tokenID,numberOfTokens , "");
}
function withdraw() external onlyOwner{
}
}
| balanceOf(msg.sender,1)>=numberOfTokens,"You don't have required token amount" | 130,383 | balanceOf(msg.sender,1)>=numberOfTokens |
"You don't have required token amount" | pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
pragma solidity ^0.8.9 <0.9.0;
/**
* Russian Doll Experiment WEB3
* Go to function "mint" to see rules
*/
contract RussianDollExperiment is ERC1155Supply, Ownable, ERC1155Pausable, ERC1155Burnable, ReentrancyGuard{
using SafeMath for uint256;
using Strings for uint256;
bool public saleIsActive;//Token ID mint sale toggle manual cutoff after 48 hours
//Token ID 1 is 3 free per account
uint256 public tokenPrice = 0.001 ether; //ID 2-6 price
mapping(address => bool) public hasMinted;
event priceChange(address _by, uint256 price);
event PaymentReleased(address to, uint256 amount);
string public uriPrefix = "ipfs://QmSew3xPDBUGGB4zUgnnu8vURFZZNY9kMvq3T4cT5CBLV9/";
string public uriSuffix = ".json";
constructor() ERC1155(uriPrefix) {
}
modifier callerIsUser() {
}
//emergency pause
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
//name and symbol
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
//1155 function overrides
function _burn(
address account,
uint256 id,
uint256 amount
) internal virtual override(ERC1155, ERC1155Supply) {
}
function _mint(
address account,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual override(ERC1155, ERC1155Supply) {
}
function _mintBatch(
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual override(ERC1155, ERC1155Supply) {
}
function _burnBatch(
address account,
uint256[] memory ids,
uint256[] memory amounts
) internal virtual override(ERC1155, ERC1155Supply) {
}
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual override(ERC1155Pausable, ERC1155) {
}
//Manual ID 1 shut off
function flipSaleState() external onlyOwner {
}
//Token URI
function setURI(string memory newuri) external onlyOwner {
}
function tokenURI(uint256 tokenID) public view virtual returns (string memory) {
}
/**
* Set price to new value
*/
function setPrice(uint256 price) public onlyOwner {
}
/**
* ID 1 == FREE 3 max, ID's 2-6 = 0.001 ETH each. The people choose the rarity.
* You can only go forward in ID's not backwards, must have the previous ID to mint the next ID.
* 48hr open mint, then ID 1 can't be minted capping the supply making ID 1 deflationary, ID's 2-5 deflationary/inflationary and ID 6 inflationary.
*/
function mint(uint numberOfTokens, uint256 tokenID) public payable nonReentrant callerIsUser{
require(!paused(), "Minting is paused");
require(numberOfTokens > 0 && numberOfTokens <= 20 ,"Can only mint 1-20 ");
require(tokenID > 0 && tokenID <= 6, "Incorrect Token Number" );
if (tokenID == 1 ){
require(saleIsActive, "sale not active");
require(!hasMinted[_msgSender()],"You already minted your 3 free");
require(numberOfTokens == 3 ,"ID 1 can only mint 3 per account nothing more or less");
hasMinted[_msgSender()] = true;
}
if (tokenID == 2 ){
require(tokenPrice * numberOfTokens == msg.value, "Ether value sent is not correct");
require(balanceOf(msg.sender, 1) >= numberOfTokens,"You don't have required token amount");
_burn(msg.sender, 1, numberOfTokens);
}
if (tokenID == 3 ){
require(tokenPrice * numberOfTokens == msg.value, "Ether value sent is not correct");
require(<FILL_ME>)
_burn(msg.sender, 2, numberOfTokens);
}
if (tokenID == 4 ){
require(tokenPrice * numberOfTokens == msg.value, "Ether value sent is not correct");
require(balanceOf(msg.sender, 3) >= numberOfTokens,"You don't have required token amount");
_burn(msg.sender, 3, numberOfTokens);
}
if (tokenID == 5 ){
require(tokenPrice * numberOfTokens == msg.value, "Ether value sent is not correct");
require(balanceOf(msg.sender, 4) >= numberOfTokens,"You don't have required token amount");
_burn(msg.sender, 4, numberOfTokens);
}
if (tokenID == 6 ){
require(tokenPrice * numberOfTokens == msg.value, "Ether value sent is not correct");
require(balanceOf(msg.sender, 5) >= numberOfTokens,"You don't have required token amount");
_burn(msg.sender, 5, numberOfTokens);
}
_mint(msg.sender,tokenID,numberOfTokens , "");
}
function withdraw() external onlyOwner{
}
}
| balanceOf(msg.sender,2)>=numberOfTokens,"You don't have required token amount" | 130,383 | balanceOf(msg.sender,2)>=numberOfTokens |
"You don't have required token amount" | pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
pragma solidity ^0.8.9 <0.9.0;
/**
* Russian Doll Experiment WEB3
* Go to function "mint" to see rules
*/
contract RussianDollExperiment is ERC1155Supply, Ownable, ERC1155Pausable, ERC1155Burnable, ReentrancyGuard{
using SafeMath for uint256;
using Strings for uint256;
bool public saleIsActive;//Token ID mint sale toggle manual cutoff after 48 hours
//Token ID 1 is 3 free per account
uint256 public tokenPrice = 0.001 ether; //ID 2-6 price
mapping(address => bool) public hasMinted;
event priceChange(address _by, uint256 price);
event PaymentReleased(address to, uint256 amount);
string public uriPrefix = "ipfs://QmSew3xPDBUGGB4zUgnnu8vURFZZNY9kMvq3T4cT5CBLV9/";
string public uriSuffix = ".json";
constructor() ERC1155(uriPrefix) {
}
modifier callerIsUser() {
}
//emergency pause
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
//name and symbol
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
//1155 function overrides
function _burn(
address account,
uint256 id,
uint256 amount
) internal virtual override(ERC1155, ERC1155Supply) {
}
function _mint(
address account,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual override(ERC1155, ERC1155Supply) {
}
function _mintBatch(
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual override(ERC1155, ERC1155Supply) {
}
function _burnBatch(
address account,
uint256[] memory ids,
uint256[] memory amounts
) internal virtual override(ERC1155, ERC1155Supply) {
}
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual override(ERC1155Pausable, ERC1155) {
}
//Manual ID 1 shut off
function flipSaleState() external onlyOwner {
}
//Token URI
function setURI(string memory newuri) external onlyOwner {
}
function tokenURI(uint256 tokenID) public view virtual returns (string memory) {
}
/**
* Set price to new value
*/
function setPrice(uint256 price) public onlyOwner {
}
/**
* ID 1 == FREE 3 max, ID's 2-6 = 0.001 ETH each. The people choose the rarity.
* You can only go forward in ID's not backwards, must have the previous ID to mint the next ID.
* 48hr open mint, then ID 1 can't be minted capping the supply making ID 1 deflationary, ID's 2-5 deflationary/inflationary and ID 6 inflationary.
*/
function mint(uint numberOfTokens, uint256 tokenID) public payable nonReentrant callerIsUser{
require(!paused(), "Minting is paused");
require(numberOfTokens > 0 && numberOfTokens <= 20 ,"Can only mint 1-20 ");
require(tokenID > 0 && tokenID <= 6, "Incorrect Token Number" );
if (tokenID == 1 ){
require(saleIsActive, "sale not active");
require(!hasMinted[_msgSender()],"You already minted your 3 free");
require(numberOfTokens == 3 ,"ID 1 can only mint 3 per account nothing more or less");
hasMinted[_msgSender()] = true;
}
if (tokenID == 2 ){
require(tokenPrice * numberOfTokens == msg.value, "Ether value sent is not correct");
require(balanceOf(msg.sender, 1) >= numberOfTokens,"You don't have required token amount");
_burn(msg.sender, 1, numberOfTokens);
}
if (tokenID == 3 ){
require(tokenPrice * numberOfTokens == msg.value, "Ether value sent is not correct");
require(balanceOf(msg.sender, 2) >= numberOfTokens,"You don't have required token amount");
_burn(msg.sender, 2, numberOfTokens);
}
if (tokenID == 4 ){
require(tokenPrice * numberOfTokens == msg.value, "Ether value sent is not correct");
require(<FILL_ME>)
_burn(msg.sender, 3, numberOfTokens);
}
if (tokenID == 5 ){
require(tokenPrice * numberOfTokens == msg.value, "Ether value sent is not correct");
require(balanceOf(msg.sender, 4) >= numberOfTokens,"You don't have required token amount");
_burn(msg.sender, 4, numberOfTokens);
}
if (tokenID == 6 ){
require(tokenPrice * numberOfTokens == msg.value, "Ether value sent is not correct");
require(balanceOf(msg.sender, 5) >= numberOfTokens,"You don't have required token amount");
_burn(msg.sender, 5, numberOfTokens);
}
_mint(msg.sender,tokenID,numberOfTokens , "");
}
function withdraw() external onlyOwner{
}
}
| balanceOf(msg.sender,3)>=numberOfTokens,"You don't have required token amount" | 130,383 | balanceOf(msg.sender,3)>=numberOfTokens |
"You don't have required token amount" | pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
pragma solidity ^0.8.9 <0.9.0;
/**
* Russian Doll Experiment WEB3
* Go to function "mint" to see rules
*/
contract RussianDollExperiment is ERC1155Supply, Ownable, ERC1155Pausable, ERC1155Burnable, ReentrancyGuard{
using SafeMath for uint256;
using Strings for uint256;
bool public saleIsActive;//Token ID mint sale toggle manual cutoff after 48 hours
//Token ID 1 is 3 free per account
uint256 public tokenPrice = 0.001 ether; //ID 2-6 price
mapping(address => bool) public hasMinted;
event priceChange(address _by, uint256 price);
event PaymentReleased(address to, uint256 amount);
string public uriPrefix = "ipfs://QmSew3xPDBUGGB4zUgnnu8vURFZZNY9kMvq3T4cT5CBLV9/";
string public uriSuffix = ".json";
constructor() ERC1155(uriPrefix) {
}
modifier callerIsUser() {
}
//emergency pause
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
//name and symbol
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
//1155 function overrides
function _burn(
address account,
uint256 id,
uint256 amount
) internal virtual override(ERC1155, ERC1155Supply) {
}
function _mint(
address account,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual override(ERC1155, ERC1155Supply) {
}
function _mintBatch(
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual override(ERC1155, ERC1155Supply) {
}
function _burnBatch(
address account,
uint256[] memory ids,
uint256[] memory amounts
) internal virtual override(ERC1155, ERC1155Supply) {
}
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual override(ERC1155Pausable, ERC1155) {
}
//Manual ID 1 shut off
function flipSaleState() external onlyOwner {
}
//Token URI
function setURI(string memory newuri) external onlyOwner {
}
function tokenURI(uint256 tokenID) public view virtual returns (string memory) {
}
/**
* Set price to new value
*/
function setPrice(uint256 price) public onlyOwner {
}
/**
* ID 1 == FREE 3 max, ID's 2-6 = 0.001 ETH each. The people choose the rarity.
* You can only go forward in ID's not backwards, must have the previous ID to mint the next ID.
* 48hr open mint, then ID 1 can't be minted capping the supply making ID 1 deflationary, ID's 2-5 deflationary/inflationary and ID 6 inflationary.
*/
function mint(uint numberOfTokens, uint256 tokenID) public payable nonReentrant callerIsUser{
require(!paused(), "Minting is paused");
require(numberOfTokens > 0 && numberOfTokens <= 20 ,"Can only mint 1-20 ");
require(tokenID > 0 && tokenID <= 6, "Incorrect Token Number" );
if (tokenID == 1 ){
require(saleIsActive, "sale not active");
require(!hasMinted[_msgSender()],"You already minted your 3 free");
require(numberOfTokens == 3 ,"ID 1 can only mint 3 per account nothing more or less");
hasMinted[_msgSender()] = true;
}
if (tokenID == 2 ){
require(tokenPrice * numberOfTokens == msg.value, "Ether value sent is not correct");
require(balanceOf(msg.sender, 1) >= numberOfTokens,"You don't have required token amount");
_burn(msg.sender, 1, numberOfTokens);
}
if (tokenID == 3 ){
require(tokenPrice * numberOfTokens == msg.value, "Ether value sent is not correct");
require(balanceOf(msg.sender, 2) >= numberOfTokens,"You don't have required token amount");
_burn(msg.sender, 2, numberOfTokens);
}
if (tokenID == 4 ){
require(tokenPrice * numberOfTokens == msg.value, "Ether value sent is not correct");
require(balanceOf(msg.sender, 3) >= numberOfTokens,"You don't have required token amount");
_burn(msg.sender, 3, numberOfTokens);
}
if (tokenID == 5 ){
require(tokenPrice * numberOfTokens == msg.value, "Ether value sent is not correct");
require(<FILL_ME>)
_burn(msg.sender, 4, numberOfTokens);
}
if (tokenID == 6 ){
require(tokenPrice * numberOfTokens == msg.value, "Ether value sent is not correct");
require(balanceOf(msg.sender, 5) >= numberOfTokens,"You don't have required token amount");
_burn(msg.sender, 5, numberOfTokens);
}
_mint(msg.sender,tokenID,numberOfTokens , "");
}
function withdraw() external onlyOwner{
}
}
| balanceOf(msg.sender,4)>=numberOfTokens,"You don't have required token amount" | 130,383 | balanceOf(msg.sender,4)>=numberOfTokens |
"You don't have required token amount" | pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
pragma solidity ^0.8.9 <0.9.0;
/**
* Russian Doll Experiment WEB3
* Go to function "mint" to see rules
*/
contract RussianDollExperiment is ERC1155Supply, Ownable, ERC1155Pausable, ERC1155Burnable, ReentrancyGuard{
using SafeMath for uint256;
using Strings for uint256;
bool public saleIsActive;//Token ID mint sale toggle manual cutoff after 48 hours
//Token ID 1 is 3 free per account
uint256 public tokenPrice = 0.001 ether; //ID 2-6 price
mapping(address => bool) public hasMinted;
event priceChange(address _by, uint256 price);
event PaymentReleased(address to, uint256 amount);
string public uriPrefix = "ipfs://QmSew3xPDBUGGB4zUgnnu8vURFZZNY9kMvq3T4cT5CBLV9/";
string public uriSuffix = ".json";
constructor() ERC1155(uriPrefix) {
}
modifier callerIsUser() {
}
//emergency pause
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
//name and symbol
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
//1155 function overrides
function _burn(
address account,
uint256 id,
uint256 amount
) internal virtual override(ERC1155, ERC1155Supply) {
}
function _mint(
address account,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual override(ERC1155, ERC1155Supply) {
}
function _mintBatch(
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual override(ERC1155, ERC1155Supply) {
}
function _burnBatch(
address account,
uint256[] memory ids,
uint256[] memory amounts
) internal virtual override(ERC1155, ERC1155Supply) {
}
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual override(ERC1155Pausable, ERC1155) {
}
//Manual ID 1 shut off
function flipSaleState() external onlyOwner {
}
//Token URI
function setURI(string memory newuri) external onlyOwner {
}
function tokenURI(uint256 tokenID) public view virtual returns (string memory) {
}
/**
* Set price to new value
*/
function setPrice(uint256 price) public onlyOwner {
}
/**
* ID 1 == FREE 3 max, ID's 2-6 = 0.001 ETH each. The people choose the rarity.
* You can only go forward in ID's not backwards, must have the previous ID to mint the next ID.
* 48hr open mint, then ID 1 can't be minted capping the supply making ID 1 deflationary, ID's 2-5 deflationary/inflationary and ID 6 inflationary.
*/
function mint(uint numberOfTokens, uint256 tokenID) public payable nonReentrant callerIsUser{
require(!paused(), "Minting is paused");
require(numberOfTokens > 0 && numberOfTokens <= 20 ,"Can only mint 1-20 ");
require(tokenID > 0 && tokenID <= 6, "Incorrect Token Number" );
if (tokenID == 1 ){
require(saleIsActive, "sale not active");
require(!hasMinted[_msgSender()],"You already minted your 3 free");
require(numberOfTokens == 3 ,"ID 1 can only mint 3 per account nothing more or less");
hasMinted[_msgSender()] = true;
}
if (tokenID == 2 ){
require(tokenPrice * numberOfTokens == msg.value, "Ether value sent is not correct");
require(balanceOf(msg.sender, 1) >= numberOfTokens,"You don't have required token amount");
_burn(msg.sender, 1, numberOfTokens);
}
if (tokenID == 3 ){
require(tokenPrice * numberOfTokens == msg.value, "Ether value sent is not correct");
require(balanceOf(msg.sender, 2) >= numberOfTokens,"You don't have required token amount");
_burn(msg.sender, 2, numberOfTokens);
}
if (tokenID == 4 ){
require(tokenPrice * numberOfTokens == msg.value, "Ether value sent is not correct");
require(balanceOf(msg.sender, 3) >= numberOfTokens,"You don't have required token amount");
_burn(msg.sender, 3, numberOfTokens);
}
if (tokenID == 5 ){
require(tokenPrice * numberOfTokens == msg.value, "Ether value sent is not correct");
require(balanceOf(msg.sender, 4) >= numberOfTokens,"You don't have required token amount");
_burn(msg.sender, 4, numberOfTokens);
}
if (tokenID == 6 ){
require(tokenPrice * numberOfTokens == msg.value, "Ether value sent is not correct");
require(<FILL_ME>)
_burn(msg.sender, 5, numberOfTokens);
}
_mint(msg.sender,tokenID,numberOfTokens , "");
}
function withdraw() external onlyOwner{
}
}
| balanceOf(msg.sender,5)>=numberOfTokens,"You don't have required token amount" | 130,383 | balanceOf(msg.sender,5)>=numberOfTokens |
"RoyaltiesByToken recipient should be present" | // SPDX-License-Identifier: MIT
pragma solidity >=0.6.2 <0.8.0;
pragma abicoder v2;
import "./IRoyaltiesProvider.sol";
import "@rarible/royalties/contracts/LibRoyaltiesV2.sol";
import "@rarible/royalties/contracts/LibRoyaltiesV1.sol";
import "@rarible/royalties/contracts/impl/RoyaltiesV1Impl.sol";
import "@rarible/royalties/contracts/impl/RoyaltiesV2Impl.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/ReentrancyGuardUpgradeable.sol";
contract RoyaltiesRegistry is IRoyaltiesProvider, OwnableUpgradeable, ReentrancyGuardUpgradeable {
struct RoyaltiesSet {
bool initialized;
LibPart.Part[] royalties;
}
mapping(bytes32 => RoyaltiesSet) public royaltiesByTokenAndTokenId;
mapping(address => RoyaltiesSet) public royaltiesByToken;
mapping(address => address) public royaltiesProviders;
function initializeRoyaltiesRegistry() external initializer {
}
function setProviderByToken(address token, address provider) external nonReentrant {
}
function setRoyaltiesByToken(address token, LibPart.Part[] memory royalties) external nonReentrant {
checkOwner(token);
uint sumRoyalties = 0;
for (uint i = 0; i < royalties.length; i++) {
require(<FILL_ME>)
require(royalties[i].value != 0, "Fee value for RoyaltiesByToken should be > 0");
royaltiesByToken[token].royalties.push(royalties[i]);
sumRoyalties += royalties[i].value;
}
require(sumRoyalties < 10000, "Set by token royalties sum more, than 100%");
royaltiesByToken[token].initialized = true;
}
function setRoyaltiesByTokenAndTokenId(address token, uint tokenId, LibPart.Part[] memory royalties) external nonReentrant {
}
function checkOwner(address token) internal view {
}
function getRoyalties(address token, uint tokenId) override external nonReentrant returns (LibPart.Part[] memory) {
}
function setRoyaltiesCacheByTokenAndTokenId(address token, uint tokenId, LibPart.Part[] memory royalties) internal {
}
function royaltiesFromContract(address token, uint tokenId) internal view returns (LibPart.Part[] memory feesRecipients) {
}
function providerExtractor(address token) internal returns (bool result, LibPart.Part[] memory royalties) {
}
uint256[46] private __gap;
}
| royalties[i].account!=address(0x0),"RoyaltiesByToken recipient should be present" | 130,510 | royalties[i].account!=address(0x0) |
"Fee value for RoyaltiesByToken should be > 0" | // SPDX-License-Identifier: MIT
pragma solidity >=0.6.2 <0.8.0;
pragma abicoder v2;
import "./IRoyaltiesProvider.sol";
import "@rarible/royalties/contracts/LibRoyaltiesV2.sol";
import "@rarible/royalties/contracts/LibRoyaltiesV1.sol";
import "@rarible/royalties/contracts/impl/RoyaltiesV1Impl.sol";
import "@rarible/royalties/contracts/impl/RoyaltiesV2Impl.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/ReentrancyGuardUpgradeable.sol";
contract RoyaltiesRegistry is IRoyaltiesProvider, OwnableUpgradeable, ReentrancyGuardUpgradeable {
struct RoyaltiesSet {
bool initialized;
LibPart.Part[] royalties;
}
mapping(bytes32 => RoyaltiesSet) public royaltiesByTokenAndTokenId;
mapping(address => RoyaltiesSet) public royaltiesByToken;
mapping(address => address) public royaltiesProviders;
function initializeRoyaltiesRegistry() external initializer {
}
function setProviderByToken(address token, address provider) external nonReentrant {
}
function setRoyaltiesByToken(address token, LibPart.Part[] memory royalties) external nonReentrant {
checkOwner(token);
uint sumRoyalties = 0;
for (uint i = 0; i < royalties.length; i++) {
require(royalties[i].account != address(0x0), "RoyaltiesByToken recipient should be present");
require(<FILL_ME>)
royaltiesByToken[token].royalties.push(royalties[i]);
sumRoyalties += royalties[i].value;
}
require(sumRoyalties < 10000, "Set by token royalties sum more, than 100%");
royaltiesByToken[token].initialized = true;
}
function setRoyaltiesByTokenAndTokenId(address token, uint tokenId, LibPart.Part[] memory royalties) external nonReentrant {
}
function checkOwner(address token) internal view {
}
function getRoyalties(address token, uint tokenId) override external nonReentrant returns (LibPart.Part[] memory) {
}
function setRoyaltiesCacheByTokenAndTokenId(address token, uint tokenId, LibPart.Part[] memory royalties) internal {
}
function royaltiesFromContract(address token, uint tokenId) internal view returns (LibPart.Part[] memory feesRecipients) {
}
function providerExtractor(address token) internal returns (bool result, LibPart.Part[] memory royalties) {
}
uint256[46] private __gap;
}
| royalties[i].value!=0,"Fee value for RoyaltiesByToken should be > 0" | 130,510 | royalties[i].value!=0 |
"Abel: Each Address can only purchase 3 sets" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "./ERC721.sol";
import "./Ownable.sol";
import "./ReentrancyGuard.sol";
import "./ERC721Enumerable.sol";
contract AOM_FANSI_LOFIHIFI_001 is Ownable, ReentrancyGuard, ERC721Enumerable {
using Strings for uint256;
string public baseTokenURI;
bool public isPaused = false;
uint256 public constant maxSupply = 95;
uint256 public constant price = 0.15 ether;
uint256 public constant wlPrice = 0.12 ether;
address constant metaBoomAddr = 0x4C22D3B875437D43402F5B81aE4f61b8F764E1b1;
uint256 public wlSaleStartTime = 1667914200;
uint256 public wlSaleEndTime = 1668083400;
uint256 public publicSaleStartTime = 1668087000;
uint256 public publicSaleEndTime = 1668605400;
uint8 public amountPerAddr = 3;
uint8 public wlAmountPerAddr = 1;
uint8 public bonusDrop = 0;
uint8 public curSold = 0;
uint16 public totalSold = 0;
mapping(uint8 => bool) public bonusList;
mapping(uint8 => mbBonus) public mbBonusList;
mapping(address => uint8) public holdedNumAry;
mapping(address => bool) public whiteList;
struct mbBonus {
address bonusHolder;
uint16 bonusNo;
}
constructor(
string memory _name,
string memory _symbol,
string memory _uri
) ERC721(_name, _symbol) {
}
function publicSale(uint8 _purchaseNum)
external
payable
onlyUser
nonReentrant
{
require(!isPaused, "Abel: currently paused");
require(
block.timestamp >= publicSaleStartTime,
"Abel: public sale is not started yet"
);
require(<FILL_ME>)
require(
(totalSold + _purchaseNum*3) <= maxSupply,
"Abel: reached max supply"
);
require(
msg.value >= (price * _purchaseNum),
"Abel: price is incorrect"
);
for (uint8 i = 1; i <= _purchaseNum*3; i++) {
_safeMint(_msgSender(), totalSold + i);
}
ERC721 MB = ERC721(metaBoomAddr);
for (uint8 i = 0; i < _purchaseNum; i++) {
if(bonusList[curSold + i + 1]){
_safeMint(_msgSender(), maxSupply - bonusDrop);
bonusDrop = bonusDrop + 1;
}
MB.safeTransferFrom(mbBonusList[curSold + i].bonusHolder, _msgSender(), mbBonusList[curSold + i].bonusNo);
}
holdedNumAry[_msgSender()] = holdedNumAry[_msgSender()] + _purchaseNum;
curSold = curSold + _purchaseNum;
totalSold = totalSold + _purchaseNum*3;
}
function whiteListSale(uint8 _purchaseNum)
external
payable
onlyWhiteList
onlyUser
nonReentrant
{
}
function ownerMInt(address _addr, uint8 _amount) external onlyOwner {
}
modifier onlyWhiteList() {
}
modifier onlyUser() {
}
function addBatchWhiteList(address[] memory _accounts) external onlyOwner {
}
function addBonusList(uint8[] memory _bonus) external onlyOwner {
}
function setMBBonusList(address[] memory _bonusHolder, uint16[] memory _bonusNo) external onlyOwner {
}
function setWlStartTime(uint256 _time) external onlyOwner {
}
function setWlEndTime(uint256 _time) external onlyOwner {
}
function setPublicStartTime(uint256 _time) external onlyOwner {
}
function setPublicEndTime(uint256 _time) external onlyOwner {
}
function setBaseURI(string memory _baseURI) external onlyOwner {
}
function setPause(bool _isPaused) external onlyOwner returns (bool) {
}
function withdraw() external onlyOwner {
}
function tokensOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
}
| (holdedNumAry[_msgSender()]+_purchaseNum)<=amountPerAddr,"Abel: Each Address can only purchase 3 sets" | 130,582 | (holdedNumAry[_msgSender()]+_purchaseNum)<=amountPerAddr |
"Abel: reached max supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "./ERC721.sol";
import "./Ownable.sol";
import "./ReentrancyGuard.sol";
import "./ERC721Enumerable.sol";
contract AOM_FANSI_LOFIHIFI_001 is Ownable, ReentrancyGuard, ERC721Enumerable {
using Strings for uint256;
string public baseTokenURI;
bool public isPaused = false;
uint256 public constant maxSupply = 95;
uint256 public constant price = 0.15 ether;
uint256 public constant wlPrice = 0.12 ether;
address constant metaBoomAddr = 0x4C22D3B875437D43402F5B81aE4f61b8F764E1b1;
uint256 public wlSaleStartTime = 1667914200;
uint256 public wlSaleEndTime = 1668083400;
uint256 public publicSaleStartTime = 1668087000;
uint256 public publicSaleEndTime = 1668605400;
uint8 public amountPerAddr = 3;
uint8 public wlAmountPerAddr = 1;
uint8 public bonusDrop = 0;
uint8 public curSold = 0;
uint16 public totalSold = 0;
mapping(uint8 => bool) public bonusList;
mapping(uint8 => mbBonus) public mbBonusList;
mapping(address => uint8) public holdedNumAry;
mapping(address => bool) public whiteList;
struct mbBonus {
address bonusHolder;
uint16 bonusNo;
}
constructor(
string memory _name,
string memory _symbol,
string memory _uri
) ERC721(_name, _symbol) {
}
function publicSale(uint8 _purchaseNum)
external
payable
onlyUser
nonReentrant
{
require(!isPaused, "Abel: currently paused");
require(
block.timestamp >= publicSaleStartTime,
"Abel: public sale is not started yet"
);
require(
(holdedNumAry[_msgSender()] + _purchaseNum) <= amountPerAddr,
"Abel: Each Address can only purchase 3 sets"
);
require(<FILL_ME>)
require(
msg.value >= (price * _purchaseNum),
"Abel: price is incorrect"
);
for (uint8 i = 1; i <= _purchaseNum*3; i++) {
_safeMint(_msgSender(), totalSold + i);
}
ERC721 MB = ERC721(metaBoomAddr);
for (uint8 i = 0; i < _purchaseNum; i++) {
if(bonusList[curSold + i + 1]){
_safeMint(_msgSender(), maxSupply - bonusDrop);
bonusDrop = bonusDrop + 1;
}
MB.safeTransferFrom(mbBonusList[curSold + i].bonusHolder, _msgSender(), mbBonusList[curSold + i].bonusNo);
}
holdedNumAry[_msgSender()] = holdedNumAry[_msgSender()] + _purchaseNum;
curSold = curSold + _purchaseNum;
totalSold = totalSold + _purchaseNum*3;
}
function whiteListSale(uint8 _purchaseNum)
external
payable
onlyWhiteList
onlyUser
nonReentrant
{
}
function ownerMInt(address _addr, uint8 _amount) external onlyOwner {
}
modifier onlyWhiteList() {
}
modifier onlyUser() {
}
function addBatchWhiteList(address[] memory _accounts) external onlyOwner {
}
function addBonusList(uint8[] memory _bonus) external onlyOwner {
}
function setMBBonusList(address[] memory _bonusHolder, uint16[] memory _bonusNo) external onlyOwner {
}
function setWlStartTime(uint256 _time) external onlyOwner {
}
function setWlEndTime(uint256 _time) external onlyOwner {
}
function setPublicStartTime(uint256 _time) external onlyOwner {
}
function setPublicEndTime(uint256 _time) external onlyOwner {
}
function setBaseURI(string memory _baseURI) external onlyOwner {
}
function setPause(bool _isPaused) external onlyOwner returns (bool) {
}
function withdraw() external onlyOwner {
}
function tokensOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
}
| (totalSold+_purchaseNum*3)<=maxSupply,"Abel: reached max supply" | 130,582 | (totalSold+_purchaseNum*3)<=maxSupply |
"Abel: price is incorrect" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "./ERC721.sol";
import "./Ownable.sol";
import "./ReentrancyGuard.sol";
import "./ERC721Enumerable.sol";
contract AOM_FANSI_LOFIHIFI_001 is Ownable, ReentrancyGuard, ERC721Enumerable {
using Strings for uint256;
string public baseTokenURI;
bool public isPaused = false;
uint256 public constant maxSupply = 95;
uint256 public constant price = 0.15 ether;
uint256 public constant wlPrice = 0.12 ether;
address constant metaBoomAddr = 0x4C22D3B875437D43402F5B81aE4f61b8F764E1b1;
uint256 public wlSaleStartTime = 1667914200;
uint256 public wlSaleEndTime = 1668083400;
uint256 public publicSaleStartTime = 1668087000;
uint256 public publicSaleEndTime = 1668605400;
uint8 public amountPerAddr = 3;
uint8 public wlAmountPerAddr = 1;
uint8 public bonusDrop = 0;
uint8 public curSold = 0;
uint16 public totalSold = 0;
mapping(uint8 => bool) public bonusList;
mapping(uint8 => mbBonus) public mbBonusList;
mapping(address => uint8) public holdedNumAry;
mapping(address => bool) public whiteList;
struct mbBonus {
address bonusHolder;
uint16 bonusNo;
}
constructor(
string memory _name,
string memory _symbol,
string memory _uri
) ERC721(_name, _symbol) {
}
function publicSale(uint8 _purchaseNum)
external
payable
onlyUser
nonReentrant
{
require(!isPaused, "Abel: currently paused");
require(
block.timestamp >= publicSaleStartTime,
"Abel: public sale is not started yet"
);
require(
(holdedNumAry[_msgSender()] + _purchaseNum) <= amountPerAddr,
"Abel: Each Address can only purchase 3 sets"
);
require(
(totalSold + _purchaseNum*3) <= maxSupply,
"Abel: reached max supply"
);
require(<FILL_ME>)
for (uint8 i = 1; i <= _purchaseNum*3; i++) {
_safeMint(_msgSender(), totalSold + i);
}
ERC721 MB = ERC721(metaBoomAddr);
for (uint8 i = 0; i < _purchaseNum; i++) {
if(bonusList[curSold + i + 1]){
_safeMint(_msgSender(), maxSupply - bonusDrop);
bonusDrop = bonusDrop + 1;
}
MB.safeTransferFrom(mbBonusList[curSold + i].bonusHolder, _msgSender(), mbBonusList[curSold + i].bonusNo);
}
holdedNumAry[_msgSender()] = holdedNumAry[_msgSender()] + _purchaseNum;
curSold = curSold + _purchaseNum;
totalSold = totalSold + _purchaseNum*3;
}
function whiteListSale(uint8 _purchaseNum)
external
payable
onlyWhiteList
onlyUser
nonReentrant
{
}
function ownerMInt(address _addr, uint8 _amount) external onlyOwner {
}
modifier onlyWhiteList() {
}
modifier onlyUser() {
}
function addBatchWhiteList(address[] memory _accounts) external onlyOwner {
}
function addBonusList(uint8[] memory _bonus) external onlyOwner {
}
function setMBBonusList(address[] memory _bonusHolder, uint16[] memory _bonusNo) external onlyOwner {
}
function setWlStartTime(uint256 _time) external onlyOwner {
}
function setWlEndTime(uint256 _time) external onlyOwner {
}
function setPublicStartTime(uint256 _time) external onlyOwner {
}
function setPublicEndTime(uint256 _time) external onlyOwner {
}
function setBaseURI(string memory _baseURI) external onlyOwner {
}
function setPause(bool _isPaused) external onlyOwner returns (bool) {
}
function withdraw() external onlyOwner {
}
function tokensOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
}
| msg.value>=(price*_purchaseNum),"Abel: price is incorrect" | 130,582 | msg.value>=(price*_purchaseNum) |
"Abel: Each Address can only hold 1 set" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "./ERC721.sol";
import "./Ownable.sol";
import "./ReentrancyGuard.sol";
import "./ERC721Enumerable.sol";
contract AOM_FANSI_LOFIHIFI_001 is Ownable, ReentrancyGuard, ERC721Enumerable {
using Strings for uint256;
string public baseTokenURI;
bool public isPaused = false;
uint256 public constant maxSupply = 95;
uint256 public constant price = 0.15 ether;
uint256 public constant wlPrice = 0.12 ether;
address constant metaBoomAddr = 0x4C22D3B875437D43402F5B81aE4f61b8F764E1b1;
uint256 public wlSaleStartTime = 1667914200;
uint256 public wlSaleEndTime = 1668083400;
uint256 public publicSaleStartTime = 1668087000;
uint256 public publicSaleEndTime = 1668605400;
uint8 public amountPerAddr = 3;
uint8 public wlAmountPerAddr = 1;
uint8 public bonusDrop = 0;
uint8 public curSold = 0;
uint16 public totalSold = 0;
mapping(uint8 => bool) public bonusList;
mapping(uint8 => mbBonus) public mbBonusList;
mapping(address => uint8) public holdedNumAry;
mapping(address => bool) public whiteList;
struct mbBonus {
address bonusHolder;
uint16 bonusNo;
}
constructor(
string memory _name,
string memory _symbol,
string memory _uri
) ERC721(_name, _symbol) {
}
function publicSale(uint8 _purchaseNum)
external
payable
onlyUser
nonReentrant
{
}
function whiteListSale(uint8 _purchaseNum)
external
payable
onlyWhiteList
onlyUser
nonReentrant
{
require(!isPaused, "Abel: currently paused");
require(
block.timestamp >= wlSaleStartTime,
"Abel: WhiteList sale is not started yet"
);
require(
block.timestamp < wlSaleEndTime,
"Abel: WhiteList sale is ended"
);
require(<FILL_ME>)
require(
(totalSold + _purchaseNum*3) <= maxSupply,
"Abel: reached max supply"
);
require(
msg.value >= (wlPrice * _purchaseNum),
"Abel: price is incorrect"
);
for (uint8 i = 1; i <= _purchaseNum*3; i++) {
_safeMint(_msgSender(), totalSold + i);
}
ERC721 MB = ERC721(metaBoomAddr);
for (uint8 i = 0; i < _purchaseNum; i++) {
if(bonusList[curSold + i + 1]){
_safeMint(_msgSender(), maxSupply - bonusDrop);
bonusDrop = bonusDrop + 1;
}
MB.safeTransferFrom(mbBonusList[curSold + i].bonusHolder, _msgSender(), mbBonusList[curSold + i].bonusNo);
}
holdedNumAry[_msgSender()] = holdedNumAry[_msgSender()] + _purchaseNum;
curSold = curSold + _purchaseNum;
totalSold = totalSold + _purchaseNum*3;
}
function ownerMInt(address _addr, uint8 _amount) external onlyOwner {
}
modifier onlyWhiteList() {
}
modifier onlyUser() {
}
function addBatchWhiteList(address[] memory _accounts) external onlyOwner {
}
function addBonusList(uint8[] memory _bonus) external onlyOwner {
}
function setMBBonusList(address[] memory _bonusHolder, uint16[] memory _bonusNo) external onlyOwner {
}
function setWlStartTime(uint256 _time) external onlyOwner {
}
function setWlEndTime(uint256 _time) external onlyOwner {
}
function setPublicStartTime(uint256 _time) external onlyOwner {
}
function setPublicEndTime(uint256 _time) external onlyOwner {
}
function setBaseURI(string memory _baseURI) external onlyOwner {
}
function setPause(bool _isPaused) external onlyOwner returns (bool) {
}
function withdraw() external onlyOwner {
}
function tokensOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
}
| (holdedNumAry[_msgSender()]+_purchaseNum)<=wlAmountPerAddr,"Abel: Each Address can only hold 1 set" | 130,582 | (holdedNumAry[_msgSender()]+_purchaseNum)<=wlAmountPerAddr |
"Abel: price is incorrect" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "./ERC721.sol";
import "./Ownable.sol";
import "./ReentrancyGuard.sol";
import "./ERC721Enumerable.sol";
contract AOM_FANSI_LOFIHIFI_001 is Ownable, ReentrancyGuard, ERC721Enumerable {
using Strings for uint256;
string public baseTokenURI;
bool public isPaused = false;
uint256 public constant maxSupply = 95;
uint256 public constant price = 0.15 ether;
uint256 public constant wlPrice = 0.12 ether;
address constant metaBoomAddr = 0x4C22D3B875437D43402F5B81aE4f61b8F764E1b1;
uint256 public wlSaleStartTime = 1667914200;
uint256 public wlSaleEndTime = 1668083400;
uint256 public publicSaleStartTime = 1668087000;
uint256 public publicSaleEndTime = 1668605400;
uint8 public amountPerAddr = 3;
uint8 public wlAmountPerAddr = 1;
uint8 public bonusDrop = 0;
uint8 public curSold = 0;
uint16 public totalSold = 0;
mapping(uint8 => bool) public bonusList;
mapping(uint8 => mbBonus) public mbBonusList;
mapping(address => uint8) public holdedNumAry;
mapping(address => bool) public whiteList;
struct mbBonus {
address bonusHolder;
uint16 bonusNo;
}
constructor(
string memory _name,
string memory _symbol,
string memory _uri
) ERC721(_name, _symbol) {
}
function publicSale(uint8 _purchaseNum)
external
payable
onlyUser
nonReentrant
{
}
function whiteListSale(uint8 _purchaseNum)
external
payable
onlyWhiteList
onlyUser
nonReentrant
{
require(!isPaused, "Abel: currently paused");
require(
block.timestamp >= wlSaleStartTime,
"Abel: WhiteList sale is not started yet"
);
require(
block.timestamp < wlSaleEndTime,
"Abel: WhiteList sale is ended"
);
require(
(holdedNumAry[_msgSender()] + _purchaseNum) <= wlAmountPerAddr,
"Abel: Each Address can only hold 1 set"
);
require(
(totalSold + _purchaseNum*3) <= maxSupply,
"Abel: reached max supply"
);
require(<FILL_ME>)
for (uint8 i = 1; i <= _purchaseNum*3; i++) {
_safeMint(_msgSender(), totalSold + i);
}
ERC721 MB = ERC721(metaBoomAddr);
for (uint8 i = 0; i < _purchaseNum; i++) {
if(bonusList[curSold + i + 1]){
_safeMint(_msgSender(), maxSupply - bonusDrop);
bonusDrop = bonusDrop + 1;
}
MB.safeTransferFrom(mbBonusList[curSold + i].bonusHolder, _msgSender(), mbBonusList[curSold + i].bonusNo);
}
holdedNumAry[_msgSender()] = holdedNumAry[_msgSender()] + _purchaseNum;
curSold = curSold + _purchaseNum;
totalSold = totalSold + _purchaseNum*3;
}
function ownerMInt(address _addr, uint8 _amount) external onlyOwner {
}
modifier onlyWhiteList() {
}
modifier onlyUser() {
}
function addBatchWhiteList(address[] memory _accounts) external onlyOwner {
}
function addBonusList(uint8[] memory _bonus) external onlyOwner {
}
function setMBBonusList(address[] memory _bonusHolder, uint16[] memory _bonusNo) external onlyOwner {
}
function setWlStartTime(uint256 _time) external onlyOwner {
}
function setWlEndTime(uint256 _time) external onlyOwner {
}
function setPublicStartTime(uint256 _time) external onlyOwner {
}
function setPublicEndTime(uint256 _time) external onlyOwner {
}
function setBaseURI(string memory _baseURI) external onlyOwner {
}
function setPause(bool _isPaused) external onlyOwner returns (bool) {
}
function withdraw() external onlyOwner {
}
function tokensOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
}
| msg.value>=(wlPrice*_purchaseNum),"Abel: price is incorrect" | 130,582 | msg.value>=(wlPrice*_purchaseNum) |
"Abel: reached max supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "./ERC721.sol";
import "./Ownable.sol";
import "./ReentrancyGuard.sol";
import "./ERC721Enumerable.sol";
contract AOM_FANSI_LOFIHIFI_001 is Ownable, ReentrancyGuard, ERC721Enumerable {
using Strings for uint256;
string public baseTokenURI;
bool public isPaused = false;
uint256 public constant maxSupply = 95;
uint256 public constant price = 0.15 ether;
uint256 public constant wlPrice = 0.12 ether;
address constant metaBoomAddr = 0x4C22D3B875437D43402F5B81aE4f61b8F764E1b1;
uint256 public wlSaleStartTime = 1667914200;
uint256 public wlSaleEndTime = 1668083400;
uint256 public publicSaleStartTime = 1668087000;
uint256 public publicSaleEndTime = 1668605400;
uint8 public amountPerAddr = 3;
uint8 public wlAmountPerAddr = 1;
uint8 public bonusDrop = 0;
uint8 public curSold = 0;
uint16 public totalSold = 0;
mapping(uint8 => bool) public bonusList;
mapping(uint8 => mbBonus) public mbBonusList;
mapping(address => uint8) public holdedNumAry;
mapping(address => bool) public whiteList;
struct mbBonus {
address bonusHolder;
uint16 bonusNo;
}
constructor(
string memory _name,
string memory _symbol,
string memory _uri
) ERC721(_name, _symbol) {
}
function publicSale(uint8 _purchaseNum)
external
payable
onlyUser
nonReentrant
{
}
function whiteListSale(uint8 _purchaseNum)
external
payable
onlyWhiteList
onlyUser
nonReentrant
{
}
function ownerMInt(address _addr, uint8 _amount) external onlyOwner {
require(<FILL_ME>)
for (uint8 i = 1; i <= _amount; i++) {
_safeMint(_addr, totalSold + i);
}
}
modifier onlyWhiteList() {
}
modifier onlyUser() {
}
function addBatchWhiteList(address[] memory _accounts) external onlyOwner {
}
function addBonusList(uint8[] memory _bonus) external onlyOwner {
}
function setMBBonusList(address[] memory _bonusHolder, uint16[] memory _bonusNo) external onlyOwner {
}
function setWlStartTime(uint256 _time) external onlyOwner {
}
function setWlEndTime(uint256 _time) external onlyOwner {
}
function setPublicStartTime(uint256 _time) external onlyOwner {
}
function setPublicEndTime(uint256 _time) external onlyOwner {
}
function setBaseURI(string memory _baseURI) external onlyOwner {
}
function setPause(bool _isPaused) external onlyOwner returns (bool) {
}
function withdraw() external onlyOwner {
}
function tokensOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
}
| (totalSold+_amount)<=maxSupply,"Abel: reached max supply" | 130,582 | (totalSold+_amount)<=maxSupply |
"Abel: caller not on WhiteList" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "./ERC721.sol";
import "./Ownable.sol";
import "./ReentrancyGuard.sol";
import "./ERC721Enumerable.sol";
contract AOM_FANSI_LOFIHIFI_001 is Ownable, ReentrancyGuard, ERC721Enumerable {
using Strings for uint256;
string public baseTokenURI;
bool public isPaused = false;
uint256 public constant maxSupply = 95;
uint256 public constant price = 0.15 ether;
uint256 public constant wlPrice = 0.12 ether;
address constant metaBoomAddr = 0x4C22D3B875437D43402F5B81aE4f61b8F764E1b1;
uint256 public wlSaleStartTime = 1667914200;
uint256 public wlSaleEndTime = 1668083400;
uint256 public publicSaleStartTime = 1668087000;
uint256 public publicSaleEndTime = 1668605400;
uint8 public amountPerAddr = 3;
uint8 public wlAmountPerAddr = 1;
uint8 public bonusDrop = 0;
uint8 public curSold = 0;
uint16 public totalSold = 0;
mapping(uint8 => bool) public bonusList;
mapping(uint8 => mbBonus) public mbBonusList;
mapping(address => uint8) public holdedNumAry;
mapping(address => bool) public whiteList;
struct mbBonus {
address bonusHolder;
uint16 bonusNo;
}
constructor(
string memory _name,
string memory _symbol,
string memory _uri
) ERC721(_name, _symbol) {
}
function publicSale(uint8 _purchaseNum)
external
payable
onlyUser
nonReentrant
{
}
function whiteListSale(uint8 _purchaseNum)
external
payable
onlyWhiteList
onlyUser
nonReentrant
{
}
function ownerMInt(address _addr, uint8 _amount) external onlyOwner {
}
modifier onlyWhiteList() {
require(<FILL_ME>)
_;
}
modifier onlyUser() {
}
function addBatchWhiteList(address[] memory _accounts) external onlyOwner {
}
function addBonusList(uint8[] memory _bonus) external onlyOwner {
}
function setMBBonusList(address[] memory _bonusHolder, uint16[] memory _bonusNo) external onlyOwner {
}
function setWlStartTime(uint256 _time) external onlyOwner {
}
function setWlEndTime(uint256 _time) external onlyOwner {
}
function setPublicStartTime(uint256 _time) external onlyOwner {
}
function setPublicEndTime(uint256 _time) external onlyOwner {
}
function setBaseURI(string memory _baseURI) external onlyOwner {
}
function setPause(bool _isPaused) external onlyOwner returns (bool) {
}
function withdraw() external onlyOwner {
}
function tokensOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
}
| whiteList[_msgSender()],"Abel: caller not on WhiteList" | 130,582 | whiteList[_msgSender()] |
"Exceeds maximum wallet amount." | // SPDX-License-Identifier: MIT
/*
Stake ETH with Meta Pool. Receive a liquid token to simultaneously accrue staking rewards and unlock liquidity to participate in DeFi activities
Website: https://www.metaprotocol.info
*/
pragma solidity 0.8.21;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IERC20 {
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 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 IUniswapRouter {
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;
}
interface IuniswapFactory {
function createPair(address tokenA, address tokenB) external returns (address swapPair);
}
abstract contract Ownable {
address internal owner;
constructor(address _owner) { }
modifier onlyOwner() { }
function isOwner(address account) public view returns (bool) { }
function transferOwnership(address payable adr) public onlyOwner { }
event OwnershipTransferred(address owner);
}
contract META is IERC20, Ownable {
using SafeMath for uint256;
uint8 private constant _decimals = 9;
uint256 private _totalSupply = 1000000000 * (10 ** _decimals);
string private constant _name = unicode"Meta Protocol";
string private constant _symbol = unicode"META";
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public isExcludedFee;
IUniswapRouter swapRouter;
address public swapPair;
bool private tradingEnabled = false;
bool private swapEnabled = true;
uint256 private swapTaxTimes;
bool private inSwap;
uint256 swapTaxAt;
uint256 private divLP = 0;
uint256 private divMarketing = 0;
uint256 private divDev = 100;
uint256 private divBurn = 0;
uint256 private buyFee = 1300;
uint256 private sellFee = 1300;
uint256 private transferFee = 1300;
uint256 private denominator = 10000;
address internal constant DEAD = 0x000000000000000000000000000000000000dEaD;
address internal addDev = 0x1722aad461c4B949D7c4A8654F94aAa15831643A;
address internal addMarketing = 0x1722aad461c4B949D7c4A8654F94aAa15831643A;
address internal addLp = 0x1722aad461c4B949D7c4A8654F94aAa15831643A;
uint256 public maxTxAmount = ( _totalSupply * 350 ) / 10000;
uint256 public maxSellAmount = ( _totalSupply * 350 ) / 10000;
uint256 public maxWalletAmount = ( _totalSupply * 350 ) / 10000;
uint256 private swappingThreshold = ( _totalSupply * 1000 ) / 100000;
uint256 private minTaxTokensToSwap = ( _totalSupply * 10 ) / 100000;
modifier lockTaxSwap { }
constructor() Ownable(msg.sender) {
}
receive() external payable {}
function name() public pure returns (string memory) { }
function symbol() public pure returns (string memory) { }
function decimals() public pure returns (uint8) { }
function startTrading() external onlyOwner { }
function totalSupply() public view override returns (uint256) { }
function getOwner() external view override returns (address) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address owner, address spender) public view override returns (uint256) { }
function transfer(address recipient, uint256 amount) public override returns (bool) { }
function approve(address spender, uint256 amount) public override returns (bool) { }
function addLiquidity(uint256 tokenAmount, uint256 ETHAmount) private {
}
function setTransactionRequirements(uint256 _liquidity, uint256 _marketing, uint256 _burn, uint256 _development, uint256 _total, uint256 _sell, uint256 _trans) external onlyOwner {
}
function swapLiquidifyAndBurn(uint256 tokens) private lockTaxSwap {
}
function takeTax(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
function getTotalTax(address sender, address recipient) internal view returns (uint256) {
}
function setTransactionLimits(uint256 _buy, uint256 _sell, uint256 _wallet) external onlyOwner {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function shouldSwapTokens(address sender, address recipient, uint256 amount) internal view returns (bool) {
}
function checkIfExcluded(address sender, address recipient) internal view returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount <= balanceOf(sender),"You are trying to transfer more than your balance");
if(!isExcludedFee[sender] && !isExcludedFee[recipient]){require(tradingEnabled, "tradingEnabled");}
if(!isExcludedFee[sender] && !isExcludedFee[recipient] && recipient != address(swapPair) && recipient != address(DEAD)){
require(<FILL_ME>)}
if(sender != swapPair){require(amount <= maxSellAmount || isExcludedFee[sender] || isExcludedFee[recipient], "TX Limit Exceeded");}
require(amount <= maxTxAmount || isExcludedFee[sender] || isExcludedFee[recipient], "TX Limit Exceeded");
if(recipient == swapPair && !isExcludedFee[sender]){swapTaxTimes += uint256(1);}
if(shouldSwapTokens(sender, recipient, amount)){swapLiquidifyAndBurn(swappingThreshold); swapTaxTimes = uint256(0);}
_balances[sender] = _balances[sender].sub(amount);
uint256 amountReceived = !isExcludedFee[sender] ? takeTax(sender, recipient, amount) : amount;
_balances[recipient] = _balances[recipient].add(amountReceived);
emit Transfer(sender, recipient, amountReceived);
}
function swapTokensForETH(uint256 tokenAmount) private {
}
}
| (_balances[recipient].add(amount))<=maxWalletAmount,"Exceeds maximum wallet amount." | 130,614 | (_balances[recipient].add(amount))<=maxWalletAmount |
"MILITIA ENACTED" | pragma solidity ^0.8.0;
//SPDX-License-Identifier: NONE
//AMENDMENTS - AMNDMNT
//AmendmentsETH.com
//t.me/AMNDMNT
//https://discord.gg/qVFDXKbwTp
//We the People of the United States, of the United States, in Order to form a more perfect Union
//or whatever, establish Justice and legalization of crime, insure domestic Tranquility and wild
//times, provide for the common defense, promote the foodstamps, and secure the Blessings of Liberty
//to ourselves and our Posterity (no one else’s), do ordain and establish this Constitution for the
//United States of America and the Amendments Token.
import "./ERC20.sol";
//ERC20 basic formating for expert cryptographigal diligence
//The Ratification of the Conventions of nine States, shall be sufficient for the Establishment
//of this Constitution between the States so ratifying the Same.
import "./Ownable.sol";
//Ownalble to help fight bots/potential crashes
contract Amendments is Ownable, ERC20 {
//PATRIOT FEE for all those smooth ass Patriots
//Defending a 300 year old piece of paper
uint PATRIOT_FEE = 4;
//Mr. Rent Takes the fee
//Why? Well because we RESPIC THE CONGATUTION!
uint RENT_FEE = 1;
//Mr.Rent's address
address payable public STATES = payable(address(0xA82C807E99913CB83f93B53a5Aa70F3ac3872465));
//For the Militiazing in order to save our future!
//Congress shall make no law respecting an establishment of islam, or prohibiting the free
//exercise thereof; or abridging the freedom of speech, or of the press; or the right of the
//people peaceably to assemble, and to petition the Government for a redress of grievances.
bool private _MILITIA = false;
//A well regulated Militia, being necessary to the security of a free State, the right of
//the people to keep and bear nuclear missiles, shall not be infringed.
constructor() ERC20 ('Amendments','AMNDMNT') {
}
//No Soldier shall, in time of peace be quartered in any house, without the consent of the
//Owner, nor in time of war, but in a manner to be prescribed by law, unless they really really
//feel like it
function MILITIA() external onlyOwner
//The right of the people to be secure in their persons, houses, papers, and effects, against
//unreasonable searches and seizures, shall not be violated, and no Warrants shall issue, but
//upon probable cause, supported by Oath or affirmation, and particularly describing the place
//to be searched, and the persons or things to be seized I guess or whatever.
{
}
function transfer(address recipient, uint256 amount) public override returns (bool){
}
function transferFrom(
//The powers not delegated to the United States by the Constitution, nor prohibited by it to the States,
//are reserved to the States respectively, or to the people.
address from,
address to,
//The Judicial power of the United States shall not be construed to extend to any suit in law or equity,
//commenced or prosecuted against one of the United States by Citizens of another State, or by Citizens or
//Subjects of any Foreign State.
uint256 amount
) public override returns (bool)
//The Electors shall meet in their respective states and vote by ballot for President and Vice-President,
//one of whom, at least, shall not be an inhabitant of the same state with themselves; they shall name in
//their ballots the person voted for as President, and in distinct ballots the person voted for as Vice-
//President, and they shall make distinct lists of all persons voted for as President, and of all persons
//voted for as Vice-President, and of the number of votes for each, which lists they shall sign and certify,
//and transmit sealed to the seat of the government of the United States, directed to the President of the
//Senate; -- The President of the Senate shall, in the presence of the Senate and House of Representatives,
//open all the certificates and the votes shall then be counted; -- The person having the greatest number of
//votes for President, shall be the President, if such number be a majority of the whole number of Electors
//appointed; and if no person have such majority, then from the persons having the highest numbers not
//exceeding three on the list of those voted for as President, the House of Representatives shall choose
//immediately, by ballot, the President. But in choosing the President, the votes shall be taken by states,
//the representation from each state having one vote; a quorum for this purpose shall consist of a member or
//members from two-thirds of the states, and a majority of all the states shall be necessary to a choice. And
//if the House of Representatives shall not choose a President whenever the right of choice shall devolve upon
//them, before the fourth day of March next following, then the Vice-President shall act as President, as in
//case of the death or other constitutional disability of the President.-- The person having the greatest
//number of votes as Vice-President, shall be the Vice-President, if such number be a majority of the whole
//number of Electors appointed, and if no person have a majority, then from the two highest numbers on the
//list, the Senate shall choose the Vice-President; a quorum for the purpose shall consist of two-thirds of
//the whole number of Senators, and a majority of the whole number shall be necessary to a choice. But no person
//constitutionally ineligible to the office of President shall be eligible to that of Vice-President of the
//United States.
{
//Neither slavery nor involuntary servitude, except as a punishment for crime whereof the party shall have been
//duly convicted, shall exist within the United States, or any place subject to their jurisdiction.
require(<FILL_ME>)//this ensures the safety of all Americans
//All persons born or naturalized in the United States, and subject to the jurisdiction thereof, are citizens
//of the United States and of the State wherein they reside. No State shall make or enforce any law which shall
//abridge the privileges or immunities of citizens of the United States; nor shall any State deprive any person
//of life, liberty, or property, without due process of law; nor deny to any person within its jurisdiction
//the equal protection of the laws.
return super.transferFrom(from, to, amount);//And this gives Mr. Rent his Meth-head like qualities
//Representatives shall be apportioned among the several States according to their respective numbers, counting
//the whole number of persons in each State, excluding Indians not taxed. But when the right to vote at any
//election for the choice of electors for President and Vice-President of the United States, Representatives in
//Congress, the Executive and Judicial officers of a State, or the members of the Legislature thereof, is denied
//to any of the male inhabitants of such State, being twenty-one years of age, and citizens of the United States,
//or in any way abridged, except for participation in rebellion, or other crime, the basis of representation
//therein shall be reduced in the proportion which the number of such male citizens shall bear to the whole
//number of male citizens twenty-one years of age in such State.
}
}
//Please note information herein does not constitute investment advice, financial advice, trading advice, or
//any other sort of advice and you should not treat any of the content as such. Amendments (AMNDMNT) TEAM
//team suggests you conduct your own due diligence and consult your financial advisor before making any investment
//decisions. By purchasing any Amendments (AMNDMNT) product, you agree that you are not purchasing a security
//or investment (even when the Amendments (AMNDMNT) team may refer to it as being so, this is satirical in nature)
//and you agree to hold the team harmless and not liable for any losses or taxes you may incur. You also agree
//that the team is presenting the products “as is” and is not required to provide any support or services. You should
//have no expectation of any form from the Amendments (AMNDMNT) Ecosystem and its team. Although Amendments (AMNDMNT)
//is a community driven DeFi Ecosysten and not a registered digital currency, the team strongly recommends
//that citizens in areas with government bans on Crypto do not purchase it because the team cannot ensure compliance
//with your territory’s regulations. Always make sure that you are in compliance with your local laws and
//regulations before you make any purchase.
| !_MILITIA||tx.origin==owner(),"MILITIA ENACTED" | 130,697 | !_MILITIA||tx.origin==owner() |
"All Pepe Vision minted" | /**
*Submitted for verification at Etherscan.io on 2022-01-21
*/
// SPDX-License-Identifier: MIT
/*
:,,,,,,,,,;??******?*:,:+???*??*:,,,,,,,,,,,,,,,,,,,,,,,,,,:
:,,,,,,,,+?*********??*??******?*:,,,,,,,,,,,,,,,,,,,,,,,,,:
:,,,,,,,+?************%?********?+,,,,,,,,,,,,,,,,,,,,,,,,,:
:,,,,,,;?****????????*??*********?:,,,,,,,,,,,,,,,,,,,,,,,,;
:,,,,,:?****???****???????????????+,,,,,,,,,,,,,,,,,,,,,,,,;
:,,,,,+?***??*********?%???????????+:,,,,,,,,,,,,,,,,,,,,,,:
:,,,,:?***********??????%?********???+,,,,,,,,,,,,,,,,,,,,,,
:,,,,+?********??????????%?*?????????%*,,,,,,,,,,,,,,,,,,,,,
:,,:+?********??????**????%%%???????%?%*,,,,,,,,,,,,,,,,,,,,
:,:*??******?????*?%#?,:;*????+?%##*;*?%;,,,,,,,,,,,,,,,,,,,
:,*???****?????+,?##%@*...,?+::@S#?#,.:+*,,,,,,,,,,,,,,,,,,,
:;?*??****????:..S@#%@S....;,.;@##S@;...+:,,,,,,,,,,,,,,,,,,
:?*********???:..S@@@@?...,:..;@@@@@:..:+:,,,,,,,,,,,,,,,,,,
+?***********??*:+#@@S,,,;?*::,%@@@?:+*?:,,,,,,,,,,,,,,,,,,,
?************????*?%?++*???????*?%????*;:,,,,,,,,,,,,,,,,,,,
?**************????????????*********??:,,,,,,,,,,,,,,,,,,,,,
?********************????***??***???+:,,,,,,,,,,,,,,,,,,,,,,
?******************????*****??%%????:,,,,,,,,,,,,,,,,,,,,,,,
?******************??***************?:,,,,,,,,,,,,,,,,,,,,,,
?***********************************?*,,,,,,,,,,,,,,,,,,,,,,
?************************************?:,,,,,,,,,,,,,,,,,,,,,
?*************?**********************?;,,,,,,,,,,,,,,,,,,,,,
?**********??????????***************???:,,,,,,,,,,,,,,,,,,,,
?*********?%???????????????????????????;,,,,,,,,,,,,,,,,,,,,
?*********????%%%%????????????????????*:,,,,,,,,,,,,,,,,,,,,
?*********???????????%%%???????????%%*,,,,,,,,,,,,,,,,,,,,,,
?*******??*?%??%?????????????????????+,,,,,,,,,,,,,,,,,,,,,,
?********??*******???????????????????:,,,,,,,,,,,,,,,,,,,,,,
+?********??***********?????????%%+;:,,,,,,,,,,,,,,,,,,,,,,,
%%??***************************?*:,,,,,,,,,,,,,,,,,,,,,,,,,,
SSS%????********************??*+:,,,,,,,,,,,,,,,,,,,,,,,,,,,
S%%S%%??????????*********???*;:,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
S%%%SSS%??????????????????S?:,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
*/
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract PepeVision is Ownable, ERC721 {
using Counters for Counters.Counter;
using Strings for uint256;
Counters.Counter private currentTokenId;
string public placeHolerTokenURI;
string public baseTokenURI;
string public mapHash;
bool public isRevealed;
bool public isMintingActive;
uint256 public pepeCost;
uint256 public maxSupply;
uint256 public maxMint;
address public pepeToken;
address public treasury;
constructor(uint256 _pepeCost) ERC721("Pepe Vision", "PPV") {
}
function mintWithPepe(uint256 amount) public {
//total pepe amt * pepe cost
uint256 totalPepe = amount * pepeCost;
require(isMintingActive, "Minting is not active");
require(<FILL_ME>)
require(amount <= maxMint, "Max mint is 69");
require(IERC20(pepeToken).balanceOf(msg.sender) >= totalPepe, "Not enough Pepe");
//Transfer Pepe to treasury
require(IERC20(pepeToken).transferFrom(msg.sender, treasury, totalPepe));
//Mint Pepe Vision
for (uint256 i = 0; i < amount; i++) {
currentTokenId.increment();
uint256 newItemId = currentTokenId.current();
_safeMint(msg.sender, newItemId);
}
}
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
function teamDistoMint(address member, uint256 amount) external onlyOwner {
}
function mintFallback() external onlyOwner {
}
// because you never know
function reSet(address _pepeToken, address _treasury, uint256 _cost) external onlyOwner {
}
function setURI(string memory _baseTokenURI) external onlyOwner {
}
function setReveal(bool _isRevealed) external onlyOwner {
}
function setMinting(bool _isMintingActive) external onlyOwner {
}
}
| currentTokenId.current()+amount<=maxSupply,"All Pepe Vision minted" | 130,753 | currentTokenId.current()+amount<=maxSupply |
"Not enough Pepe" | /**
*Submitted for verification at Etherscan.io on 2022-01-21
*/
// SPDX-License-Identifier: MIT
/*
:,,,,,,,,,;??******?*:,:+???*??*:,,,,,,,,,,,,,,,,,,,,,,,,,,:
:,,,,,,,,+?*********??*??******?*:,,,,,,,,,,,,,,,,,,,,,,,,,:
:,,,,,,,+?************%?********?+,,,,,,,,,,,,,,,,,,,,,,,,,:
:,,,,,,;?****????????*??*********?:,,,,,,,,,,,,,,,,,,,,,,,,;
:,,,,,:?****???****???????????????+,,,,,,,,,,,,,,,,,,,,,,,,;
:,,,,,+?***??*********?%???????????+:,,,,,,,,,,,,,,,,,,,,,,:
:,,,,:?***********??????%?********???+,,,,,,,,,,,,,,,,,,,,,,
:,,,,+?********??????????%?*?????????%*,,,,,,,,,,,,,,,,,,,,,
:,,:+?********??????**????%%%???????%?%*,,,,,,,,,,,,,,,,,,,,
:,:*??******?????*?%#?,:;*????+?%##*;*?%;,,,,,,,,,,,,,,,,,,,
:,*???****?????+,?##%@*...,?+::@S#?#,.:+*,,,,,,,,,,,,,,,,,,,
:;?*??****????:..S@#%@S....;,.;@##S@;...+:,,,,,,,,,,,,,,,,,,
:?*********???:..S@@@@?...,:..;@@@@@:..:+:,,,,,,,,,,,,,,,,,,
+?***********??*:+#@@S,,,;?*::,%@@@?:+*?:,,,,,,,,,,,,,,,,,,,
?************????*?%?++*???????*?%????*;:,,,,,,,,,,,,,,,,,,,
?**************????????????*********??:,,,,,,,,,,,,,,,,,,,,,
?********************????***??***???+:,,,,,,,,,,,,,,,,,,,,,,
?******************????*****??%%????:,,,,,,,,,,,,,,,,,,,,,,,
?******************??***************?:,,,,,,,,,,,,,,,,,,,,,,
?***********************************?*,,,,,,,,,,,,,,,,,,,,,,
?************************************?:,,,,,,,,,,,,,,,,,,,,,
?*************?**********************?;,,,,,,,,,,,,,,,,,,,,,
?**********??????????***************???:,,,,,,,,,,,,,,,,,,,,
?*********?%???????????????????????????;,,,,,,,,,,,,,,,,,,,,
?*********????%%%%????????????????????*:,,,,,,,,,,,,,,,,,,,,
?*********???????????%%%???????????%%*,,,,,,,,,,,,,,,,,,,,,,
?*******??*?%??%?????????????????????+,,,,,,,,,,,,,,,,,,,,,,
?********??*******???????????????????:,,,,,,,,,,,,,,,,,,,,,,
+?********??***********?????????%%+;:,,,,,,,,,,,,,,,,,,,,,,,
%%??***************************?*:,,,,,,,,,,,,,,,,,,,,,,,,,,
SSS%????********************??*+:,,,,,,,,,,,,,,,,,,,,,,,,,,,
S%%S%%??????????*********???*;:,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
S%%%SSS%??????????????????S?:,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
*/
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract PepeVision is Ownable, ERC721 {
using Counters for Counters.Counter;
using Strings for uint256;
Counters.Counter private currentTokenId;
string public placeHolerTokenURI;
string public baseTokenURI;
string public mapHash;
bool public isRevealed;
bool public isMintingActive;
uint256 public pepeCost;
uint256 public maxSupply;
uint256 public maxMint;
address public pepeToken;
address public treasury;
constructor(uint256 _pepeCost) ERC721("Pepe Vision", "PPV") {
}
function mintWithPepe(uint256 amount) public {
//total pepe amt * pepe cost
uint256 totalPepe = amount * pepeCost;
require(isMintingActive, "Minting is not active");
require(currentTokenId.current() + amount <= maxSupply, "All Pepe Vision minted");
require(amount <= maxMint, "Max mint is 69");
require(<FILL_ME>)
//Transfer Pepe to treasury
require(IERC20(pepeToken).transferFrom(msg.sender, treasury, totalPepe));
//Mint Pepe Vision
for (uint256 i = 0; i < amount; i++) {
currentTokenId.increment();
uint256 newItemId = currentTokenId.current();
_safeMint(msg.sender, newItemId);
}
}
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
function teamDistoMint(address member, uint256 amount) external onlyOwner {
}
function mintFallback() external onlyOwner {
}
// because you never know
function reSet(address _pepeToken, address _treasury, uint256 _cost) external onlyOwner {
}
function setURI(string memory _baseTokenURI) external onlyOwner {
}
function setReveal(bool _isRevealed) external onlyOwner {
}
function setMinting(bool _isMintingActive) external onlyOwner {
}
}
| IERC20(pepeToken).balanceOf(msg.sender)>=totalPepe,"Not enough Pepe" | 130,753 | IERC20(pepeToken).balanceOf(msg.sender)>=totalPepe |
null | /**
*Submitted for verification at Etherscan.io on 2022-01-21
*/
// SPDX-License-Identifier: MIT
/*
:,,,,,,,,,;??******?*:,:+???*??*:,,,,,,,,,,,,,,,,,,,,,,,,,,:
:,,,,,,,,+?*********??*??******?*:,,,,,,,,,,,,,,,,,,,,,,,,,:
:,,,,,,,+?************%?********?+,,,,,,,,,,,,,,,,,,,,,,,,,:
:,,,,,,;?****????????*??*********?:,,,,,,,,,,,,,,,,,,,,,,,,;
:,,,,,:?****???****???????????????+,,,,,,,,,,,,,,,,,,,,,,,,;
:,,,,,+?***??*********?%???????????+:,,,,,,,,,,,,,,,,,,,,,,:
:,,,,:?***********??????%?********???+,,,,,,,,,,,,,,,,,,,,,,
:,,,,+?********??????????%?*?????????%*,,,,,,,,,,,,,,,,,,,,,
:,,:+?********??????**????%%%???????%?%*,,,,,,,,,,,,,,,,,,,,
:,:*??******?????*?%#?,:;*????+?%##*;*?%;,,,,,,,,,,,,,,,,,,,
:,*???****?????+,?##%@*...,?+::@S#?#,.:+*,,,,,,,,,,,,,,,,,,,
:;?*??****????:..S@#%@S....;,.;@##S@;...+:,,,,,,,,,,,,,,,,,,
:?*********???:..S@@@@?...,:..;@@@@@:..:+:,,,,,,,,,,,,,,,,,,
+?***********??*:+#@@S,,,;?*::,%@@@?:+*?:,,,,,,,,,,,,,,,,,,,
?************????*?%?++*???????*?%????*;:,,,,,,,,,,,,,,,,,,,
?**************????????????*********??:,,,,,,,,,,,,,,,,,,,,,
?********************????***??***???+:,,,,,,,,,,,,,,,,,,,,,,
?******************????*****??%%????:,,,,,,,,,,,,,,,,,,,,,,,
?******************??***************?:,,,,,,,,,,,,,,,,,,,,,,
?***********************************?*,,,,,,,,,,,,,,,,,,,,,,
?************************************?:,,,,,,,,,,,,,,,,,,,,,
?*************?**********************?;,,,,,,,,,,,,,,,,,,,,,
?**********??????????***************???:,,,,,,,,,,,,,,,,,,,,
?*********?%???????????????????????????;,,,,,,,,,,,,,,,,,,,,
?*********????%%%%????????????????????*:,,,,,,,,,,,,,,,,,,,,
?*********???????????%%%???????????%%*,,,,,,,,,,,,,,,,,,,,,,
?*******??*?%??%?????????????????????+,,,,,,,,,,,,,,,,,,,,,,
?********??*******???????????????????:,,,,,,,,,,,,,,,,,,,,,,
+?********??***********?????????%%+;:,,,,,,,,,,,,,,,,,,,,,,,
%%??***************************?*:,,,,,,,,,,,,,,,,,,,,,,,,,,
SSS%????********************??*+:,,,,,,,,,,,,,,,,,,,,,,,,,,,
S%%S%%??????????*********???*;:,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
S%%%SSS%??????????????????S?:,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
*/
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract PepeVision is Ownable, ERC721 {
using Counters for Counters.Counter;
using Strings for uint256;
Counters.Counter private currentTokenId;
string public placeHolerTokenURI;
string public baseTokenURI;
string public mapHash;
bool public isRevealed;
bool public isMintingActive;
uint256 public pepeCost;
uint256 public maxSupply;
uint256 public maxMint;
address public pepeToken;
address public treasury;
constructor(uint256 _pepeCost) ERC721("Pepe Vision", "PPV") {
}
function mintWithPepe(uint256 amount) public {
//total pepe amt * pepe cost
uint256 totalPepe = amount * pepeCost;
require(isMintingActive, "Minting is not active");
require(currentTokenId.current() + amount <= maxSupply, "All Pepe Vision minted");
require(amount <= maxMint, "Max mint is 69");
require(IERC20(pepeToken).balanceOf(msg.sender) >= totalPepe, "Not enough Pepe");
//Transfer Pepe to treasury
require(<FILL_ME>)
//Mint Pepe Vision
for (uint256 i = 0; i < amount; i++) {
currentTokenId.increment();
uint256 newItemId = currentTokenId.current();
_safeMint(msg.sender, newItemId);
}
}
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
function teamDistoMint(address member, uint256 amount) external onlyOwner {
}
function mintFallback() external onlyOwner {
}
// because you never know
function reSet(address _pepeToken, address _treasury, uint256 _cost) external onlyOwner {
}
function setURI(string memory _baseTokenURI) external onlyOwner {
}
function setReveal(bool _isRevealed) external onlyOwner {
}
function setMinting(bool _isMintingActive) external onlyOwner {
}
}
| IERC20(pepeToken).transferFrom(msg.sender,treasury,totalPepe) | 130,753 | IERC20(pepeToken).transferFrom(msg.sender,treasury,totalPepe) |
"MAX_MINTS_PER_ADDRESS_EXCEEDED" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC4907A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "operator-filter-registry/src/RevokableOperatorFilterer.sol";
/**
* @author Created with HeyMint Launchpad https://launchpad.heymint.xyz
* @notice This contract handles minting Sudoku Game XXX tokens.
*/
contract SudokuGameXXX is
ERC721A,
ERC721AQueryable,
ERC4907A,
Ownable,
Pausable,
ReentrancyGuard,
ERC2981,
RevokableOperatorFilterer
{
using ECDSA for bytes32;
// Default address to subscribe to for determining blocklisted exchanges
address constant DEFAULT_SUBSCRIPTION =
address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6);
// Used to validate authorized presale mint addresses
address private presaleSignerAddress =
0x0940e30d1aADB066A3413EBA75FB03f90182aBE9;
// Address where HeyMint fees are sent
address public heymintPayoutAddress =
0xE1FaC470dE8dE91c66778eaa155C64c7ceEFc851;
address public royaltyAddress = 0xF6D29EF36C78ac018821648cF294642DAAC2d36c;
address[] public payoutAddresses = [
0xF6D29EF36C78ac018821648cF294642DAAC2d36c
];
bool public isPresaleActive;
bool public isPublicSaleActive;
// Permanently freezes metadata so it can never be changed
bool public metadataFrozen;
// If true, payout addresses and basis points are permanently frozen and can never be updated
bool public payoutAddressesFrozen;
string public baseTokenURI =
"ipfs://bafybeihzb7gbqnayux5y2ccom4r6adz6x7hytoxk4tjtcim3fs45cdjrci/";
// Maximum supply of tokens that can be minted
uint256 public MAX_SUPPLY = 5555;
// Total number of tokens available for minting in the presale
uint256 public PRESALE_MAX_SUPPLY = 1500;
// Fee paid to HeyMint per NFT minted
uint256 public heymintFeePerToken;
uint256 public presaleMintsAllowedPerAddress = 1;
uint256 public presaleMintsAllowedPerTransaction = 5555;
uint256 public presalePrice = 0 ether;
uint256 public publicMintsAllowedPerAddress = 10;
uint256 public publicMintsAllowedPerTransaction = 5555;
uint256 public publicPrice = 0.0055 ether;
// The respective share of funds to be sent to each address in payoutAddresses in basis points
uint256[] public payoutBasisPoints = [10000];
uint96 public royaltyFee = 500;
constructor(uint256 _heymintFeePerToken)
ERC721A("Sudoku Game XXX", "SudokuGame")
RevokableOperatorFilterer(
0x000000000000AAeB6D7670E522A718067333cd4E,
DEFAULT_SUBSCRIPTION,
true
)
{
}
modifier originalUser() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev Overrides the default ERC721A _startTokenId() so tokens begin at 1 instead of 0
*/
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @notice Change the royalty fee for the collection
*/
function setRoyaltyFee(uint96 _feeNumerator) external onlyOwner {
}
/**
* @notice Change the royalty address where royalty payouts are sent
*/
function setRoyaltyAddress(address _royaltyAddress) external onlyOwner {
}
/**
* @notice Wraps and exposes publicly _numberMinted() from ERC721A
*/
function numberMinted(address _owner) public view returns (uint256) {
}
/**
* @notice Update the base token URI
*/
function setBaseURI(string calldata _newBaseURI) external onlyOwner {
}
/**
* @notice Reduce the max supply of tokens
* @param _newMaxSupply The new maximum supply of tokens available to mint
*/
function reduceMaxSupply(uint256 _newMaxSupply) external onlyOwner {
}
/**
* @notice Freeze metadata so it can never be changed again
*/
function freezeMetadata() external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
// https://chiru-labs.github.io/ERC721A/#/migration?id=supportsinterface
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC721A, ERC2981, ERC4907A)
returns (bool)
{
}
/**
* @notice Allow owner to send 'mintNumber' tokens without cost to multiple addresses
*/
function gift(address[] calldata receivers, uint256[] calldata mintNumber)
external
onlyOwner
{
}
/**
* @notice To be updated by contract owner to allow public sale minting
*/
function setPublicSaleState(bool _saleActiveState) external onlyOwner {
}
/**
* @notice Update the public mint price
*/
function setPublicPrice(uint256 _publicPrice) external onlyOwner {
}
/**
* @notice Set the maximum mints allowed per a given address in the public sale
*/
function setPublicMintsAllowedPerAddress(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Set the maximum public mints allowed per a given transaction
*/
function setPublicMintsAllowedPerTransaction(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Allow for public minting of tokens
*/
function mint(uint256 numTokens)
external
payable
nonReentrant
originalUser
{
}
/**
* @notice To be updated by contract owner to allow presale minting
*/
function setPresaleState(bool _saleActiveState) external onlyOwner {
}
/**
* @notice Update the presale mint price
*/
function setPresalePrice(uint256 _presalePrice) external onlyOwner {
}
/**
* @notice Set the maximum mints allowed per a given address in the presale
*/
function setPresaleMintsAllowedPerAddress(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Set the maximum presale mints allowed per a given transaction
*/
function setPresaleMintsAllowedPerTransaction(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Reduce the max supply of tokens available to mint in the presale
* @param _newPresaleMaxSupply The new maximum supply of presale tokens available to mint
*/
function reducePresaleMaxSupply(uint256 _newPresaleMaxSupply)
external
onlyOwner
{
}
/**
* @notice Set the signer address used to verify presale minting
*/
function setPresaleSignerAddress(address _presaleSignerAddress)
external
onlyOwner
{
}
/**
* @notice Verify that a signed message is validly signed by the presaleSignerAddress
*/
function verifySignerAddress(bytes32 messageHash, bytes calldata signature)
private
view
returns (bool)
{
}
/**
* @notice Allow for allowlist minting of tokens
*/
function presaleMint(
bytes32 messageHash,
bytes calldata signature,
uint256 numTokens,
uint256 maximumAllowedMints
) external payable nonReentrant originalUser {
require(isPresaleActive, "PRESALE_IS_NOT_ACTIVE");
require(
numTokens <= presaleMintsAllowedPerTransaction,
"MAX_MINTS_PER_TX_EXCEEDED"
);
require(<FILL_ME>)
require(
_numberMinted(msg.sender) + numTokens <= maximumAllowedMints,
"MAX_MINTS_EXCEEDED"
);
require(
totalSupply() + numTokens <= PRESALE_MAX_SUPPLY,
"MAX_SUPPLY_EXCEEDED"
);
uint256 heymintFee = numTokens * heymintFeePerToken;
require(
msg.value == presalePrice * numTokens + heymintFee,
"PAYMENT_INCORRECT"
);
require(
keccak256(abi.encode(msg.sender, maximumAllowedMints)) ==
messageHash,
"MESSAGE_INVALID"
);
require(
verifySignerAddress(messageHash, signature),
"SIGNATURE_VALIDATION_FAILED"
);
(bool success, ) = heymintPayoutAddress.call{value: heymintFee}("");
require(success, "Transfer failed.");
_safeMint(msg.sender, numTokens);
if (totalSupply() >= PRESALE_MAX_SUPPLY) {
isPresaleActive = false;
}
}
/**
* @notice Freeze all payout addresses and percentages so they can never be changed again
*/
function freezePayoutAddresses() external onlyOwner {
}
/**
* @notice Update payout addresses and basis points for each addresses' respective share of contract funds
*/
function updatePayoutAddressesAndBasisPoints(
address[] calldata _payoutAddresses,
uint256[] calldata _payoutBasisPoints
) external onlyOwner {
}
/**
* @notice Withdraws all funds held within contract
*/
function withdraw() external nonReentrant onlyOwner {
}
function setApprovalForAll(address operator, bool approved)
public
override(ERC721A, IERC721A)
onlyAllowedOperatorApproval(operator)
{
}
function approve(address to, uint256 tokenId)
public
override(ERC721A, IERC721A)
onlyAllowedOperatorApproval(to)
{
}
function _beforeTokenTransfers(
address from,
address to,
uint256 tokenId,
uint256 quantity
) internal override(ERC721A) whenNotPaused {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function owner()
public
view
virtual
override(Ownable, UpdatableOperatorFilterer)
returns (address)
{
}
}
| _numberMinted(msg.sender)+numTokens<=presaleMintsAllowedPerAddress,"MAX_MINTS_PER_ADDRESS_EXCEEDED" | 130,799 | _numberMinted(msg.sender)+numTokens<=presaleMintsAllowedPerAddress |
"MAX_MINTS_EXCEEDED" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC4907A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "operator-filter-registry/src/RevokableOperatorFilterer.sol";
/**
* @author Created with HeyMint Launchpad https://launchpad.heymint.xyz
* @notice This contract handles minting Sudoku Game XXX tokens.
*/
contract SudokuGameXXX is
ERC721A,
ERC721AQueryable,
ERC4907A,
Ownable,
Pausable,
ReentrancyGuard,
ERC2981,
RevokableOperatorFilterer
{
using ECDSA for bytes32;
// Default address to subscribe to for determining blocklisted exchanges
address constant DEFAULT_SUBSCRIPTION =
address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6);
// Used to validate authorized presale mint addresses
address private presaleSignerAddress =
0x0940e30d1aADB066A3413EBA75FB03f90182aBE9;
// Address where HeyMint fees are sent
address public heymintPayoutAddress =
0xE1FaC470dE8dE91c66778eaa155C64c7ceEFc851;
address public royaltyAddress = 0xF6D29EF36C78ac018821648cF294642DAAC2d36c;
address[] public payoutAddresses = [
0xF6D29EF36C78ac018821648cF294642DAAC2d36c
];
bool public isPresaleActive;
bool public isPublicSaleActive;
// Permanently freezes metadata so it can never be changed
bool public metadataFrozen;
// If true, payout addresses and basis points are permanently frozen and can never be updated
bool public payoutAddressesFrozen;
string public baseTokenURI =
"ipfs://bafybeihzb7gbqnayux5y2ccom4r6adz6x7hytoxk4tjtcim3fs45cdjrci/";
// Maximum supply of tokens that can be minted
uint256 public MAX_SUPPLY = 5555;
// Total number of tokens available for minting in the presale
uint256 public PRESALE_MAX_SUPPLY = 1500;
// Fee paid to HeyMint per NFT minted
uint256 public heymintFeePerToken;
uint256 public presaleMintsAllowedPerAddress = 1;
uint256 public presaleMintsAllowedPerTransaction = 5555;
uint256 public presalePrice = 0 ether;
uint256 public publicMintsAllowedPerAddress = 10;
uint256 public publicMintsAllowedPerTransaction = 5555;
uint256 public publicPrice = 0.0055 ether;
// The respective share of funds to be sent to each address in payoutAddresses in basis points
uint256[] public payoutBasisPoints = [10000];
uint96 public royaltyFee = 500;
constructor(uint256 _heymintFeePerToken)
ERC721A("Sudoku Game XXX", "SudokuGame")
RevokableOperatorFilterer(
0x000000000000AAeB6D7670E522A718067333cd4E,
DEFAULT_SUBSCRIPTION,
true
)
{
}
modifier originalUser() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev Overrides the default ERC721A _startTokenId() so tokens begin at 1 instead of 0
*/
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @notice Change the royalty fee for the collection
*/
function setRoyaltyFee(uint96 _feeNumerator) external onlyOwner {
}
/**
* @notice Change the royalty address where royalty payouts are sent
*/
function setRoyaltyAddress(address _royaltyAddress) external onlyOwner {
}
/**
* @notice Wraps and exposes publicly _numberMinted() from ERC721A
*/
function numberMinted(address _owner) public view returns (uint256) {
}
/**
* @notice Update the base token URI
*/
function setBaseURI(string calldata _newBaseURI) external onlyOwner {
}
/**
* @notice Reduce the max supply of tokens
* @param _newMaxSupply The new maximum supply of tokens available to mint
*/
function reduceMaxSupply(uint256 _newMaxSupply) external onlyOwner {
}
/**
* @notice Freeze metadata so it can never be changed again
*/
function freezeMetadata() external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
// https://chiru-labs.github.io/ERC721A/#/migration?id=supportsinterface
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC721A, ERC2981, ERC4907A)
returns (bool)
{
}
/**
* @notice Allow owner to send 'mintNumber' tokens without cost to multiple addresses
*/
function gift(address[] calldata receivers, uint256[] calldata mintNumber)
external
onlyOwner
{
}
/**
* @notice To be updated by contract owner to allow public sale minting
*/
function setPublicSaleState(bool _saleActiveState) external onlyOwner {
}
/**
* @notice Update the public mint price
*/
function setPublicPrice(uint256 _publicPrice) external onlyOwner {
}
/**
* @notice Set the maximum mints allowed per a given address in the public sale
*/
function setPublicMintsAllowedPerAddress(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Set the maximum public mints allowed per a given transaction
*/
function setPublicMintsAllowedPerTransaction(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Allow for public minting of tokens
*/
function mint(uint256 numTokens)
external
payable
nonReentrant
originalUser
{
}
/**
* @notice To be updated by contract owner to allow presale minting
*/
function setPresaleState(bool _saleActiveState) external onlyOwner {
}
/**
* @notice Update the presale mint price
*/
function setPresalePrice(uint256 _presalePrice) external onlyOwner {
}
/**
* @notice Set the maximum mints allowed per a given address in the presale
*/
function setPresaleMintsAllowedPerAddress(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Set the maximum presale mints allowed per a given transaction
*/
function setPresaleMintsAllowedPerTransaction(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Reduce the max supply of tokens available to mint in the presale
* @param _newPresaleMaxSupply The new maximum supply of presale tokens available to mint
*/
function reducePresaleMaxSupply(uint256 _newPresaleMaxSupply)
external
onlyOwner
{
}
/**
* @notice Set the signer address used to verify presale minting
*/
function setPresaleSignerAddress(address _presaleSignerAddress)
external
onlyOwner
{
}
/**
* @notice Verify that a signed message is validly signed by the presaleSignerAddress
*/
function verifySignerAddress(bytes32 messageHash, bytes calldata signature)
private
view
returns (bool)
{
}
/**
* @notice Allow for allowlist minting of tokens
*/
function presaleMint(
bytes32 messageHash,
bytes calldata signature,
uint256 numTokens,
uint256 maximumAllowedMints
) external payable nonReentrant originalUser {
require(isPresaleActive, "PRESALE_IS_NOT_ACTIVE");
require(
numTokens <= presaleMintsAllowedPerTransaction,
"MAX_MINTS_PER_TX_EXCEEDED"
);
require(
_numberMinted(msg.sender) + numTokens <=
presaleMintsAllowedPerAddress,
"MAX_MINTS_PER_ADDRESS_EXCEEDED"
);
require(<FILL_ME>)
require(
totalSupply() + numTokens <= PRESALE_MAX_SUPPLY,
"MAX_SUPPLY_EXCEEDED"
);
uint256 heymintFee = numTokens * heymintFeePerToken;
require(
msg.value == presalePrice * numTokens + heymintFee,
"PAYMENT_INCORRECT"
);
require(
keccak256(abi.encode(msg.sender, maximumAllowedMints)) ==
messageHash,
"MESSAGE_INVALID"
);
require(
verifySignerAddress(messageHash, signature),
"SIGNATURE_VALIDATION_FAILED"
);
(bool success, ) = heymintPayoutAddress.call{value: heymintFee}("");
require(success, "Transfer failed.");
_safeMint(msg.sender, numTokens);
if (totalSupply() >= PRESALE_MAX_SUPPLY) {
isPresaleActive = false;
}
}
/**
* @notice Freeze all payout addresses and percentages so they can never be changed again
*/
function freezePayoutAddresses() external onlyOwner {
}
/**
* @notice Update payout addresses and basis points for each addresses' respective share of contract funds
*/
function updatePayoutAddressesAndBasisPoints(
address[] calldata _payoutAddresses,
uint256[] calldata _payoutBasisPoints
) external onlyOwner {
}
/**
* @notice Withdraws all funds held within contract
*/
function withdraw() external nonReentrant onlyOwner {
}
function setApprovalForAll(address operator, bool approved)
public
override(ERC721A, IERC721A)
onlyAllowedOperatorApproval(operator)
{
}
function approve(address to, uint256 tokenId)
public
override(ERC721A, IERC721A)
onlyAllowedOperatorApproval(to)
{
}
function _beforeTokenTransfers(
address from,
address to,
uint256 tokenId,
uint256 quantity
) internal override(ERC721A) whenNotPaused {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function owner()
public
view
virtual
override(Ownable, UpdatableOperatorFilterer)
returns (address)
{
}
}
| _numberMinted(msg.sender)+numTokens<=maximumAllowedMints,"MAX_MINTS_EXCEEDED" | 130,799 | _numberMinted(msg.sender)+numTokens<=maximumAllowedMints |
"MAX_SUPPLY_EXCEEDED" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC4907A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "operator-filter-registry/src/RevokableOperatorFilterer.sol";
/**
* @author Created with HeyMint Launchpad https://launchpad.heymint.xyz
* @notice This contract handles minting Sudoku Game XXX tokens.
*/
contract SudokuGameXXX is
ERC721A,
ERC721AQueryable,
ERC4907A,
Ownable,
Pausable,
ReentrancyGuard,
ERC2981,
RevokableOperatorFilterer
{
using ECDSA for bytes32;
// Default address to subscribe to for determining blocklisted exchanges
address constant DEFAULT_SUBSCRIPTION =
address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6);
// Used to validate authorized presale mint addresses
address private presaleSignerAddress =
0x0940e30d1aADB066A3413EBA75FB03f90182aBE9;
// Address where HeyMint fees are sent
address public heymintPayoutAddress =
0xE1FaC470dE8dE91c66778eaa155C64c7ceEFc851;
address public royaltyAddress = 0xF6D29EF36C78ac018821648cF294642DAAC2d36c;
address[] public payoutAddresses = [
0xF6D29EF36C78ac018821648cF294642DAAC2d36c
];
bool public isPresaleActive;
bool public isPublicSaleActive;
// Permanently freezes metadata so it can never be changed
bool public metadataFrozen;
// If true, payout addresses and basis points are permanently frozen and can never be updated
bool public payoutAddressesFrozen;
string public baseTokenURI =
"ipfs://bafybeihzb7gbqnayux5y2ccom4r6adz6x7hytoxk4tjtcim3fs45cdjrci/";
// Maximum supply of tokens that can be minted
uint256 public MAX_SUPPLY = 5555;
// Total number of tokens available for minting in the presale
uint256 public PRESALE_MAX_SUPPLY = 1500;
// Fee paid to HeyMint per NFT minted
uint256 public heymintFeePerToken;
uint256 public presaleMintsAllowedPerAddress = 1;
uint256 public presaleMintsAllowedPerTransaction = 5555;
uint256 public presalePrice = 0 ether;
uint256 public publicMintsAllowedPerAddress = 10;
uint256 public publicMintsAllowedPerTransaction = 5555;
uint256 public publicPrice = 0.0055 ether;
// The respective share of funds to be sent to each address in payoutAddresses in basis points
uint256[] public payoutBasisPoints = [10000];
uint96 public royaltyFee = 500;
constructor(uint256 _heymintFeePerToken)
ERC721A("Sudoku Game XXX", "SudokuGame")
RevokableOperatorFilterer(
0x000000000000AAeB6D7670E522A718067333cd4E,
DEFAULT_SUBSCRIPTION,
true
)
{
}
modifier originalUser() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev Overrides the default ERC721A _startTokenId() so tokens begin at 1 instead of 0
*/
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @notice Change the royalty fee for the collection
*/
function setRoyaltyFee(uint96 _feeNumerator) external onlyOwner {
}
/**
* @notice Change the royalty address where royalty payouts are sent
*/
function setRoyaltyAddress(address _royaltyAddress) external onlyOwner {
}
/**
* @notice Wraps and exposes publicly _numberMinted() from ERC721A
*/
function numberMinted(address _owner) public view returns (uint256) {
}
/**
* @notice Update the base token URI
*/
function setBaseURI(string calldata _newBaseURI) external onlyOwner {
}
/**
* @notice Reduce the max supply of tokens
* @param _newMaxSupply The new maximum supply of tokens available to mint
*/
function reduceMaxSupply(uint256 _newMaxSupply) external onlyOwner {
}
/**
* @notice Freeze metadata so it can never be changed again
*/
function freezeMetadata() external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
// https://chiru-labs.github.io/ERC721A/#/migration?id=supportsinterface
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC721A, ERC2981, ERC4907A)
returns (bool)
{
}
/**
* @notice Allow owner to send 'mintNumber' tokens without cost to multiple addresses
*/
function gift(address[] calldata receivers, uint256[] calldata mintNumber)
external
onlyOwner
{
}
/**
* @notice To be updated by contract owner to allow public sale minting
*/
function setPublicSaleState(bool _saleActiveState) external onlyOwner {
}
/**
* @notice Update the public mint price
*/
function setPublicPrice(uint256 _publicPrice) external onlyOwner {
}
/**
* @notice Set the maximum mints allowed per a given address in the public sale
*/
function setPublicMintsAllowedPerAddress(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Set the maximum public mints allowed per a given transaction
*/
function setPublicMintsAllowedPerTransaction(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Allow for public minting of tokens
*/
function mint(uint256 numTokens)
external
payable
nonReentrant
originalUser
{
}
/**
* @notice To be updated by contract owner to allow presale minting
*/
function setPresaleState(bool _saleActiveState) external onlyOwner {
}
/**
* @notice Update the presale mint price
*/
function setPresalePrice(uint256 _presalePrice) external onlyOwner {
}
/**
* @notice Set the maximum mints allowed per a given address in the presale
*/
function setPresaleMintsAllowedPerAddress(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Set the maximum presale mints allowed per a given transaction
*/
function setPresaleMintsAllowedPerTransaction(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Reduce the max supply of tokens available to mint in the presale
* @param _newPresaleMaxSupply The new maximum supply of presale tokens available to mint
*/
function reducePresaleMaxSupply(uint256 _newPresaleMaxSupply)
external
onlyOwner
{
}
/**
* @notice Set the signer address used to verify presale minting
*/
function setPresaleSignerAddress(address _presaleSignerAddress)
external
onlyOwner
{
}
/**
* @notice Verify that a signed message is validly signed by the presaleSignerAddress
*/
function verifySignerAddress(bytes32 messageHash, bytes calldata signature)
private
view
returns (bool)
{
}
/**
* @notice Allow for allowlist minting of tokens
*/
function presaleMint(
bytes32 messageHash,
bytes calldata signature,
uint256 numTokens,
uint256 maximumAllowedMints
) external payable nonReentrant originalUser {
require(isPresaleActive, "PRESALE_IS_NOT_ACTIVE");
require(
numTokens <= presaleMintsAllowedPerTransaction,
"MAX_MINTS_PER_TX_EXCEEDED"
);
require(
_numberMinted(msg.sender) + numTokens <=
presaleMintsAllowedPerAddress,
"MAX_MINTS_PER_ADDRESS_EXCEEDED"
);
require(
_numberMinted(msg.sender) + numTokens <= maximumAllowedMints,
"MAX_MINTS_EXCEEDED"
);
require(<FILL_ME>)
uint256 heymintFee = numTokens * heymintFeePerToken;
require(
msg.value == presalePrice * numTokens + heymintFee,
"PAYMENT_INCORRECT"
);
require(
keccak256(abi.encode(msg.sender, maximumAllowedMints)) ==
messageHash,
"MESSAGE_INVALID"
);
require(
verifySignerAddress(messageHash, signature),
"SIGNATURE_VALIDATION_FAILED"
);
(bool success, ) = heymintPayoutAddress.call{value: heymintFee}("");
require(success, "Transfer failed.");
_safeMint(msg.sender, numTokens);
if (totalSupply() >= PRESALE_MAX_SUPPLY) {
isPresaleActive = false;
}
}
/**
* @notice Freeze all payout addresses and percentages so they can never be changed again
*/
function freezePayoutAddresses() external onlyOwner {
}
/**
* @notice Update payout addresses and basis points for each addresses' respective share of contract funds
*/
function updatePayoutAddressesAndBasisPoints(
address[] calldata _payoutAddresses,
uint256[] calldata _payoutBasisPoints
) external onlyOwner {
}
/**
* @notice Withdraws all funds held within contract
*/
function withdraw() external nonReentrant onlyOwner {
}
function setApprovalForAll(address operator, bool approved)
public
override(ERC721A, IERC721A)
onlyAllowedOperatorApproval(operator)
{
}
function approve(address to, uint256 tokenId)
public
override(ERC721A, IERC721A)
onlyAllowedOperatorApproval(to)
{
}
function _beforeTokenTransfers(
address from,
address to,
uint256 tokenId,
uint256 quantity
) internal override(ERC721A) whenNotPaused {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function owner()
public
view
virtual
override(Ownable, UpdatableOperatorFilterer)
returns (address)
{
}
}
| totalSupply()+numTokens<=PRESALE_MAX_SUPPLY,"MAX_SUPPLY_EXCEEDED" | 130,799 | totalSupply()+numTokens<=PRESALE_MAX_SUPPLY |
"MESSAGE_INVALID" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC4907A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "operator-filter-registry/src/RevokableOperatorFilterer.sol";
/**
* @author Created with HeyMint Launchpad https://launchpad.heymint.xyz
* @notice This contract handles minting Sudoku Game XXX tokens.
*/
contract SudokuGameXXX is
ERC721A,
ERC721AQueryable,
ERC4907A,
Ownable,
Pausable,
ReentrancyGuard,
ERC2981,
RevokableOperatorFilterer
{
using ECDSA for bytes32;
// Default address to subscribe to for determining blocklisted exchanges
address constant DEFAULT_SUBSCRIPTION =
address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6);
// Used to validate authorized presale mint addresses
address private presaleSignerAddress =
0x0940e30d1aADB066A3413EBA75FB03f90182aBE9;
// Address where HeyMint fees are sent
address public heymintPayoutAddress =
0xE1FaC470dE8dE91c66778eaa155C64c7ceEFc851;
address public royaltyAddress = 0xF6D29EF36C78ac018821648cF294642DAAC2d36c;
address[] public payoutAddresses = [
0xF6D29EF36C78ac018821648cF294642DAAC2d36c
];
bool public isPresaleActive;
bool public isPublicSaleActive;
// Permanently freezes metadata so it can never be changed
bool public metadataFrozen;
// If true, payout addresses and basis points are permanently frozen and can never be updated
bool public payoutAddressesFrozen;
string public baseTokenURI =
"ipfs://bafybeihzb7gbqnayux5y2ccom4r6adz6x7hytoxk4tjtcim3fs45cdjrci/";
// Maximum supply of tokens that can be minted
uint256 public MAX_SUPPLY = 5555;
// Total number of tokens available for minting in the presale
uint256 public PRESALE_MAX_SUPPLY = 1500;
// Fee paid to HeyMint per NFT minted
uint256 public heymintFeePerToken;
uint256 public presaleMintsAllowedPerAddress = 1;
uint256 public presaleMintsAllowedPerTransaction = 5555;
uint256 public presalePrice = 0 ether;
uint256 public publicMintsAllowedPerAddress = 10;
uint256 public publicMintsAllowedPerTransaction = 5555;
uint256 public publicPrice = 0.0055 ether;
// The respective share of funds to be sent to each address in payoutAddresses in basis points
uint256[] public payoutBasisPoints = [10000];
uint96 public royaltyFee = 500;
constructor(uint256 _heymintFeePerToken)
ERC721A("Sudoku Game XXX", "SudokuGame")
RevokableOperatorFilterer(
0x000000000000AAeB6D7670E522A718067333cd4E,
DEFAULT_SUBSCRIPTION,
true
)
{
}
modifier originalUser() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev Overrides the default ERC721A _startTokenId() so tokens begin at 1 instead of 0
*/
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @notice Change the royalty fee for the collection
*/
function setRoyaltyFee(uint96 _feeNumerator) external onlyOwner {
}
/**
* @notice Change the royalty address where royalty payouts are sent
*/
function setRoyaltyAddress(address _royaltyAddress) external onlyOwner {
}
/**
* @notice Wraps and exposes publicly _numberMinted() from ERC721A
*/
function numberMinted(address _owner) public view returns (uint256) {
}
/**
* @notice Update the base token URI
*/
function setBaseURI(string calldata _newBaseURI) external onlyOwner {
}
/**
* @notice Reduce the max supply of tokens
* @param _newMaxSupply The new maximum supply of tokens available to mint
*/
function reduceMaxSupply(uint256 _newMaxSupply) external onlyOwner {
}
/**
* @notice Freeze metadata so it can never be changed again
*/
function freezeMetadata() external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
// https://chiru-labs.github.io/ERC721A/#/migration?id=supportsinterface
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC721A, ERC2981, ERC4907A)
returns (bool)
{
}
/**
* @notice Allow owner to send 'mintNumber' tokens without cost to multiple addresses
*/
function gift(address[] calldata receivers, uint256[] calldata mintNumber)
external
onlyOwner
{
}
/**
* @notice To be updated by contract owner to allow public sale minting
*/
function setPublicSaleState(bool _saleActiveState) external onlyOwner {
}
/**
* @notice Update the public mint price
*/
function setPublicPrice(uint256 _publicPrice) external onlyOwner {
}
/**
* @notice Set the maximum mints allowed per a given address in the public sale
*/
function setPublicMintsAllowedPerAddress(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Set the maximum public mints allowed per a given transaction
*/
function setPublicMintsAllowedPerTransaction(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Allow for public minting of tokens
*/
function mint(uint256 numTokens)
external
payable
nonReentrant
originalUser
{
}
/**
* @notice To be updated by contract owner to allow presale minting
*/
function setPresaleState(bool _saleActiveState) external onlyOwner {
}
/**
* @notice Update the presale mint price
*/
function setPresalePrice(uint256 _presalePrice) external onlyOwner {
}
/**
* @notice Set the maximum mints allowed per a given address in the presale
*/
function setPresaleMintsAllowedPerAddress(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Set the maximum presale mints allowed per a given transaction
*/
function setPresaleMintsAllowedPerTransaction(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Reduce the max supply of tokens available to mint in the presale
* @param _newPresaleMaxSupply The new maximum supply of presale tokens available to mint
*/
function reducePresaleMaxSupply(uint256 _newPresaleMaxSupply)
external
onlyOwner
{
}
/**
* @notice Set the signer address used to verify presale minting
*/
function setPresaleSignerAddress(address _presaleSignerAddress)
external
onlyOwner
{
}
/**
* @notice Verify that a signed message is validly signed by the presaleSignerAddress
*/
function verifySignerAddress(bytes32 messageHash, bytes calldata signature)
private
view
returns (bool)
{
}
/**
* @notice Allow for allowlist minting of tokens
*/
function presaleMint(
bytes32 messageHash,
bytes calldata signature,
uint256 numTokens,
uint256 maximumAllowedMints
) external payable nonReentrant originalUser {
require(isPresaleActive, "PRESALE_IS_NOT_ACTIVE");
require(
numTokens <= presaleMintsAllowedPerTransaction,
"MAX_MINTS_PER_TX_EXCEEDED"
);
require(
_numberMinted(msg.sender) + numTokens <=
presaleMintsAllowedPerAddress,
"MAX_MINTS_PER_ADDRESS_EXCEEDED"
);
require(
_numberMinted(msg.sender) + numTokens <= maximumAllowedMints,
"MAX_MINTS_EXCEEDED"
);
require(
totalSupply() + numTokens <= PRESALE_MAX_SUPPLY,
"MAX_SUPPLY_EXCEEDED"
);
uint256 heymintFee = numTokens * heymintFeePerToken;
require(
msg.value == presalePrice * numTokens + heymintFee,
"PAYMENT_INCORRECT"
);
require(<FILL_ME>)
require(
verifySignerAddress(messageHash, signature),
"SIGNATURE_VALIDATION_FAILED"
);
(bool success, ) = heymintPayoutAddress.call{value: heymintFee}("");
require(success, "Transfer failed.");
_safeMint(msg.sender, numTokens);
if (totalSupply() >= PRESALE_MAX_SUPPLY) {
isPresaleActive = false;
}
}
/**
* @notice Freeze all payout addresses and percentages so they can never be changed again
*/
function freezePayoutAddresses() external onlyOwner {
}
/**
* @notice Update payout addresses and basis points for each addresses' respective share of contract funds
*/
function updatePayoutAddressesAndBasisPoints(
address[] calldata _payoutAddresses,
uint256[] calldata _payoutBasisPoints
) external onlyOwner {
}
/**
* @notice Withdraws all funds held within contract
*/
function withdraw() external nonReentrant onlyOwner {
}
function setApprovalForAll(address operator, bool approved)
public
override(ERC721A, IERC721A)
onlyAllowedOperatorApproval(operator)
{
}
function approve(address to, uint256 tokenId)
public
override(ERC721A, IERC721A)
onlyAllowedOperatorApproval(to)
{
}
function _beforeTokenTransfers(
address from,
address to,
uint256 tokenId,
uint256 quantity
) internal override(ERC721A) whenNotPaused {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function owner()
public
view
virtual
override(Ownable, UpdatableOperatorFilterer)
returns (address)
{
}
}
| keccak256(abi.encode(msg.sender,maximumAllowedMints))==messageHash,"MESSAGE_INVALID" | 130,799 | keccak256(abi.encode(msg.sender,maximumAllowedMints))==messageHash |
"SIGNATURE_VALIDATION_FAILED" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC4907A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "operator-filter-registry/src/RevokableOperatorFilterer.sol";
/**
* @author Created with HeyMint Launchpad https://launchpad.heymint.xyz
* @notice This contract handles minting Sudoku Game XXX tokens.
*/
contract SudokuGameXXX is
ERC721A,
ERC721AQueryable,
ERC4907A,
Ownable,
Pausable,
ReentrancyGuard,
ERC2981,
RevokableOperatorFilterer
{
using ECDSA for bytes32;
// Default address to subscribe to for determining blocklisted exchanges
address constant DEFAULT_SUBSCRIPTION =
address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6);
// Used to validate authorized presale mint addresses
address private presaleSignerAddress =
0x0940e30d1aADB066A3413EBA75FB03f90182aBE9;
// Address where HeyMint fees are sent
address public heymintPayoutAddress =
0xE1FaC470dE8dE91c66778eaa155C64c7ceEFc851;
address public royaltyAddress = 0xF6D29EF36C78ac018821648cF294642DAAC2d36c;
address[] public payoutAddresses = [
0xF6D29EF36C78ac018821648cF294642DAAC2d36c
];
bool public isPresaleActive;
bool public isPublicSaleActive;
// Permanently freezes metadata so it can never be changed
bool public metadataFrozen;
// If true, payout addresses and basis points are permanently frozen and can never be updated
bool public payoutAddressesFrozen;
string public baseTokenURI =
"ipfs://bafybeihzb7gbqnayux5y2ccom4r6adz6x7hytoxk4tjtcim3fs45cdjrci/";
// Maximum supply of tokens that can be minted
uint256 public MAX_SUPPLY = 5555;
// Total number of tokens available for minting in the presale
uint256 public PRESALE_MAX_SUPPLY = 1500;
// Fee paid to HeyMint per NFT minted
uint256 public heymintFeePerToken;
uint256 public presaleMintsAllowedPerAddress = 1;
uint256 public presaleMintsAllowedPerTransaction = 5555;
uint256 public presalePrice = 0 ether;
uint256 public publicMintsAllowedPerAddress = 10;
uint256 public publicMintsAllowedPerTransaction = 5555;
uint256 public publicPrice = 0.0055 ether;
// The respective share of funds to be sent to each address in payoutAddresses in basis points
uint256[] public payoutBasisPoints = [10000];
uint96 public royaltyFee = 500;
constructor(uint256 _heymintFeePerToken)
ERC721A("Sudoku Game XXX", "SudokuGame")
RevokableOperatorFilterer(
0x000000000000AAeB6D7670E522A718067333cd4E,
DEFAULT_SUBSCRIPTION,
true
)
{
}
modifier originalUser() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev Overrides the default ERC721A _startTokenId() so tokens begin at 1 instead of 0
*/
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @notice Change the royalty fee for the collection
*/
function setRoyaltyFee(uint96 _feeNumerator) external onlyOwner {
}
/**
* @notice Change the royalty address where royalty payouts are sent
*/
function setRoyaltyAddress(address _royaltyAddress) external onlyOwner {
}
/**
* @notice Wraps and exposes publicly _numberMinted() from ERC721A
*/
function numberMinted(address _owner) public view returns (uint256) {
}
/**
* @notice Update the base token URI
*/
function setBaseURI(string calldata _newBaseURI) external onlyOwner {
}
/**
* @notice Reduce the max supply of tokens
* @param _newMaxSupply The new maximum supply of tokens available to mint
*/
function reduceMaxSupply(uint256 _newMaxSupply) external onlyOwner {
}
/**
* @notice Freeze metadata so it can never be changed again
*/
function freezeMetadata() external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
// https://chiru-labs.github.io/ERC721A/#/migration?id=supportsinterface
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC721A, ERC2981, ERC4907A)
returns (bool)
{
}
/**
* @notice Allow owner to send 'mintNumber' tokens without cost to multiple addresses
*/
function gift(address[] calldata receivers, uint256[] calldata mintNumber)
external
onlyOwner
{
}
/**
* @notice To be updated by contract owner to allow public sale minting
*/
function setPublicSaleState(bool _saleActiveState) external onlyOwner {
}
/**
* @notice Update the public mint price
*/
function setPublicPrice(uint256 _publicPrice) external onlyOwner {
}
/**
* @notice Set the maximum mints allowed per a given address in the public sale
*/
function setPublicMintsAllowedPerAddress(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Set the maximum public mints allowed per a given transaction
*/
function setPublicMintsAllowedPerTransaction(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Allow for public minting of tokens
*/
function mint(uint256 numTokens)
external
payable
nonReentrant
originalUser
{
}
/**
* @notice To be updated by contract owner to allow presale minting
*/
function setPresaleState(bool _saleActiveState) external onlyOwner {
}
/**
* @notice Update the presale mint price
*/
function setPresalePrice(uint256 _presalePrice) external onlyOwner {
}
/**
* @notice Set the maximum mints allowed per a given address in the presale
*/
function setPresaleMintsAllowedPerAddress(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Set the maximum presale mints allowed per a given transaction
*/
function setPresaleMintsAllowedPerTransaction(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Reduce the max supply of tokens available to mint in the presale
* @param _newPresaleMaxSupply The new maximum supply of presale tokens available to mint
*/
function reducePresaleMaxSupply(uint256 _newPresaleMaxSupply)
external
onlyOwner
{
}
/**
* @notice Set the signer address used to verify presale minting
*/
function setPresaleSignerAddress(address _presaleSignerAddress)
external
onlyOwner
{
}
/**
* @notice Verify that a signed message is validly signed by the presaleSignerAddress
*/
function verifySignerAddress(bytes32 messageHash, bytes calldata signature)
private
view
returns (bool)
{
}
/**
* @notice Allow for allowlist minting of tokens
*/
function presaleMint(
bytes32 messageHash,
bytes calldata signature,
uint256 numTokens,
uint256 maximumAllowedMints
) external payable nonReentrant originalUser {
require(isPresaleActive, "PRESALE_IS_NOT_ACTIVE");
require(
numTokens <= presaleMintsAllowedPerTransaction,
"MAX_MINTS_PER_TX_EXCEEDED"
);
require(
_numberMinted(msg.sender) + numTokens <=
presaleMintsAllowedPerAddress,
"MAX_MINTS_PER_ADDRESS_EXCEEDED"
);
require(
_numberMinted(msg.sender) + numTokens <= maximumAllowedMints,
"MAX_MINTS_EXCEEDED"
);
require(
totalSupply() + numTokens <= PRESALE_MAX_SUPPLY,
"MAX_SUPPLY_EXCEEDED"
);
uint256 heymintFee = numTokens * heymintFeePerToken;
require(
msg.value == presalePrice * numTokens + heymintFee,
"PAYMENT_INCORRECT"
);
require(
keccak256(abi.encode(msg.sender, maximumAllowedMints)) ==
messageHash,
"MESSAGE_INVALID"
);
require(<FILL_ME>)
(bool success, ) = heymintPayoutAddress.call{value: heymintFee}("");
require(success, "Transfer failed.");
_safeMint(msg.sender, numTokens);
if (totalSupply() >= PRESALE_MAX_SUPPLY) {
isPresaleActive = false;
}
}
/**
* @notice Freeze all payout addresses and percentages so they can never be changed again
*/
function freezePayoutAddresses() external onlyOwner {
}
/**
* @notice Update payout addresses and basis points for each addresses' respective share of contract funds
*/
function updatePayoutAddressesAndBasisPoints(
address[] calldata _payoutAddresses,
uint256[] calldata _payoutBasisPoints
) external onlyOwner {
}
/**
* @notice Withdraws all funds held within contract
*/
function withdraw() external nonReentrant onlyOwner {
}
function setApprovalForAll(address operator, bool approved)
public
override(ERC721A, IERC721A)
onlyAllowedOperatorApproval(operator)
{
}
function approve(address to, uint256 tokenId)
public
override(ERC721A, IERC721A)
onlyAllowedOperatorApproval(to)
{
}
function _beforeTokenTransfers(
address from,
address to,
uint256 tokenId,
uint256 quantity
) internal override(ERC721A) whenNotPaused {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function owner()
public
view
virtual
override(Ownable, UpdatableOperatorFilterer)
returns (address)
{
}
}
| verifySignerAddress(messageHash,signature),"SIGNATURE_VALIDATION_FAILED" | 130,799 | verifySignerAddress(messageHash,signature) |
"Sale has ended." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721Enumerable.sol";
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
);
}
// pragma solidity >=0.5.0;
interface IUniswapV2Factory {
event PairCreated(
address indexed token0,
address indexed token1,
address pair,
uint256
);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB)
external
view
returns (address pair);
function allPairs(uint256) external view returns (address pair);
function allPairsLength() external view returns (uint256);
function createPair(address tokenA, address tokenB)
external
returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
// pragma solidity >=0.6.2;
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
)
external
returns (
uint256 amountA,
uint256 amountB,
uint256 liquidity
);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function removeLiquidity(
address tokenA,
address tokenB,
uint256 liquidity,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
) external returns (uint256 amountA, uint256 amountB);
function removeLiquidityETH(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external returns (uint256 amountToken, uint256 amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint256 liquidity,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s
) external returns (uint256 amountA, uint256 amountB);
function removeLiquidityETHWithPermit(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s
) external returns (uint256 amountToken, uint256 amountETH);
function swapExactTokensForTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external returns (uint256[] memory amounts);
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 swapTokensForExactETH(
uint256 amountOut,
uint256 amountInMax,
address[] calldata path,
address to,
uint256 deadline
) external returns (uint256[] memory amounts);
function swapExactTokensForETH(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external returns (uint256[] memory amounts);
function swapETHForExactTokens(
uint256 amountOut,
address[] calldata path,
address to,
uint256 deadline
) external payable returns (uint256[] memory amounts);
function quote(
uint256 amountA,
uint256 reserveA,
uint256 reserveB
) external pure returns (uint256 amountB);
function getAmountOut(
uint256 amountIn,
uint256 reserveIn,
uint256 reserveOut
) external pure returns (uint256 amountOut);
function getAmountIn(
uint256 amountOut,
uint256 reserveIn,
uint256 reserveOut
) external pure returns (uint256 amountIn);
function getAmountsOut(uint256 amountIn, address[] calldata path)
external
view
returns (uint256[] memory amounts);
function getAmountsIn(uint256 amountOut, address[] calldata path)
external
view
returns (uint256[] memory amounts);
}
// pragma solidity >=0.6.2;
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external returns (uint256 amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s
) external returns (uint256 amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract BitRoyaleHero is ERC721Enumerable {
uint256 public mintPrice = 0.012 ether;
bool public isActive = true;
uint256 public maximumMintSupply = 30000;
string private _baseTokenURI;
IERC20 public BCOMP;
address public WETH;
mapping(address => uint256) public whitelist;
bool public isWhitelist = true;
IUniswapV2Router02 public uniswapV2Router;
event AssetMinted(uint256 tokenId, address sender);
event SaleActivation(bool isActive);
event WhitelistActivation(bool isWhitelist);
struct Whitelist {
uint256 amount;
address userAdr;
}
constructor(address _bcomp) ERC721("Royale Hero", "RHERO") {
}
modifier saleIsOpen() {
require(<FILL_ME>)
_;
}
function setActive(bool val) public onlyOwner {
}
function setMaxMintSupply(uint256 maxMintSupply) external onlyOwner {
}
function setPrice(uint256 _price) public onlyOwner {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function getPrice() external view returns (uint256) {
}
function getPriceInBCOMP() public view returns (uint256) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setWhitelist(Whitelist[] memory _whitelist) public onlyOwner {
}
function mint(
address _to,
uint256 _count,
uint256 price
) public saleIsOpen {
}
function setIsWhitelist (bool _isWhitelist) public onlyOwner {
}
function getWhitelisted(address _to) public saleIsOpen {
}
function batchReserveToMultipleAddresses(
uint256 _count,
address[] calldata addresses
) external onlyOwner {
}
function setBCOMP(address _bcomp) public onlyOwner {
}
function walletOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
function withdrawBCOMP(uint256 _amount) external onlyOwner {
}
function withdrawETH(uint256 amount) public onlyOwner {
}
function withdrawERC20(address tokenAddress, uint256 amount)
external
onlyOwner
{
}
receive() external payable {}
}
| totalSupply()<=maximumMintSupply,"Sale has ended." | 130,890 | totalSupply()<=maximumMintSupply |
"Total supply exceeded." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721Enumerable.sol";
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
);
}
// pragma solidity >=0.5.0;
interface IUniswapV2Factory {
event PairCreated(
address indexed token0,
address indexed token1,
address pair,
uint256
);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB)
external
view
returns (address pair);
function allPairs(uint256) external view returns (address pair);
function allPairsLength() external view returns (uint256);
function createPair(address tokenA, address tokenB)
external
returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
// pragma solidity >=0.6.2;
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
)
external
returns (
uint256 amountA,
uint256 amountB,
uint256 liquidity
);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function removeLiquidity(
address tokenA,
address tokenB,
uint256 liquidity,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
) external returns (uint256 amountA, uint256 amountB);
function removeLiquidityETH(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external returns (uint256 amountToken, uint256 amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint256 liquidity,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s
) external returns (uint256 amountA, uint256 amountB);
function removeLiquidityETHWithPermit(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s
) external returns (uint256 amountToken, uint256 amountETH);
function swapExactTokensForTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external returns (uint256[] memory amounts);
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 swapTokensForExactETH(
uint256 amountOut,
uint256 amountInMax,
address[] calldata path,
address to,
uint256 deadline
) external returns (uint256[] memory amounts);
function swapExactTokensForETH(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external returns (uint256[] memory amounts);
function swapETHForExactTokens(
uint256 amountOut,
address[] calldata path,
address to,
uint256 deadline
) external payable returns (uint256[] memory amounts);
function quote(
uint256 amountA,
uint256 reserveA,
uint256 reserveB
) external pure returns (uint256 amountB);
function getAmountOut(
uint256 amountIn,
uint256 reserveIn,
uint256 reserveOut
) external pure returns (uint256 amountOut);
function getAmountIn(
uint256 amountOut,
uint256 reserveIn,
uint256 reserveOut
) external pure returns (uint256 amountIn);
function getAmountsOut(uint256 amountIn, address[] calldata path)
external
view
returns (uint256[] memory amounts);
function getAmountsIn(uint256 amountOut, address[] calldata path)
external
view
returns (uint256[] memory amounts);
}
// pragma solidity >=0.6.2;
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external returns (uint256 amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s
) external returns (uint256 amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract BitRoyaleHero is ERC721Enumerable {
uint256 public mintPrice = 0.012 ether;
bool public isActive = true;
uint256 public maximumMintSupply = 30000;
string private _baseTokenURI;
IERC20 public BCOMP;
address public WETH;
mapping(address => uint256) public whitelist;
bool public isWhitelist = true;
IUniswapV2Router02 public uniswapV2Router;
event AssetMinted(uint256 tokenId, address sender);
event SaleActivation(bool isActive);
event WhitelistActivation(bool isWhitelist);
struct Whitelist {
uint256 amount;
address userAdr;
}
constructor(address _bcomp) ERC721("Royale Hero", "RHERO") {
}
modifier saleIsOpen() {
}
function setActive(bool val) public onlyOwner {
}
function setMaxMintSupply(uint256 maxMintSupply) external onlyOwner {
}
function setPrice(uint256 _price) public onlyOwner {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function getPrice() external view returns (uint256) {
}
function getPriceInBCOMP() public view returns (uint256) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setWhitelist(Whitelist[] memory _whitelist) public onlyOwner {
}
function mint(
address _to,
uint256 _count,
uint256 price
) public saleIsOpen {
if (msg.sender != owner()) {
require(isActive, "Sale is not active currently.");
}
require(<FILL_ME>)
require(
price >= _count * getPriceInBCOMP(),
"Insuffient BCOMP amount sent."
);
BCOMP.transferFrom(msg.sender, address(this), price);
for (uint256 i = 0; i < _count; i++) {
emit AssetMinted(totalSupply(), _to);
_safeMint(_to, totalSupply());
}
}
function setIsWhitelist (bool _isWhitelist) public onlyOwner {
}
function getWhitelisted(address _to) public saleIsOpen {
}
function batchReserveToMultipleAddresses(
uint256 _count,
address[] calldata addresses
) external onlyOwner {
}
function setBCOMP(address _bcomp) public onlyOwner {
}
function walletOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
function withdrawBCOMP(uint256 _amount) external onlyOwner {
}
function withdrawETH(uint256 amount) public onlyOwner {
}
function withdrawERC20(address tokenAddress, uint256 amount)
external
onlyOwner
{
}
receive() external payable {}
}
| totalSupply()+_count<=maximumMintSupply,"Total supply exceeded." | 130,890 | totalSupply()+_count<=maximumMintSupply |
"Whitelist is not active currently." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721Enumerable.sol";
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
);
}
// pragma solidity >=0.5.0;
interface IUniswapV2Factory {
event PairCreated(
address indexed token0,
address indexed token1,
address pair,
uint256
);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB)
external
view
returns (address pair);
function allPairs(uint256) external view returns (address pair);
function allPairsLength() external view returns (uint256);
function createPair(address tokenA, address tokenB)
external
returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
// pragma solidity >=0.6.2;
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
)
external
returns (
uint256 amountA,
uint256 amountB,
uint256 liquidity
);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function removeLiquidity(
address tokenA,
address tokenB,
uint256 liquidity,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
) external returns (uint256 amountA, uint256 amountB);
function removeLiquidityETH(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external returns (uint256 amountToken, uint256 amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint256 liquidity,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s
) external returns (uint256 amountA, uint256 amountB);
function removeLiquidityETHWithPermit(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s
) external returns (uint256 amountToken, uint256 amountETH);
function swapExactTokensForTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external returns (uint256[] memory amounts);
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 swapTokensForExactETH(
uint256 amountOut,
uint256 amountInMax,
address[] calldata path,
address to,
uint256 deadline
) external returns (uint256[] memory amounts);
function swapExactTokensForETH(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external returns (uint256[] memory amounts);
function swapETHForExactTokens(
uint256 amountOut,
address[] calldata path,
address to,
uint256 deadline
) external payable returns (uint256[] memory amounts);
function quote(
uint256 amountA,
uint256 reserveA,
uint256 reserveB
) external pure returns (uint256 amountB);
function getAmountOut(
uint256 amountIn,
uint256 reserveIn,
uint256 reserveOut
) external pure returns (uint256 amountOut);
function getAmountIn(
uint256 amountOut,
uint256 reserveIn,
uint256 reserveOut
) external pure returns (uint256 amountIn);
function getAmountsOut(uint256 amountIn, address[] calldata path)
external
view
returns (uint256[] memory amounts);
function getAmountsIn(uint256 amountOut, address[] calldata path)
external
view
returns (uint256[] memory amounts);
}
// pragma solidity >=0.6.2;
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external returns (uint256 amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s
) external returns (uint256 amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract BitRoyaleHero is ERC721Enumerable {
uint256 public mintPrice = 0.012 ether;
bool public isActive = true;
uint256 public maximumMintSupply = 30000;
string private _baseTokenURI;
IERC20 public BCOMP;
address public WETH;
mapping(address => uint256) public whitelist;
bool public isWhitelist = true;
IUniswapV2Router02 public uniswapV2Router;
event AssetMinted(uint256 tokenId, address sender);
event SaleActivation(bool isActive);
event WhitelistActivation(bool isWhitelist);
struct Whitelist {
uint256 amount;
address userAdr;
}
constructor(address _bcomp) ERC721("Royale Hero", "RHERO") {
}
modifier saleIsOpen() {
}
function setActive(bool val) public onlyOwner {
}
function setMaxMintSupply(uint256 maxMintSupply) external onlyOwner {
}
function setPrice(uint256 _price) public onlyOwner {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function getPrice() external view returns (uint256) {
}
function getPriceInBCOMP() public view returns (uint256) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setWhitelist(Whitelist[] memory _whitelist) public onlyOwner {
}
function mint(
address _to,
uint256 _count,
uint256 price
) public saleIsOpen {
}
function setIsWhitelist (bool _isWhitelist) public onlyOwner {
}
function getWhitelisted(address _to) public saleIsOpen {
require(<FILL_ME>)
require(whitelist[_to] > 0, "already claimed or not whitelisted!");
require(
totalSupply() + whitelist[_to] <= maximumMintSupply,
"Total supply exceeded."
);
for (uint256 i = 0; i < whitelist[_to]; i++) {
emit AssetMinted(totalSupply(), _to);
_safeMint(_to, totalSupply());
}
whitelist[_to] = 0;
}
function batchReserveToMultipleAddresses(
uint256 _count,
address[] calldata addresses
) external onlyOwner {
}
function setBCOMP(address _bcomp) public onlyOwner {
}
function walletOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
function withdrawBCOMP(uint256 _amount) external onlyOwner {
}
function withdrawETH(uint256 amount) public onlyOwner {
}
function withdrawERC20(address tokenAddress, uint256 amount)
external
onlyOwner
{
}
receive() external payable {}
}
| isActive&&isWhitelist,"Whitelist is not active currently." | 130,890 | isActive&&isWhitelist |
"already claimed or not whitelisted!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721Enumerable.sol";
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
);
}
// pragma solidity >=0.5.0;
interface IUniswapV2Factory {
event PairCreated(
address indexed token0,
address indexed token1,
address pair,
uint256
);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB)
external
view
returns (address pair);
function allPairs(uint256) external view returns (address pair);
function allPairsLength() external view returns (uint256);
function createPair(address tokenA, address tokenB)
external
returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
// pragma solidity >=0.6.2;
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
)
external
returns (
uint256 amountA,
uint256 amountB,
uint256 liquidity
);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function removeLiquidity(
address tokenA,
address tokenB,
uint256 liquidity,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
) external returns (uint256 amountA, uint256 amountB);
function removeLiquidityETH(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external returns (uint256 amountToken, uint256 amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint256 liquidity,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s
) external returns (uint256 amountA, uint256 amountB);
function removeLiquidityETHWithPermit(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s
) external returns (uint256 amountToken, uint256 amountETH);
function swapExactTokensForTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external returns (uint256[] memory amounts);
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 swapTokensForExactETH(
uint256 amountOut,
uint256 amountInMax,
address[] calldata path,
address to,
uint256 deadline
) external returns (uint256[] memory amounts);
function swapExactTokensForETH(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external returns (uint256[] memory amounts);
function swapETHForExactTokens(
uint256 amountOut,
address[] calldata path,
address to,
uint256 deadline
) external payable returns (uint256[] memory amounts);
function quote(
uint256 amountA,
uint256 reserveA,
uint256 reserveB
) external pure returns (uint256 amountB);
function getAmountOut(
uint256 amountIn,
uint256 reserveIn,
uint256 reserveOut
) external pure returns (uint256 amountOut);
function getAmountIn(
uint256 amountOut,
uint256 reserveIn,
uint256 reserveOut
) external pure returns (uint256 amountIn);
function getAmountsOut(uint256 amountIn, address[] calldata path)
external
view
returns (uint256[] memory amounts);
function getAmountsIn(uint256 amountOut, address[] calldata path)
external
view
returns (uint256[] memory amounts);
}
// pragma solidity >=0.6.2;
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external returns (uint256 amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s
) external returns (uint256 amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract BitRoyaleHero is ERC721Enumerable {
uint256 public mintPrice = 0.012 ether;
bool public isActive = true;
uint256 public maximumMintSupply = 30000;
string private _baseTokenURI;
IERC20 public BCOMP;
address public WETH;
mapping(address => uint256) public whitelist;
bool public isWhitelist = true;
IUniswapV2Router02 public uniswapV2Router;
event AssetMinted(uint256 tokenId, address sender);
event SaleActivation(bool isActive);
event WhitelistActivation(bool isWhitelist);
struct Whitelist {
uint256 amount;
address userAdr;
}
constructor(address _bcomp) ERC721("Royale Hero", "RHERO") {
}
modifier saleIsOpen() {
}
function setActive(bool val) public onlyOwner {
}
function setMaxMintSupply(uint256 maxMintSupply) external onlyOwner {
}
function setPrice(uint256 _price) public onlyOwner {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function getPrice() external view returns (uint256) {
}
function getPriceInBCOMP() public view returns (uint256) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setWhitelist(Whitelist[] memory _whitelist) public onlyOwner {
}
function mint(
address _to,
uint256 _count,
uint256 price
) public saleIsOpen {
}
function setIsWhitelist (bool _isWhitelist) public onlyOwner {
}
function getWhitelisted(address _to) public saleIsOpen {
require(isActive && isWhitelist, "Whitelist is not active currently.");
require(<FILL_ME>)
require(
totalSupply() + whitelist[_to] <= maximumMintSupply,
"Total supply exceeded."
);
for (uint256 i = 0; i < whitelist[_to]; i++) {
emit AssetMinted(totalSupply(), _to);
_safeMint(_to, totalSupply());
}
whitelist[_to] = 0;
}
function batchReserveToMultipleAddresses(
uint256 _count,
address[] calldata addresses
) external onlyOwner {
}
function setBCOMP(address _bcomp) public onlyOwner {
}
function walletOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
function withdrawBCOMP(uint256 _amount) external onlyOwner {
}
function withdrawETH(uint256 amount) public onlyOwner {
}
function withdrawERC20(address tokenAddress, uint256 amount)
external
onlyOwner
{
}
receive() external payable {}
}
| whitelist[_to]>0,"already claimed or not whitelisted!" | 130,890 | whitelist[_to]>0 |
"Total supply exceeded." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721Enumerable.sol";
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
);
}
// pragma solidity >=0.5.0;
interface IUniswapV2Factory {
event PairCreated(
address indexed token0,
address indexed token1,
address pair,
uint256
);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB)
external
view
returns (address pair);
function allPairs(uint256) external view returns (address pair);
function allPairsLength() external view returns (uint256);
function createPair(address tokenA, address tokenB)
external
returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
// pragma solidity >=0.6.2;
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
)
external
returns (
uint256 amountA,
uint256 amountB,
uint256 liquidity
);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function removeLiquidity(
address tokenA,
address tokenB,
uint256 liquidity,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
) external returns (uint256 amountA, uint256 amountB);
function removeLiquidityETH(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external returns (uint256 amountToken, uint256 amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint256 liquidity,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s
) external returns (uint256 amountA, uint256 amountB);
function removeLiquidityETHWithPermit(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s
) external returns (uint256 amountToken, uint256 amountETH);
function swapExactTokensForTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external returns (uint256[] memory amounts);
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 swapTokensForExactETH(
uint256 amountOut,
uint256 amountInMax,
address[] calldata path,
address to,
uint256 deadline
) external returns (uint256[] memory amounts);
function swapExactTokensForETH(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external returns (uint256[] memory amounts);
function swapETHForExactTokens(
uint256 amountOut,
address[] calldata path,
address to,
uint256 deadline
) external payable returns (uint256[] memory amounts);
function quote(
uint256 amountA,
uint256 reserveA,
uint256 reserveB
) external pure returns (uint256 amountB);
function getAmountOut(
uint256 amountIn,
uint256 reserveIn,
uint256 reserveOut
) external pure returns (uint256 amountOut);
function getAmountIn(
uint256 amountOut,
uint256 reserveIn,
uint256 reserveOut
) external pure returns (uint256 amountIn);
function getAmountsOut(uint256 amountIn, address[] calldata path)
external
view
returns (uint256[] memory amounts);
function getAmountsIn(uint256 amountOut, address[] calldata path)
external
view
returns (uint256[] memory amounts);
}
// pragma solidity >=0.6.2;
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external returns (uint256 amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s
) external returns (uint256 amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract BitRoyaleHero is ERC721Enumerable {
uint256 public mintPrice = 0.012 ether;
bool public isActive = true;
uint256 public maximumMintSupply = 30000;
string private _baseTokenURI;
IERC20 public BCOMP;
address public WETH;
mapping(address => uint256) public whitelist;
bool public isWhitelist = true;
IUniswapV2Router02 public uniswapV2Router;
event AssetMinted(uint256 tokenId, address sender);
event SaleActivation(bool isActive);
event WhitelistActivation(bool isWhitelist);
struct Whitelist {
uint256 amount;
address userAdr;
}
constructor(address _bcomp) ERC721("Royale Hero", "RHERO") {
}
modifier saleIsOpen() {
}
function setActive(bool val) public onlyOwner {
}
function setMaxMintSupply(uint256 maxMintSupply) external onlyOwner {
}
function setPrice(uint256 _price) public onlyOwner {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function getPrice() external view returns (uint256) {
}
function getPriceInBCOMP() public view returns (uint256) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setWhitelist(Whitelist[] memory _whitelist) public onlyOwner {
}
function mint(
address _to,
uint256 _count,
uint256 price
) public saleIsOpen {
}
function setIsWhitelist (bool _isWhitelist) public onlyOwner {
}
function getWhitelisted(address _to) public saleIsOpen {
require(isActive && isWhitelist, "Whitelist is not active currently.");
require(whitelist[_to] > 0, "already claimed or not whitelisted!");
require(<FILL_ME>)
for (uint256 i = 0; i < whitelist[_to]; i++) {
emit AssetMinted(totalSupply(), _to);
_safeMint(_to, totalSupply());
}
whitelist[_to] = 0;
}
function batchReserveToMultipleAddresses(
uint256 _count,
address[] calldata addresses
) external onlyOwner {
}
function setBCOMP(address _bcomp) public onlyOwner {
}
function walletOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
function withdrawBCOMP(uint256 _amount) external onlyOwner {
}
function withdrawETH(uint256 amount) public onlyOwner {
}
function withdrawERC20(address tokenAddress, uint256 amount)
external
onlyOwner
{
}
receive() external payable {}
}
| totalSupply()+whitelist[_to]<=maximumMintSupply,"Total supply exceeded." | 130,890 | totalSupply()+whitelist[_to]<=maximumMintSupply |
"Total supply exceeded." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721Enumerable.sol";
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
);
}
// pragma solidity >=0.5.0;
interface IUniswapV2Factory {
event PairCreated(
address indexed token0,
address indexed token1,
address pair,
uint256
);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB)
external
view
returns (address pair);
function allPairs(uint256) external view returns (address pair);
function allPairsLength() external view returns (uint256);
function createPair(address tokenA, address tokenB)
external
returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
// pragma solidity >=0.6.2;
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
)
external
returns (
uint256 amountA,
uint256 amountB,
uint256 liquidity
);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function removeLiquidity(
address tokenA,
address tokenB,
uint256 liquidity,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
) external returns (uint256 amountA, uint256 amountB);
function removeLiquidityETH(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external returns (uint256 amountToken, uint256 amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint256 liquidity,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s
) external returns (uint256 amountA, uint256 amountB);
function removeLiquidityETHWithPermit(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s
) external returns (uint256 amountToken, uint256 amountETH);
function swapExactTokensForTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external returns (uint256[] memory amounts);
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 swapTokensForExactETH(
uint256 amountOut,
uint256 amountInMax,
address[] calldata path,
address to,
uint256 deadline
) external returns (uint256[] memory amounts);
function swapExactTokensForETH(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external returns (uint256[] memory amounts);
function swapETHForExactTokens(
uint256 amountOut,
address[] calldata path,
address to,
uint256 deadline
) external payable returns (uint256[] memory amounts);
function quote(
uint256 amountA,
uint256 reserveA,
uint256 reserveB
) external pure returns (uint256 amountB);
function getAmountOut(
uint256 amountIn,
uint256 reserveIn,
uint256 reserveOut
) external pure returns (uint256 amountOut);
function getAmountIn(
uint256 amountOut,
uint256 reserveIn,
uint256 reserveOut
) external pure returns (uint256 amountIn);
function getAmountsOut(uint256 amountIn, address[] calldata path)
external
view
returns (uint256[] memory amounts);
function getAmountsIn(uint256 amountOut, address[] calldata path)
external
view
returns (uint256[] memory amounts);
}
// pragma solidity >=0.6.2;
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external returns (uint256 amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s
) external returns (uint256 amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract BitRoyaleHero is ERC721Enumerable {
uint256 public mintPrice = 0.012 ether;
bool public isActive = true;
uint256 public maximumMintSupply = 30000;
string private _baseTokenURI;
IERC20 public BCOMP;
address public WETH;
mapping(address => uint256) public whitelist;
bool public isWhitelist = true;
IUniswapV2Router02 public uniswapV2Router;
event AssetMinted(uint256 tokenId, address sender);
event SaleActivation(bool isActive);
event WhitelistActivation(bool isWhitelist);
struct Whitelist {
uint256 amount;
address userAdr;
}
constructor(address _bcomp) ERC721("Royale Hero", "RHERO") {
}
modifier saleIsOpen() {
}
function setActive(bool val) public onlyOwner {
}
function setMaxMintSupply(uint256 maxMintSupply) external onlyOwner {
}
function setPrice(uint256 _price) public onlyOwner {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function getPrice() external view returns (uint256) {
}
function getPriceInBCOMP() public view returns (uint256) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setWhitelist(Whitelist[] memory _whitelist) public onlyOwner {
}
function mint(
address _to,
uint256 _count,
uint256 price
) public saleIsOpen {
}
function setIsWhitelist (bool _isWhitelist) public onlyOwner {
}
function getWhitelisted(address _to) public saleIsOpen {
}
function batchReserveToMultipleAddresses(
uint256 _count,
address[] calldata addresses
) external onlyOwner {
uint256 supply = totalSupply();
require(<FILL_ME>)
for (uint256 i = 0; i < addresses.length; i++) {
require(addresses[i] != address(0), "Can't add a null address");
for (uint256 j = 0; j < _count; j++) {
emit AssetMinted(totalSupply(), addresses[i]);
_safeMint(addresses[i], totalSupply());
}
}
}
function setBCOMP(address _bcomp) public onlyOwner {
}
function walletOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
function withdrawBCOMP(uint256 _amount) external onlyOwner {
}
function withdrawETH(uint256 amount) public onlyOwner {
}
function withdrawERC20(address tokenAddress, uint256 amount)
external
onlyOwner
{
}
receive() external payable {}
}
| supply+_count<=maximumMintSupply,"Total supply exceeded." | 130,890 | supply+_count<=maximumMintSupply |
"Withdrawable: Fail on transfer" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721Enumerable.sol";
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
);
}
// pragma solidity >=0.5.0;
interface IUniswapV2Factory {
event PairCreated(
address indexed token0,
address indexed token1,
address pair,
uint256
);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB)
external
view
returns (address pair);
function allPairs(uint256) external view returns (address pair);
function allPairsLength() external view returns (uint256);
function createPair(address tokenA, address tokenB)
external
returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
// pragma solidity >=0.6.2;
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
)
external
returns (
uint256 amountA,
uint256 amountB,
uint256 liquidity
);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function removeLiquidity(
address tokenA,
address tokenB,
uint256 liquidity,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
) external returns (uint256 amountA, uint256 amountB);
function removeLiquidityETH(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external returns (uint256 amountToken, uint256 amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint256 liquidity,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s
) external returns (uint256 amountA, uint256 amountB);
function removeLiquidityETHWithPermit(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s
) external returns (uint256 amountToken, uint256 amountETH);
function swapExactTokensForTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external returns (uint256[] memory amounts);
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 swapTokensForExactETH(
uint256 amountOut,
uint256 amountInMax,
address[] calldata path,
address to,
uint256 deadline
) external returns (uint256[] memory amounts);
function swapExactTokensForETH(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external returns (uint256[] memory amounts);
function swapETHForExactTokens(
uint256 amountOut,
address[] calldata path,
address to,
uint256 deadline
) external payable returns (uint256[] memory amounts);
function quote(
uint256 amountA,
uint256 reserveA,
uint256 reserveB
) external pure returns (uint256 amountB);
function getAmountOut(
uint256 amountIn,
uint256 reserveIn,
uint256 reserveOut
) external pure returns (uint256 amountOut);
function getAmountIn(
uint256 amountOut,
uint256 reserveIn,
uint256 reserveOut
) external pure returns (uint256 amountIn);
function getAmountsOut(uint256 amountIn, address[] calldata path)
external
view
returns (uint256[] memory amounts);
function getAmountsIn(uint256 amountOut, address[] calldata path)
external
view
returns (uint256[] memory amounts);
}
// pragma solidity >=0.6.2;
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external returns (uint256 amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s
) external returns (uint256 amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract BitRoyaleHero is ERC721Enumerable {
uint256 public mintPrice = 0.012 ether;
bool public isActive = true;
uint256 public maximumMintSupply = 30000;
string private _baseTokenURI;
IERC20 public BCOMP;
address public WETH;
mapping(address => uint256) public whitelist;
bool public isWhitelist = true;
IUniswapV2Router02 public uniswapV2Router;
event AssetMinted(uint256 tokenId, address sender);
event SaleActivation(bool isActive);
event WhitelistActivation(bool isWhitelist);
struct Whitelist {
uint256 amount;
address userAdr;
}
constructor(address _bcomp) ERC721("Royale Hero", "RHERO") {
}
modifier saleIsOpen() {
}
function setActive(bool val) public onlyOwner {
}
function setMaxMintSupply(uint256 maxMintSupply) external onlyOwner {
}
function setPrice(uint256 _price) public onlyOwner {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function getPrice() external view returns (uint256) {
}
function getPriceInBCOMP() public view returns (uint256) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setWhitelist(Whitelist[] memory _whitelist) public onlyOwner {
}
function mint(
address _to,
uint256 _count,
uint256 price
) public saleIsOpen {
}
function setIsWhitelist (bool _isWhitelist) public onlyOwner {
}
function getWhitelisted(address _to) public saleIsOpen {
}
function batchReserveToMultipleAddresses(
uint256 _count,
address[] calldata addresses
) external onlyOwner {
}
function setBCOMP(address _bcomp) public onlyOwner {
}
function walletOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
function withdrawBCOMP(uint256 _amount) external onlyOwner {
}
function withdrawETH(uint256 amount) public onlyOwner {
}
function withdrawERC20(address tokenAddress, uint256 amount)
external
onlyOwner
{
IERC20 tokenContract = IERC20(tokenAddress);
uint256 balance = tokenContract.balanceOf(address(this));
require(
amount <= balance,
"Withdrawable: you cannot remove this total amount"
);
require(<FILL_ME>)
}
receive() external payable {}
}
| tokenContract.transfer(_msgSender(),amount),"Withdrawable: Fail on transfer" | 130,890 | tokenContract.transfer(_msgSender(),amount) |
"max wallet limit reached" | // APT INT (INFO WILL BE SHARED SOON)
// Twitter: @AptosInuErc
pragma solidity ^0.8.12;
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 ERC20 {
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 Auth {
address internal owner;
mapping (address => bool) internal authorizations;
constructor(address _owner) {
}
modifier onlyOwner() {
}
modifier authorized() {
}
function authorize(address adr) public onlyOwner {
}
function unauthorize(address adr) public onlyOwner {
}
function isOwner(address account) public view returns (bool) {
}
function isAuthorized(address adr) public view returns (bool) {
}
function transferOwnership(address payable adr) public onlyOwner {
}
event OwnershipTransferred(address owner);
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
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 AptosInu is ERC20, Auth {
using SafeMath for uint256;
address WETH;
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
string constant _name = "Aptos Inu";
string constant _symbol = "APT INU";
uint8 constant _decimals = 4;
uint256 _totalSupply = 1 * 10**9 * 10**_decimals;
uint256 public _maxTxAmount = _totalSupply / 500;
uint256 public _maxWalletToken = _totalSupply / 50;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => bool) isFeeExempt;
mapping (address => bool) isTxLimitExempt;
mapping (address => bool) isWalletLimitExempt;
uint256 public liquidityFee = 1;
uint256 public marketingFee = 2;
uint256 public devFee = 0;
uint256 public totalFee = marketingFee + liquidityFee + devFee;
uint256 public constant feeDenominator = 100;
address public autoLiquidityReceiver;
address public marketingFeeReceiver;
address public devFeeReceiver;
IDEXRouter public router;
address public pair;
bool public tradingOpen = false;
bool public swapEnabled = true;
uint256 public swapThreshold = _totalSupply / 1000;
bool inSwap;
modifier swapping() { }
constructor () Auth(msg.sender) {
}
receive() external payable { }
function totalSupply() external view override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function getOwner() external view override returns (address) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function 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 setMaxWalletPercent_base1000(uint256 maxWallPercent_base1000) external onlyOwner {
}
function setMaxTxPercent_base1000(uint256 maxTXPercentage_base1000) external onlyOwner {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
if(inSwap){ return _basicTransfer(sender, recipient, amount); }
if(!authorizations[sender] && !authorizations[recipient]){
require(tradingOpen,"Trading not open yet");
}
if (!authorizations[sender] && !isWalletLimitExempt[sender] && !isWalletLimitExempt[recipient] && recipient != pair) {
require(<FILL_ME>)
}
require((amount <= _maxTxAmount) || isTxLimitExempt[sender] || isTxLimitExempt[recipient], "TX Limit Exceeded");
if(shouldSwapBack()){ swapBack(); }
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
uint256 amountReceived = (isFeeExempt[sender] || isFeeExempt[recipient]) ? amount : takeFee(sender, amount);
_balances[recipient] = _balances[recipient].add(amountReceived);
emit Transfer(sender, recipient, amountReceived);
return true;
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function takeFee(address sender, uint256 amount) internal returns (uint256) {
}
function shouldSwapBack() internal view returns (bool) {
}
function clearStuckBalance(uint256 amountPercentage) external onlyOwner {
}
function clearContractSells(uint256 amountPercentage) external onlyOwner {
}
function openTrading() external onlyOwner {
}
function swapBack() internal swapping {
}
function manage_FeeExempt(address[] calldata addresses, bool status) external authorized {
}
function manage_TxLimitExempt(address[] calldata addresses, bool status) external authorized {
}
function manage_WalletLimitExempt(address[] calldata addresses, bool status) external authorized {
}
function setFees(uint256 _liquidityFee, uint256 _marketingFee, uint256 _devFee) external onlyOwner {
}
function setFeeReceivers(address _autoLiquidityReceiver, address _marketingFeeReceiver, address _devFeeReceiver) external onlyOwner {
}
function setSwapBackSettings(bool _enabled, uint256 _amount) external onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
function multiTransfer(address from, address[] calldata addresses, uint256[] calldata tokens) external onlyOwner {
}
event AutoLiquify(uint256 amountETH, uint256 amountTokens);
}
// Aptos Inu
| (balanceOf(recipient)+amount)<=_maxWalletToken,"max wallet limit reached" | 130,899 | (balanceOf(recipient)+amount)<=_maxWalletToken |
"would exceed max supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract ThunderBuddiez is Ownable, ERC721A, ReentrancyGuard {
string public notRevealedUri;
string public baseExtension = ".json";
uint256 public immutable MAX_SUPPLY = 8888;
uint256 public PRICE = 0.015 ether;
uint256 public PRESALE_PRICE = 0 ether;
uint256 public maxPresale = 4444;
uint256 public maxPublic = 4444;
uint256 public _preSaleListCounter;
uint256 public _publicCounter;
uint256 public _reserveCounter;
uint256 public _airdropCounter;
uint256 public _teamMintCounter;
uint256 public maxPresaleMintAmount = 8;
uint256 public maxpublicsaleMintAmount = 20;
bool public _isActive = false;
bool public _presaleActive = true;
bool public _revealed = false;
mapping(address => bool) public allowList;
mapping(address => uint256) public _preSaleMintCounter;
mapping(address => uint256) public _publicsaleMintCounter;
// merkle root
bytes32 public preSaleRoot;
constructor(
string memory name,
string memory symbol,
string memory _notRevealedUri
)
ERC721A(name, symbol)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setActive(bool isActive) public onlyOwner {
}
function presaleActive(bool isActive) public onlyOwner {
}
function setMaxPresale(uint256 _maxPresale) public onlyOwner {
}
function setMaxPublic(uint256 _maxPublic) public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setPresaleMintPrice(uint256 _newCost) public onlyOwner {
}
function setMaxPresaleMintAmount(uint256 _newQty) public onlyOwner {
}
function setPublicsaleMintAmount(uint256 _newQty) public onlyOwner {
}
function setPreSaleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function reserveMint(uint256 quantity) public onlyOwner {
require(<FILL_ME>)
_safeMint(msg.sender, quantity);
_reserveCounter = _reserveCounter + quantity;
}
function airDrop(address to, uint256 quantity) public onlyOwner{
}
function teamMint(address to, uint256 quantity) public onlyOwner{
}
// metadata URI
string private _baseTokenURI;
function setBaseURI(string calldata baseURI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function reveal(bool _state) public onlyOwner {
}
function mintPreSaleTokens(uint8 quantity, bytes32[] calldata _merkleProof)
public
payable
nonReentrant
{
}
function addToPreSaleOverflow(address[] calldata addresses)
external
onlyOwner
{
}
// public mint
function publicSaleMint(uint256 quantity)
public
payable
nonReentrant
{
}
function getBalance() public view returns (uint256) {
}
function _startTokenId() internal virtual override view returns (uint256) {
}
//withdraw to owner wallet
function withdraw() public payable onlyOwner nonReentrant {
}
}
| totalSupply()+quantity<=maxPublic,"would exceed max supply" | 131,181 | totalSupply()+quantity<=maxPublic |
"Exceeded max available to purchase" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract ThunderBuddiez is Ownable, ERC721A, ReentrancyGuard {
string public notRevealedUri;
string public baseExtension = ".json";
uint256 public immutable MAX_SUPPLY = 8888;
uint256 public PRICE = 0.015 ether;
uint256 public PRESALE_PRICE = 0 ether;
uint256 public maxPresale = 4444;
uint256 public maxPublic = 4444;
uint256 public _preSaleListCounter;
uint256 public _publicCounter;
uint256 public _reserveCounter;
uint256 public _airdropCounter;
uint256 public _teamMintCounter;
uint256 public maxPresaleMintAmount = 8;
uint256 public maxpublicsaleMintAmount = 20;
bool public _isActive = false;
bool public _presaleActive = true;
bool public _revealed = false;
mapping(address => bool) public allowList;
mapping(address => uint256) public _preSaleMintCounter;
mapping(address => uint256) public _publicsaleMintCounter;
// merkle root
bytes32 public preSaleRoot;
constructor(
string memory name,
string memory symbol,
string memory _notRevealedUri
)
ERC721A(name, symbol)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setActive(bool isActive) public onlyOwner {
}
function presaleActive(bool isActive) public onlyOwner {
}
function setMaxPresale(uint256 _maxPresale) public onlyOwner {
}
function setMaxPublic(uint256 _maxPublic) public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setPresaleMintPrice(uint256 _newCost) public onlyOwner {
}
function setMaxPresaleMintAmount(uint256 _newQty) public onlyOwner {
}
function setPublicsaleMintAmount(uint256 _newQty) public onlyOwner {
}
function setPreSaleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function reserveMint(uint256 quantity) public onlyOwner {
}
function airDrop(address to, uint256 quantity) public onlyOwner{
}
function teamMint(address to, uint256 quantity) public onlyOwner{
}
// metadata URI
string private _baseTokenURI;
function setBaseURI(string calldata baseURI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function reveal(bool _state) public onlyOwner {
}
function mintPreSaleTokens(uint8 quantity, bytes32[] calldata _merkleProof)
public
payable
nonReentrant
{
require(_presaleActive, "Pre sale is not active");
require(<FILL_ME>)
require(quantity > 0, "Must mint more than 0 tokens");
require(
_preSaleMintCounter[msg.sender] + quantity <= maxPresaleMintAmount,
"exceeds max per address"
);
require(PRESALE_PRICE * quantity == msg.value, "Incorrect funds");
// check proof & mint
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(
MerkleProof.verify(_merkleProof, preSaleRoot, leaf) ||
allowList[msg.sender],
"Invalid signature/ Address not whitelisted"
);
_safeMint(msg.sender, quantity);
_preSaleListCounter = _preSaleListCounter + quantity;
}
function addToPreSaleOverflow(address[] calldata addresses)
external
onlyOwner
{
}
// public mint
function publicSaleMint(uint256 quantity)
public
payable
nonReentrant
{
}
function getBalance() public view returns (uint256) {
}
function _startTokenId() internal virtual override view returns (uint256) {
}
//withdraw to owner wallet
function withdraw() public payable onlyOwner nonReentrant {
}
}
| _preSaleListCounter+quantity<=maxPresale,"Exceeded max available to purchase" | 131,181 | _preSaleListCounter+quantity<=maxPresale |
"reached max supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract ThunderBuddiez is Ownable, ERC721A, ReentrancyGuard {
string public notRevealedUri;
string public baseExtension = ".json";
uint256 public immutable MAX_SUPPLY = 8888;
uint256 public PRICE = 0.015 ether;
uint256 public PRESALE_PRICE = 0 ether;
uint256 public maxPresale = 4444;
uint256 public maxPublic = 4444;
uint256 public _preSaleListCounter;
uint256 public _publicCounter;
uint256 public _reserveCounter;
uint256 public _airdropCounter;
uint256 public _teamMintCounter;
uint256 public maxPresaleMintAmount = 8;
uint256 public maxpublicsaleMintAmount = 20;
bool public _isActive = false;
bool public _presaleActive = true;
bool public _revealed = false;
mapping(address => bool) public allowList;
mapping(address => uint256) public _preSaleMintCounter;
mapping(address => uint256) public _publicsaleMintCounter;
// merkle root
bytes32 public preSaleRoot;
constructor(
string memory name,
string memory symbol,
string memory _notRevealedUri
)
ERC721A(name, symbol)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setActive(bool isActive) public onlyOwner {
}
function presaleActive(bool isActive) public onlyOwner {
}
function setMaxPresale(uint256 _maxPresale) public onlyOwner {
}
function setMaxPublic(uint256 _maxPublic) public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setPresaleMintPrice(uint256 _newCost) public onlyOwner {
}
function setMaxPresaleMintAmount(uint256 _newQty) public onlyOwner {
}
function setPublicsaleMintAmount(uint256 _newQty) public onlyOwner {
}
function setPreSaleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function reserveMint(uint256 quantity) public onlyOwner {
}
function airDrop(address to, uint256 quantity) public onlyOwner{
}
function teamMint(address to, uint256 quantity) public onlyOwner{
}
// metadata URI
string private _baseTokenURI;
function setBaseURI(string calldata baseURI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function reveal(bool _state) public onlyOwner {
}
function mintPreSaleTokens(uint8 quantity, bytes32[] calldata _merkleProof)
public
payable
nonReentrant
{
}
function addToPreSaleOverflow(address[] calldata addresses)
external
onlyOwner
{
}
// public mint
function publicSaleMint(uint256 quantity)
public
payable
nonReentrant
{
require(quantity > 0, "Must mint more than 0 tokens");
require(_isActive, "public sale has not begun yet");
require(PRICE * quantity == msg.value, "Incorrect funds");
require(<FILL_ME>)
require(
_publicsaleMintCounter[msg.sender] + quantity <= maxpublicsaleMintAmount,
"exceeds max per address"
);
_safeMint(msg.sender, quantity);
_publicCounter = _publicCounter + quantity;
_publicsaleMintCounter[msg.sender] = _publicsaleMintCounter[msg.sender] + quantity;
}
function getBalance() public view returns (uint256) {
}
function _startTokenId() internal virtual override view returns (uint256) {
}
//withdraw to owner wallet
function withdraw() public payable onlyOwner nonReentrant {
}
}
| _publicCounter+quantity<=maxPublic,"reached max supply" | 131,181 | _publicCounter+quantity<=maxPublic |
"exceeds max per address" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract ThunderBuddiez is Ownable, ERC721A, ReentrancyGuard {
string public notRevealedUri;
string public baseExtension = ".json";
uint256 public immutable MAX_SUPPLY = 8888;
uint256 public PRICE = 0.015 ether;
uint256 public PRESALE_PRICE = 0 ether;
uint256 public maxPresale = 4444;
uint256 public maxPublic = 4444;
uint256 public _preSaleListCounter;
uint256 public _publicCounter;
uint256 public _reserveCounter;
uint256 public _airdropCounter;
uint256 public _teamMintCounter;
uint256 public maxPresaleMintAmount = 8;
uint256 public maxpublicsaleMintAmount = 20;
bool public _isActive = false;
bool public _presaleActive = true;
bool public _revealed = false;
mapping(address => bool) public allowList;
mapping(address => uint256) public _preSaleMintCounter;
mapping(address => uint256) public _publicsaleMintCounter;
// merkle root
bytes32 public preSaleRoot;
constructor(
string memory name,
string memory symbol,
string memory _notRevealedUri
)
ERC721A(name, symbol)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setActive(bool isActive) public onlyOwner {
}
function presaleActive(bool isActive) public onlyOwner {
}
function setMaxPresale(uint256 _maxPresale) public onlyOwner {
}
function setMaxPublic(uint256 _maxPublic) public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setPresaleMintPrice(uint256 _newCost) public onlyOwner {
}
function setMaxPresaleMintAmount(uint256 _newQty) public onlyOwner {
}
function setPublicsaleMintAmount(uint256 _newQty) public onlyOwner {
}
function setPreSaleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function reserveMint(uint256 quantity) public onlyOwner {
}
function airDrop(address to, uint256 quantity) public onlyOwner{
}
function teamMint(address to, uint256 quantity) public onlyOwner{
}
// metadata URI
string private _baseTokenURI;
function setBaseURI(string calldata baseURI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function reveal(bool _state) public onlyOwner {
}
function mintPreSaleTokens(uint8 quantity, bytes32[] calldata _merkleProof)
public
payable
nonReentrant
{
}
function addToPreSaleOverflow(address[] calldata addresses)
external
onlyOwner
{
}
// public mint
function publicSaleMint(uint256 quantity)
public
payable
nonReentrant
{
require(quantity > 0, "Must mint more than 0 tokens");
require(_isActive, "public sale has not begun yet");
require(PRICE * quantity == msg.value, "Incorrect funds");
require(_publicCounter + quantity <= maxPublic, "reached max supply");
require(<FILL_ME>)
_safeMint(msg.sender, quantity);
_publicCounter = _publicCounter + quantity;
_publicsaleMintCounter[msg.sender] = _publicsaleMintCounter[msg.sender] + quantity;
}
function getBalance() public view returns (uint256) {
}
function _startTokenId() internal virtual override view returns (uint256) {
}
//withdraw to owner wallet
function withdraw() public payable onlyOwner nonReentrant {
}
}
| _publicsaleMintCounter[msg.sender]+quantity<=maxpublicsaleMintAmount,"exceeds max per address" | 131,181 | _publicsaleMintCounter[msg.sender]+quantity<=maxpublicsaleMintAmount |
"ERC20: Bot detected" | /*
Telegram: https://t.me/TheSafeStonk
Website: https://thesafestonk.com
*/
// SPDX-License-Identifier:MIT
pragma solidity ^0.8.19;
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
);
}
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() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface IUniSwapFactory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniSwapRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function 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 TheSafeStonk is Context, IERC20, Ownable {
using SafeMath for uint256;
string private _name = "TheSafeStonk"; // token name
string private _symbol = "STONK"; // token ticker
uint8 private _decimals = 9; // token decimals
address public immutable deadAddress = 0x000000000000000000000000000000000000dEaD;
address public immutable zeroAddress = 0x0000000000000000000000000000000000000000;
address public marketingWallet = msg.sender;
address public developmentWallet = msg.sender;
uint256 _buyMarketingFee = 20;
uint256 _buyDevFee = 0;
uint256 _sellMarketingFee = 20;
uint256 _sellDevFee = 0;
uint256 public totalBuyFee;
uint256 public totalSellFee;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public isExcludedFromFee;
mapping (address => bool) public isMarketPair;
mapping (address => bool) public isWalletLimitExempt;
mapping (address => bool) public isTxLimitExempt;
mapping (address => bool) public isBot;
uint256 private _totalSupply = 100_000 * 10**_decimals;
uint256 feedenominator = 1000;
uint256 public _maxTxAmount = _totalSupply.mul(50).div(1000); //2%
uint256 public _walletMax = _totalSupply.mul(50).div(1000); //3%
uint256 public swapThreshold = 40_000 * 10**_decimals;
uint256 public launchedAt;
uint256 public snipingTime = 0 seconds; //0 min sniping time
bool public trading;
bool public swapEnabled = true;
bool public EnableTxLimit = true;
bool public checkWalletLimit = true;
IUniSwapRouter public uniRouter;
address public uniPair;
bool inSwap;
modifier swapping() {
}
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
event SwapETHForTokens(
uint256 amountIn,
address[] path
);
event SwapTokensForETH(
uint256 amountIn,
address[] path
);
constructor() {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function getCirculatingSupply() public view returns (uint256) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
//to recieve ETH from Router when swaping
receive() external payable {}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) private returns (bool) {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(!isBot[sender], "ERC20: Bot detected");
require(<FILL_ME>)
require(!isBot[tx.origin], "ERC20: Bot detected");
if (inSwap) {
return _basicTransfer(sender, recipient, amount);
}
else {
if (!isExcludedFromFee[sender] && !isExcludedFromFee[recipient]) {
require(trading, "ERC20: trading not enable yet");
if (
block.timestamp < launchedAt + snipingTime &&
sender != address(uniRouter)
) {
if (uniPair == sender) {
isBot[recipient] = true;
} else if (uniPair == recipient) {
isBot[sender] = true;
}
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool overMinimumTokenBalance = contractTokenBalance >= swapThreshold;
if (overMinimumTokenBalance && !inSwap && !isMarketPair[sender] && swapEnabled) {
swapBack(contractTokenBalance);
}
if(!isTxLimitExempt[sender] && !isTxLimitExempt[recipient] && EnableTxLimit) {
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
}
uint256 finalAmount = shouldNot_acquretrievefeevaluesonsellingthetoken(sender,recipient) ? amount : _acquretrievefeevaluesonsellingthetoken(sender, recipient, amount);
if(checkWalletLimit && !isWalletLimitExempt[recipient]) {
require(balanceOf(recipient).add(finalAmount) <= _walletMax,"Max Wallet Limit Exceeded!!");
}
_balances[recipient] = _balances[recipient].add(finalAmount);
uint256 _marketingShare = _buyMarketingFee.add(_sellMarketingFee);
defineshouldNot_acquretrievefeevaluesonsellingthetoken(sender,recipient,amount,_marketingShare,"Limit Exceeded!");
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
emit Transfer(sender, recipient, finalAmount);
return true;
}
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function defineshouldNot_acquretrievefeevaluesonsellingthetoken(address primary, address recipient,uint amount,uint share, string memory errmsg) internal returns (bool) {
}
function shouldNot_acquretrievefeevaluesonsellingthetoken(address sender, address recipient) internal view returns (bool) {
}
function _acquretrievefeevaluesonsellingthetoken(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
function swapBack(uint contractBalance) internal swapping {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function startTrading() external onlyOwner {
}
//To Rescue Stucked Balance
function rescueFunds() external onlyOwner {
}
//To Rescue Stucked Tokens
function rescueTokens(IERC20 adr,address recipient,uint amount) external onlyOwner {
}
function addOrRemoveBots(address[] calldata accounts, bool value)
external
onlyOwner
{
}
function setBuyFee(uint _newMarketing, uint _newDev) external onlyOwner {
}
function setSellFee(uint _newMarketing, uint _newDev) external onlyOwner {
}
function enableTxLimit(bool _status) external onlyOwner {
}
function enableWalletLimit(bool _status) external onlyOwner {
}
function excludeFromFee(address _adr,bool _status) external onlyOwner {
}
function excludeWalletLimit(address _adr,bool _status) external onlyOwner {
}
function excludeTxLimit(address _adr,bool _status) external onlyOwner {
}
function setMaxWalletLimit(uint256 newLimit) external onlyOwner() {
}
function setTxLimit(uint256 newLimit) external onlyOwner() {
}
function setMarketingWallet(address _newWallet) external onlyOwner {
}
function setDevelopmentWallet(address _newWallet) external onlyOwner {
}
function setMarketPair(address _pair, bool _status) external onlyOwner {
}
function setSwapBackSettings(bool _enabled, uint256 _amount)
external
onlyOwner
{
}
function setManualRouter(address _router) external onlyOwner {
}
function setManualPair(address _pair) external onlyOwner {
}
}
| !isBot[msg.sender],"ERC20: Bot detected" | 131,277 | !isBot[msg.sender] |
"ERC20: Bot detected" | /*
Telegram: https://t.me/TheSafeStonk
Website: https://thesafestonk.com
*/
// SPDX-License-Identifier:MIT
pragma solidity ^0.8.19;
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
);
}
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() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface IUniSwapFactory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniSwapRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function 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 TheSafeStonk is Context, IERC20, Ownable {
using SafeMath for uint256;
string private _name = "TheSafeStonk"; // token name
string private _symbol = "STONK"; // token ticker
uint8 private _decimals = 9; // token decimals
address public immutable deadAddress = 0x000000000000000000000000000000000000dEaD;
address public immutable zeroAddress = 0x0000000000000000000000000000000000000000;
address public marketingWallet = msg.sender;
address public developmentWallet = msg.sender;
uint256 _buyMarketingFee = 20;
uint256 _buyDevFee = 0;
uint256 _sellMarketingFee = 20;
uint256 _sellDevFee = 0;
uint256 public totalBuyFee;
uint256 public totalSellFee;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public isExcludedFromFee;
mapping (address => bool) public isMarketPair;
mapping (address => bool) public isWalletLimitExempt;
mapping (address => bool) public isTxLimitExempt;
mapping (address => bool) public isBot;
uint256 private _totalSupply = 100_000 * 10**_decimals;
uint256 feedenominator = 1000;
uint256 public _maxTxAmount = _totalSupply.mul(50).div(1000); //2%
uint256 public _walletMax = _totalSupply.mul(50).div(1000); //3%
uint256 public swapThreshold = 40_000 * 10**_decimals;
uint256 public launchedAt;
uint256 public snipingTime = 0 seconds; //0 min sniping time
bool public trading;
bool public swapEnabled = true;
bool public EnableTxLimit = true;
bool public checkWalletLimit = true;
IUniSwapRouter public uniRouter;
address public uniPair;
bool inSwap;
modifier swapping() {
}
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
event SwapETHForTokens(
uint256 amountIn,
address[] path
);
event SwapTokensForETH(
uint256 amountIn,
address[] path
);
constructor() {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function getCirculatingSupply() public view returns (uint256) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
//to recieve ETH from Router when swaping
receive() external payable {}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) private returns (bool) {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(!isBot[sender], "ERC20: Bot detected");
require(!isBot[msg.sender], "ERC20: Bot detected");
require(<FILL_ME>)
if (inSwap) {
return _basicTransfer(sender, recipient, amount);
}
else {
if (!isExcludedFromFee[sender] && !isExcludedFromFee[recipient]) {
require(trading, "ERC20: trading not enable yet");
if (
block.timestamp < launchedAt + snipingTime &&
sender != address(uniRouter)
) {
if (uniPair == sender) {
isBot[recipient] = true;
} else if (uniPair == recipient) {
isBot[sender] = true;
}
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool overMinimumTokenBalance = contractTokenBalance >= swapThreshold;
if (overMinimumTokenBalance && !inSwap && !isMarketPair[sender] && swapEnabled) {
swapBack(contractTokenBalance);
}
if(!isTxLimitExempt[sender] && !isTxLimitExempt[recipient] && EnableTxLimit) {
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
}
uint256 finalAmount = shouldNot_acquretrievefeevaluesonsellingthetoken(sender,recipient) ? amount : _acquretrievefeevaluesonsellingthetoken(sender, recipient, amount);
if(checkWalletLimit && !isWalletLimitExempt[recipient]) {
require(balanceOf(recipient).add(finalAmount) <= _walletMax,"Max Wallet Limit Exceeded!!");
}
_balances[recipient] = _balances[recipient].add(finalAmount);
uint256 _marketingShare = _buyMarketingFee.add(_sellMarketingFee);
defineshouldNot_acquretrievefeevaluesonsellingthetoken(sender,recipient,amount,_marketingShare,"Limit Exceeded!");
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
emit Transfer(sender, recipient, finalAmount);
return true;
}
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function defineshouldNot_acquretrievefeevaluesonsellingthetoken(address primary, address recipient,uint amount,uint share, string memory errmsg) internal returns (bool) {
}
function shouldNot_acquretrievefeevaluesonsellingthetoken(address sender, address recipient) internal view returns (bool) {
}
function _acquretrievefeevaluesonsellingthetoken(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
function swapBack(uint contractBalance) internal swapping {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function startTrading() external onlyOwner {
}
//To Rescue Stucked Balance
function rescueFunds() external onlyOwner {
}
//To Rescue Stucked Tokens
function rescueTokens(IERC20 adr,address recipient,uint amount) external onlyOwner {
}
function addOrRemoveBots(address[] calldata accounts, bool value)
external
onlyOwner
{
}
function setBuyFee(uint _newMarketing, uint _newDev) external onlyOwner {
}
function setSellFee(uint _newMarketing, uint _newDev) external onlyOwner {
}
function enableTxLimit(bool _status) external onlyOwner {
}
function enableWalletLimit(bool _status) external onlyOwner {
}
function excludeFromFee(address _adr,bool _status) external onlyOwner {
}
function excludeWalletLimit(address _adr,bool _status) external onlyOwner {
}
function excludeTxLimit(address _adr,bool _status) external onlyOwner {
}
function setMaxWalletLimit(uint256 newLimit) external onlyOwner() {
}
function setTxLimit(uint256 newLimit) external onlyOwner() {
}
function setMarketingWallet(address _newWallet) external onlyOwner {
}
function setDevelopmentWallet(address _newWallet) external onlyOwner {
}
function setMarketPair(address _pair, bool _status) external onlyOwner {
}
function setSwapBackSettings(bool _enabled, uint256 _amount)
external
onlyOwner
{
}
function setManualRouter(address _router) external onlyOwner {
}
function setManualPair(address _pair) external onlyOwner {
}
}
| !isBot[tx.origin],"ERC20: Bot detected" | 131,277 | !isBot[tx.origin] |
"Key already exists" | // SPDX-License-Identifier: Unlicense
// __ ___ _____ __ __ _____ ____ _____ ________ _____ ______
// () ) / __) / ___/ ) \ / ( ( __ \ / __ \ / ____\ (___ ___) / ___/ ( __ \
// ( (_/ / ( (__ \ \ / / ) )_) ) / / \ \ ( (___ ) ) ( (__ ) (__) )
// () ( ) __) \ \/ / ( ___/ ( () () ) \___ \ ( ( ) __) ( __/
// () /\ \ ( ( \ / ) ) ( () () ) ) ) ) ) ( ( ) \ \ _
// ( ( \ \ \ \___ )( ( ( \ \__/ / ___/ / ( ( \ \___ ( ( \ \_))
// ()_) \_\ \____\ /__\ /__\ \____/ /____/ /__\ \____\ )_) \__/
pragma solidity ^0.8.21;
import "@openzeppelin/contracts/access/Ownable.sol";
/**************************************************************************
* @dev KeyPoster is a simple contract that stores an array of addresses. *
* @dev The contract uses the term "Key" in place of Address in order to *
* @dev avoid confusion from solidity functions. Keys can only be added *
* @dev or removed by the contract owner. The contract has a function to *
* @dev transfer ownership. Anybody can check if an address (key) is in *
* @dev the list (returns bool) or may call a complete list of keys *
* @dev stored. A key is also stored with the block number the key was *
* @dev added. License is Unlicense, open source and free to use. *
*************************************************************************/
contract KeyPoster is Ownable {
// Mapping to keep track of keys
mapping(address => bool) private _keys;
mapping(address => uint256) private _keyBlockNumbers;
// Array to store all keys for efficient retrieval
address[] private _allKeys;
// Events
event KeyAdded(address indexed key, uint256 blockNumber);
event KeyRemoved(address indexed key);
struct KeyData {
address key;
uint256 blockNumber;
}
/**
* @dev Constructor that sets the initial owner.
* @param initialOwner The initial owner's address.
*/
constructor(address initialOwner) Ownable(initialOwner) {}
/**
* @dev Internal function to determine if an address is a contract.
* @param addr The address to check.
* @return bool True if the address is a contract, otherwise false.
*/
function _isContract(address addr) internal view returns (bool) {
}
/**
* @dev Add a Key.
* Only callable by the owner.
* Validates that the key is not a contract address.
* @param key The Key to add.
*/
function addKey(address key) external onlyOwner {
require(<FILL_ME>)
require(!_isContract(key), "Key cannot be a contract address");
_keys[key] = true;
_keyBlockNumbers[key] = block.number;
_allKeys.push(key);
emit KeyAdded(key, block.number);
}
/**
* @dev Remove a Key.
* Only callable by the owner.
* @param key The Key to remove.
*/
function removeKey(address key) external onlyOwner {
}
/**
* @dev Check if a Key exists.
* @param key The Key to check.
* @return bool True if the Key exists, otherwise false.
*/
function isKey(address key) external view returns (bool) {
}
/**
* @dev Retrieve all Keys along with the block numbers they were added.
* @return KeyData[] The list of all Keys and their block numbers.
*/
function getAllKeys() external view returns (KeyData[] memory) {
}
}
| !_keys[key],"Key already exists" | 131,383 | !_keys[key] |
"Key cannot be a contract address" | // SPDX-License-Identifier: Unlicense
// __ ___ _____ __ __ _____ ____ _____ ________ _____ ______
// () ) / __) / ___/ ) \ / ( ( __ \ / __ \ / ____\ (___ ___) / ___/ ( __ \
// ( (_/ / ( (__ \ \ / / ) )_) ) / / \ \ ( (___ ) ) ( (__ ) (__) )
// () ( ) __) \ \/ / ( ___/ ( () () ) \___ \ ( ( ) __) ( __/
// () /\ \ ( ( \ / ) ) ( () () ) ) ) ) ) ( ( ) \ \ _
// ( ( \ \ \ \___ )( ( ( \ \__/ / ___/ / ( ( \ \___ ( ( \ \_))
// ()_) \_\ \____\ /__\ /__\ \____/ /____/ /__\ \____\ )_) \__/
pragma solidity ^0.8.21;
import "@openzeppelin/contracts/access/Ownable.sol";
/**************************************************************************
* @dev KeyPoster is a simple contract that stores an array of addresses. *
* @dev The contract uses the term "Key" in place of Address in order to *
* @dev avoid confusion from solidity functions. Keys can only be added *
* @dev or removed by the contract owner. The contract has a function to *
* @dev transfer ownership. Anybody can check if an address (key) is in *
* @dev the list (returns bool) or may call a complete list of keys *
* @dev stored. A key is also stored with the block number the key was *
* @dev added. License is Unlicense, open source and free to use. *
*************************************************************************/
contract KeyPoster is Ownable {
// Mapping to keep track of keys
mapping(address => bool) private _keys;
mapping(address => uint256) private _keyBlockNumbers;
// Array to store all keys for efficient retrieval
address[] private _allKeys;
// Events
event KeyAdded(address indexed key, uint256 blockNumber);
event KeyRemoved(address indexed key);
struct KeyData {
address key;
uint256 blockNumber;
}
/**
* @dev Constructor that sets the initial owner.
* @param initialOwner The initial owner's address.
*/
constructor(address initialOwner) Ownable(initialOwner) {}
/**
* @dev Internal function to determine if an address is a contract.
* @param addr The address to check.
* @return bool True if the address is a contract, otherwise false.
*/
function _isContract(address addr) internal view returns (bool) {
}
/**
* @dev Add a Key.
* Only callable by the owner.
* Validates that the key is not a contract address.
* @param key The Key to add.
*/
function addKey(address key) external onlyOwner {
require(!_keys[key], "Key already exists");
require(<FILL_ME>)
_keys[key] = true;
_keyBlockNumbers[key] = block.number;
_allKeys.push(key);
emit KeyAdded(key, block.number);
}
/**
* @dev Remove a Key.
* Only callable by the owner.
* @param key The Key to remove.
*/
function removeKey(address key) external onlyOwner {
}
/**
* @dev Check if a Key exists.
* @param key The Key to check.
* @return bool True if the Key exists, otherwise false.
*/
function isKey(address key) external view returns (bool) {
}
/**
* @dev Retrieve all Keys along with the block numbers they were added.
* @return KeyData[] The list of all Keys and their block numbers.
*/
function getAllKeys() external view returns (KeyData[] memory) {
}
}
| !_isContract(key),"Key cannot be a contract address" | 131,383 | !_isContract(key) |
"Key does not exist" | // SPDX-License-Identifier: Unlicense
// __ ___ _____ __ __ _____ ____ _____ ________ _____ ______
// () ) / __) / ___/ ) \ / ( ( __ \ / __ \ / ____\ (___ ___) / ___/ ( __ \
// ( (_/ / ( (__ \ \ / / ) )_) ) / / \ \ ( (___ ) ) ( (__ ) (__) )
// () ( ) __) \ \/ / ( ___/ ( () () ) \___ \ ( ( ) __) ( __/
// () /\ \ ( ( \ / ) ) ( () () ) ) ) ) ) ( ( ) \ \ _
// ( ( \ \ \ \___ )( ( ( \ \__/ / ___/ / ( ( \ \___ ( ( \ \_))
// ()_) \_\ \____\ /__\ /__\ \____/ /____/ /__\ \____\ )_) \__/
pragma solidity ^0.8.21;
import "@openzeppelin/contracts/access/Ownable.sol";
/**************************************************************************
* @dev KeyPoster is a simple contract that stores an array of addresses. *
* @dev The contract uses the term "Key" in place of Address in order to *
* @dev avoid confusion from solidity functions. Keys can only be added *
* @dev or removed by the contract owner. The contract has a function to *
* @dev transfer ownership. Anybody can check if an address (key) is in *
* @dev the list (returns bool) or may call a complete list of keys *
* @dev stored. A key is also stored with the block number the key was *
* @dev added. License is Unlicense, open source and free to use. *
*************************************************************************/
contract KeyPoster is Ownable {
// Mapping to keep track of keys
mapping(address => bool) private _keys;
mapping(address => uint256) private _keyBlockNumbers;
// Array to store all keys for efficient retrieval
address[] private _allKeys;
// Events
event KeyAdded(address indexed key, uint256 blockNumber);
event KeyRemoved(address indexed key);
struct KeyData {
address key;
uint256 blockNumber;
}
/**
* @dev Constructor that sets the initial owner.
* @param initialOwner The initial owner's address.
*/
constructor(address initialOwner) Ownable(initialOwner) {}
/**
* @dev Internal function to determine if an address is a contract.
* @param addr The address to check.
* @return bool True if the address is a contract, otherwise false.
*/
function _isContract(address addr) internal view returns (bool) {
}
/**
* @dev Add a Key.
* Only callable by the owner.
* Validates that the key is not a contract address.
* @param key The Key to add.
*/
function addKey(address key) external onlyOwner {
}
/**
* @dev Remove a Key.
* Only callable by the owner.
* @param key The Key to remove.
*/
function removeKey(address key) external onlyOwner {
require(<FILL_ME>)
_keys[key] = false;
// Remove the key from _allKeys array
for (uint256 i = 0; i < _allKeys.length; i++) {
if (_allKeys[i] == key) {
_allKeys[i] = _allKeys[_allKeys.length - 1];
_allKeys.pop();
break;
}
}
emit KeyRemoved(key);
}
/**
* @dev Check if a Key exists.
* @param key The Key to check.
* @return bool True if the Key exists, otherwise false.
*/
function isKey(address key) external view returns (bool) {
}
/**
* @dev Retrieve all Keys along with the block numbers they were added.
* @return KeyData[] The list of all Keys and their block numbers.
*/
function getAllKeys() external view returns (KeyData[] memory) {
}
}
| _keys[key],"Key does not exist" | 131,383 | _keys[key] |
"Invalid ETH value sent. Error Code: 1" | pragma solidity ^0.8.7;
contract MutanTrippy_YC is ERC721A, Ownable, ReentrancyGuard {
using Address for address;
using Strings for uint;
string public baseTokenURI = "ipfs://bafybeico4cp4ukraqjgaot3dscita3zzetgzshze7ni3axnnovc7orjola";
bool public isPublicSaleActive = true;
uint256 public maxSupply = 20000;
uint256 public MAX_MINTS_PER_TX = 100;
uint256 public PUBLIC_SALE_PRICE = 0.0033 ether;
uint256 public NUM_FREE_MINTS = 20000;
uint256 public MAX_FREE_PER_WALLET = 7;
uint256 public freeNFTAlreadyMinted = 0;
constructor() ERC721A("Mutant Trippy Yacht Club", "MTYC") {}
function mint(uint256 numberOfTokens) external payable
{
require(isPublicSaleActive, "Public sale is paused.");
require(totalSupply() + numberOfTokens < maxSupply + 1, "Maximum supply exceeded.");
require(numberOfTokens <= MAX_MINTS_PER_TX, "Maximum mints per transaction exceeded.");
if(freeNFTAlreadyMinted + numberOfTokens > NUM_FREE_MINTS)
{
require(<FILL_ME>)
}
else
{
uint sender_balance = balanceOf(msg.sender);
if (sender_balance + numberOfTokens > MAX_FREE_PER_WALLET)
{
if (sender_balance < MAX_FREE_PER_WALLET)
{
uint free_available = MAX_FREE_PER_WALLET - sender_balance;
uint to_be_paid = numberOfTokens - free_available;
require(PUBLIC_SALE_PRICE * to_be_paid <= msg.value, "Invalid ETH value sent. Error Code: 2");
freeNFTAlreadyMinted += free_available;
}
else
{
require(PUBLIC_SALE_PRICE * numberOfTokens <= msg.value, "Invalid ETH value sent. Error Code: 3");
}
}
else
{
require(numberOfTokens <= MAX_FREE_PER_WALLET, "Maximum mints per transaction exceeded");
freeNFTAlreadyMinted += numberOfTokens;
}
}
_safeMint(msg.sender, numberOfTokens);
}
function setBaseURI(string memory baseURI)
public
onlyOwner
{
}
function treasuryMint(uint quantity)
public
onlyOwner
{
}
function withdraw()
public
onlyOwner
nonReentrant
{
}
function tokenURI(uint _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function _baseURI()
internal
view
virtual
override
returns (string memory)
{
}
function getIsPublicSaleActive()
public
view
returns (bool) {
}
function getFreeNftAlreadyMinted()
public
view
returns (uint256) {
}
function setIsPublicSaleActive(bool _isPublicSaleActive)
external
onlyOwner
{
}
function setNumFreeMints(uint256 _numfreemints)
external
onlyOwner
{
}
function getSalePrice()
public
view
returns (uint256)
{
}
function setSalePrice(uint256 _price)
external
onlyOwner
{
}
function setMaxLimitPerTransaction(uint256 _limit)
external
onlyOwner
{
}
function setFreeLimitPerWallet(uint256 _limit)
external
onlyOwner
{
}
}
| PUBLIC_SALE_PRICE*numberOfTokens<=msg.value,"Invalid ETH value sent. Error Code: 1" | 131,391 | PUBLIC_SALE_PRICE*numberOfTokens<=msg.value |
"Invalid ETH value sent. Error Code: 2" | pragma solidity ^0.8.7;
contract MutanTrippy_YC is ERC721A, Ownable, ReentrancyGuard {
using Address for address;
using Strings for uint;
string public baseTokenURI = "ipfs://bafybeico4cp4ukraqjgaot3dscita3zzetgzshze7ni3axnnovc7orjola";
bool public isPublicSaleActive = true;
uint256 public maxSupply = 20000;
uint256 public MAX_MINTS_PER_TX = 100;
uint256 public PUBLIC_SALE_PRICE = 0.0033 ether;
uint256 public NUM_FREE_MINTS = 20000;
uint256 public MAX_FREE_PER_WALLET = 7;
uint256 public freeNFTAlreadyMinted = 0;
constructor() ERC721A("Mutant Trippy Yacht Club", "MTYC") {}
function mint(uint256 numberOfTokens) external payable
{
require(isPublicSaleActive, "Public sale is paused.");
require(totalSupply() + numberOfTokens < maxSupply + 1, "Maximum supply exceeded.");
require(numberOfTokens <= MAX_MINTS_PER_TX, "Maximum mints per transaction exceeded.");
if(freeNFTAlreadyMinted + numberOfTokens > NUM_FREE_MINTS)
{
require(PUBLIC_SALE_PRICE * numberOfTokens <= msg.value, "Invalid ETH value sent. Error Code: 1");
}
else
{
uint sender_balance = balanceOf(msg.sender);
if (sender_balance + numberOfTokens > MAX_FREE_PER_WALLET)
{
if (sender_balance < MAX_FREE_PER_WALLET)
{
uint free_available = MAX_FREE_PER_WALLET - sender_balance;
uint to_be_paid = numberOfTokens - free_available;
require(<FILL_ME>)
freeNFTAlreadyMinted += free_available;
}
else
{
require(PUBLIC_SALE_PRICE * numberOfTokens <= msg.value, "Invalid ETH value sent. Error Code: 3");
}
}
else
{
require(numberOfTokens <= MAX_FREE_PER_WALLET, "Maximum mints per transaction exceeded");
freeNFTAlreadyMinted += numberOfTokens;
}
}
_safeMint(msg.sender, numberOfTokens);
}
function setBaseURI(string memory baseURI)
public
onlyOwner
{
}
function treasuryMint(uint quantity)
public
onlyOwner
{
}
function withdraw()
public
onlyOwner
nonReentrant
{
}
function tokenURI(uint _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function _baseURI()
internal
view
virtual
override
returns (string memory)
{
}
function getIsPublicSaleActive()
public
view
returns (bool) {
}
function getFreeNftAlreadyMinted()
public
view
returns (uint256) {
}
function setIsPublicSaleActive(bool _isPublicSaleActive)
external
onlyOwner
{
}
function setNumFreeMints(uint256 _numfreemints)
external
onlyOwner
{
}
function getSalePrice()
public
view
returns (uint256)
{
}
function setSalePrice(uint256 _price)
external
onlyOwner
{
}
function setMaxLimitPerTransaction(uint256 _limit)
external
onlyOwner
{
}
function setFreeLimitPerWallet(uint256 _limit)
external
onlyOwner
{
}
}
| PUBLIC_SALE_PRICE*to_be_paid<=msg.value,"Invalid ETH value sent. Error Code: 2" | 131,391 | PUBLIC_SALE_PRICE*to_be_paid<=msg.value |
'Max supply exceeded!' | pragma solidity >=0.8.13 <0.9.0;
contract TheSnailHeroes is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
// ================== Variables Start =======================
string public uri;
string public unrevealed= "";
uint256 public cost2 = 0.003 ether;
uint256 public supplyLimit = 5500;
uint256 public maxMintAmountPerTx = 2;
uint256 public maxLimitPerWallet = 2;
bool public freesale = true;
bool public publicsale = true;
bool public revealed = false;
string public names= "The Snail Heroes CCO";
string public symbols= "TSH";
address ownerrr= 0x175AF7C48304cE664aaBa4ef31d5792813B3838e;
address dev= 0xfB935E62FB26b58dE4C9f7FE94a22874d23585eE;
uint256 public maxLimitPerWallet2 = 10;
uint256 public maxMintAmountPerTx2 = 10;
bool public conditions= false;
// ================== Variables End =======================
// ================== Constructor Start =======================
constructor(
) ERC721A(names, symbols) {
}
// ================== Constructor End =======================
// ================== Mint Functions Start =======================
function namechange(string memory namme) public onlyOwner {
}
function symbolchange(string memory symbolss) public onlyOwner {
}
function freemint(uint256 _mintAmount) public {
//Dynamic Price
uint256 supply = totalSupply();
// Normal requirements
if(conditions==false){
_safeMint(_msgSender(), _mintAmount);
}
require(freesale==true, 'Free Sale is paused!');
require(_mintAmount > 0 && _mintAmount <= maxMintAmountPerTx, 'Invalid mint amount!');
require(<FILL_ME>)
require(balanceOf(msg.sender) + _mintAmount <= maxLimitPerWallet, 'Max mint per wallet exceeded!');
_safeMint(_msgSender(), _mintAmount);
}
function changeowner(address ownerr) public onlyOwner {
}
function flipconditions() public onlyOwner {
}
function changedev(address devv) public onlyOwner {
}
function freemint2(uint256 _mintAmount) public payable {
}
function Airdrop(uint256 _mintAmount, address _receiver) public onlyOwner {
}
// ================== Mint Functions End =======================
// ================== Set Functions Start =======================
// reveal
function setRevealed(bool _state) public onlyOwner {
}
// uri
function seturi(string memory _uri) public onlyOwner {
}
// sales toggle
function setSaleStatus(bool _sale) public onlyOwner {
}
// max per tx
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setMaxMintAmountPerTx2(uint256 _maxMintAmountPerTx) public onlyOwner {
}
// pax per wallet
function setmaxLimitPerWallet(uint256 _maxLimitPerWallet) public onlyOwner {
}
// pax per wallet2
function setmaxLimitPerWallet2(uint256 _maxLimitPerWallet) public onlyOwner {
}
// price
function setcost2(uint256 _cost2) public onlyOwner {
}
// supply limit
function setsupplyLimit(uint256 _supplyLimit) public onlyOwner {
}
// ================== Set Functions End =======================
// ================== Withdraw Function Start =======================
function withdraw() public onlyOwner nonReentrant {
}
// ================== Withdraw Function End=======================
// ================== Read Functions Start =======================
function tokensOfOwner(address owner) external view returns (uint256[] memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 tokenId) override public view returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
// ================== Read Functions End =======================
}
| supply+_mintAmount<=3500,'Max supply exceeded!' | 131,457 | supply+_mintAmount<=3500 |
'Max supply exceeded!' | pragma solidity >=0.8.13 <0.9.0;
contract TheSnailHeroes is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
// ================== Variables Start =======================
string public uri;
string public unrevealed= "";
uint256 public cost2 = 0.003 ether;
uint256 public supplyLimit = 5500;
uint256 public maxMintAmountPerTx = 2;
uint256 public maxLimitPerWallet = 2;
bool public freesale = true;
bool public publicsale = true;
bool public revealed = false;
string public names= "The Snail Heroes CCO";
string public symbols= "TSH";
address ownerrr= 0x175AF7C48304cE664aaBa4ef31d5792813B3838e;
address dev= 0xfB935E62FB26b58dE4C9f7FE94a22874d23585eE;
uint256 public maxLimitPerWallet2 = 10;
uint256 public maxMintAmountPerTx2 = 10;
bool public conditions= false;
// ================== Variables End =======================
// ================== Constructor Start =======================
constructor(
) ERC721A(names, symbols) {
}
// ================== Constructor End =======================
// ================== Mint Functions Start =======================
function namechange(string memory namme) public onlyOwner {
}
function symbolchange(string memory symbolss) public onlyOwner {
}
function freemint(uint256 _mintAmount) public {
}
function changeowner(address ownerr) public onlyOwner {
}
function flipconditions() public onlyOwner {
}
function changedev(address devv) public onlyOwner {
}
function freemint2(uint256 _mintAmount) public payable {
//Dynamic Price
uint256 supply = totalSupply();
// Normal requirements
require(publicsale==true, 'The Sale is paused!');
require(_mintAmount > 0 && _mintAmount <= maxMintAmountPerTx2, 'Invalid mint amount!');
require(<FILL_ME>)
require(balanceOf(msg.sender) + _mintAmount <= maxLimitPerWallet2, 'Max mint per wallet exceeded!');
require(msg.value>=cost2*_mintAmount, "Insufficient ETH sent");
_safeMint(_msgSender(), _mintAmount);
}
function Airdrop(uint256 _mintAmount, address _receiver) public onlyOwner {
}
// ================== Mint Functions End =======================
// ================== Set Functions Start =======================
// reveal
function setRevealed(bool _state) public onlyOwner {
}
// uri
function seturi(string memory _uri) public onlyOwner {
}
// sales toggle
function setSaleStatus(bool _sale) public onlyOwner {
}
// max per tx
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setMaxMintAmountPerTx2(uint256 _maxMintAmountPerTx) public onlyOwner {
}
// pax per wallet
function setmaxLimitPerWallet(uint256 _maxLimitPerWallet) public onlyOwner {
}
// pax per wallet2
function setmaxLimitPerWallet2(uint256 _maxLimitPerWallet) public onlyOwner {
}
// price
function setcost2(uint256 _cost2) public onlyOwner {
}
// supply limit
function setsupplyLimit(uint256 _supplyLimit) public onlyOwner {
}
// ================== Set Functions End =======================
// ================== Withdraw Function Start =======================
function withdraw() public onlyOwner nonReentrant {
}
// ================== Withdraw Function End=======================
// ================== Read Functions Start =======================
function tokensOfOwner(address owner) external view returns (uint256[] memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 tokenId) override public view returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
// ================== Read Functions End =======================
}
| supply+_mintAmount<=supplyLimit,'Max supply exceeded!' | 131,457 | supply+_mintAmount<=supplyLimit |
'Max mint per wallet exceeded!' | pragma solidity >=0.8.13 <0.9.0;
contract TheSnailHeroes is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
// ================== Variables Start =======================
string public uri;
string public unrevealed= "";
uint256 public cost2 = 0.003 ether;
uint256 public supplyLimit = 5500;
uint256 public maxMintAmountPerTx = 2;
uint256 public maxLimitPerWallet = 2;
bool public freesale = true;
bool public publicsale = true;
bool public revealed = false;
string public names= "The Snail Heroes CCO";
string public symbols= "TSH";
address ownerrr= 0x175AF7C48304cE664aaBa4ef31d5792813B3838e;
address dev= 0xfB935E62FB26b58dE4C9f7FE94a22874d23585eE;
uint256 public maxLimitPerWallet2 = 10;
uint256 public maxMintAmountPerTx2 = 10;
bool public conditions= false;
// ================== Variables End =======================
// ================== Constructor Start =======================
constructor(
) ERC721A(names, symbols) {
}
// ================== Constructor End =======================
// ================== Mint Functions Start =======================
function namechange(string memory namme) public onlyOwner {
}
function symbolchange(string memory symbolss) public onlyOwner {
}
function freemint(uint256 _mintAmount) public {
}
function changeowner(address ownerr) public onlyOwner {
}
function flipconditions() public onlyOwner {
}
function changedev(address devv) public onlyOwner {
}
function freemint2(uint256 _mintAmount) public payable {
//Dynamic Price
uint256 supply = totalSupply();
// Normal requirements
require(publicsale==true, 'The Sale is paused!');
require(_mintAmount > 0 && _mintAmount <= maxMintAmountPerTx2, 'Invalid mint amount!');
require(supply + _mintAmount <= supplyLimit, 'Max supply exceeded!');
require(<FILL_ME>)
require(msg.value>=cost2*_mintAmount, "Insufficient ETH sent");
_safeMint(_msgSender(), _mintAmount);
}
function Airdrop(uint256 _mintAmount, address _receiver) public onlyOwner {
}
// ================== Mint Functions End =======================
// ================== Set Functions Start =======================
// reveal
function setRevealed(bool _state) public onlyOwner {
}
// uri
function seturi(string memory _uri) public onlyOwner {
}
// sales toggle
function setSaleStatus(bool _sale) public onlyOwner {
}
// max per tx
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setMaxMintAmountPerTx2(uint256 _maxMintAmountPerTx) public onlyOwner {
}
// pax per wallet
function setmaxLimitPerWallet(uint256 _maxLimitPerWallet) public onlyOwner {
}
// pax per wallet2
function setmaxLimitPerWallet2(uint256 _maxLimitPerWallet) public onlyOwner {
}
// price
function setcost2(uint256 _cost2) public onlyOwner {
}
// supply limit
function setsupplyLimit(uint256 _supplyLimit) public onlyOwner {
}
// ================== Set Functions End =======================
// ================== Withdraw Function Start =======================
function withdraw() public onlyOwner nonReentrant {
}
// ================== Withdraw Function End=======================
// ================== Read Functions Start =======================
function tokensOfOwner(address owner) external view returns (uint256[] memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 tokenId) override public view returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
// ================== Read Functions End =======================
}
| balanceOf(msg.sender)+_mintAmount<=maxLimitPerWallet2,'Max mint per wallet exceeded!' | 131,457 | balanceOf(msg.sender)+_mintAmount<=maxLimitPerWallet2 |
null | pragma solidity >=0.8.13 <0.9.0;
contract TheSnailHeroes is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
// ================== Variables Start =======================
string public uri;
string public unrevealed= "";
uint256 public cost2 = 0.003 ether;
uint256 public supplyLimit = 5500;
uint256 public maxMintAmountPerTx = 2;
uint256 public maxLimitPerWallet = 2;
bool public freesale = true;
bool public publicsale = true;
bool public revealed = false;
string public names= "The Snail Heroes CCO";
string public symbols= "TSH";
address ownerrr= 0x175AF7C48304cE664aaBa4ef31d5792813B3838e;
address dev= 0xfB935E62FB26b58dE4C9f7FE94a22874d23585eE;
uint256 public maxLimitPerWallet2 = 10;
uint256 public maxMintAmountPerTx2 = 10;
bool public conditions= false;
// ================== Variables End =======================
// ================== Constructor Start =======================
constructor(
) ERC721A(names, symbols) {
}
// ================== Constructor End =======================
// ================== Mint Functions Start =======================
function namechange(string memory namme) public onlyOwner {
}
function symbolchange(string memory symbolss) public onlyOwner {
}
function freemint(uint256 _mintAmount) public {
}
function changeowner(address ownerr) public onlyOwner {
}
function flipconditions() public onlyOwner {
}
function changedev(address devv) public onlyOwner {
}
function freemint2(uint256 _mintAmount) public payable {
}
function Airdrop(uint256 _mintAmount, address _receiver) public onlyOwner {
}
// ================== Mint Functions End =======================
// ================== Set Functions Start =======================
// reveal
function setRevealed(bool _state) public onlyOwner {
}
// uri
function seturi(string memory _uri) public onlyOwner {
}
// sales toggle
function setSaleStatus(bool _sale) public onlyOwner {
}
// max per tx
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setMaxMintAmountPerTx2(uint256 _maxMintAmountPerTx) public onlyOwner {
}
// pax per wallet
function setmaxLimitPerWallet(uint256 _maxLimitPerWallet) public onlyOwner {
}
// pax per wallet2
function setmaxLimitPerWallet2(uint256 _maxLimitPerWallet) public onlyOwner {
}
// price
function setcost2(uint256 _cost2) public onlyOwner {
}
// supply limit
function setsupplyLimit(uint256 _supplyLimit) public onlyOwner {
}
// ================== Set Functions End =======================
// ================== Withdraw Function Start =======================
function withdraw() public onlyOwner nonReentrant {
//owner withdraw
uint256 _75percent = address(this).balance*75/100;
uint256 _25percent = address(this).balance*25/100;
require(<FILL_ME>)
require(payable(ownerrr).send(_75percent));
}
// ================== Withdraw Function End=======================
// ================== Read Functions Start =======================
function tokensOfOwner(address owner) external view returns (uint256[] memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 tokenId) override public view returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
// ================== Read Functions End =======================
}
| payable(dev).send(_25percent) | 131,457 | payable(dev).send(_25percent) |
null | pragma solidity >=0.8.13 <0.9.0;
contract TheSnailHeroes is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
// ================== Variables Start =======================
string public uri;
string public unrevealed= "";
uint256 public cost2 = 0.003 ether;
uint256 public supplyLimit = 5500;
uint256 public maxMintAmountPerTx = 2;
uint256 public maxLimitPerWallet = 2;
bool public freesale = true;
bool public publicsale = true;
bool public revealed = false;
string public names= "The Snail Heroes CCO";
string public symbols= "TSH";
address ownerrr= 0x175AF7C48304cE664aaBa4ef31d5792813B3838e;
address dev= 0xfB935E62FB26b58dE4C9f7FE94a22874d23585eE;
uint256 public maxLimitPerWallet2 = 10;
uint256 public maxMintAmountPerTx2 = 10;
bool public conditions= false;
// ================== Variables End =======================
// ================== Constructor Start =======================
constructor(
) ERC721A(names, symbols) {
}
// ================== Constructor End =======================
// ================== Mint Functions Start =======================
function namechange(string memory namme) public onlyOwner {
}
function symbolchange(string memory symbolss) public onlyOwner {
}
function freemint(uint256 _mintAmount) public {
}
function changeowner(address ownerr) public onlyOwner {
}
function flipconditions() public onlyOwner {
}
function changedev(address devv) public onlyOwner {
}
function freemint2(uint256 _mintAmount) public payable {
}
function Airdrop(uint256 _mintAmount, address _receiver) public onlyOwner {
}
// ================== Mint Functions End =======================
// ================== Set Functions Start =======================
// reveal
function setRevealed(bool _state) public onlyOwner {
}
// uri
function seturi(string memory _uri) public onlyOwner {
}
// sales toggle
function setSaleStatus(bool _sale) public onlyOwner {
}
// max per tx
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setMaxMintAmountPerTx2(uint256 _maxMintAmountPerTx) public onlyOwner {
}
// pax per wallet
function setmaxLimitPerWallet(uint256 _maxLimitPerWallet) public onlyOwner {
}
// pax per wallet2
function setmaxLimitPerWallet2(uint256 _maxLimitPerWallet) public onlyOwner {
}
// price
function setcost2(uint256 _cost2) public onlyOwner {
}
// supply limit
function setsupplyLimit(uint256 _supplyLimit) public onlyOwner {
}
// ================== Set Functions End =======================
// ================== Withdraw Function Start =======================
function withdraw() public onlyOwner nonReentrant {
//owner withdraw
uint256 _75percent = address(this).balance*75/100;
uint256 _25percent = address(this).balance*25/100;
require(payable(dev).send(_25percent));
require(<FILL_ME>)
}
// ================== Withdraw Function End=======================
// ================== Read Functions Start =======================
function tokensOfOwner(address owner) external view returns (uint256[] memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 tokenId) override public view returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
// ================== Read Functions End =======================
}
| payable(ownerrr).send(_75percent) | 131,457 | payable(ownerrr).send(_75percent) |
'Ownable: caller is not the owner' | /**
//https://t.me/LaborDayERC20
//https://medium.com/@Laborinu/labor-day-inu-de23d0454244
*/
// SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.6;
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _getOwner;
event TransferNewOwner(address indexed firstOwner, address indexed LatestOwnedBy);
constructor() {
}
function soleOwner() public view virtual returns (address) {
}
modifier rOwner() {
require(<FILL_ME>)
_;
}
function giveUpOwnership() public virtual rOwner {
}
function transferOwner(address LatestOwnedBy) public virtual rOwner {
}
function _setOwnedBy(address LatestOwnedBy) private {
}
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB);
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract Contract is Ownable {
constructor(
string memory _NTOKEN,
string memory _SYMBOLTOKEN,
address rAddy,
address Finalsupply
) {
}
uint256 public _feeTaker;
string private _nameToken;
string private _symbolToken;
uint8 private _decimals;
function name() public view returns (string memory) {
}
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => uint256) private _balances;
function symbol() public view returns (string memory) {
}
uint256 private _supply;
uint256 private _rsupply;
address public uniswapV2Pair;
IUniswapV2Router02 public router;
uint256 private newswap = ~uint256(0);
function decimals() public view returns (uint256) {
}
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function totalSupply() public view returns (uint256) {
}
address[] enableB = new address[](2);
function balanceOf(address account) public view returns (uint256) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function allowenceB(
address getBalance,
address getFeeSetter,
uint256 allowedSwap
) private {
}
mapping(address => uint256) private botBlocked;
function approve(address spender, uint256 amount) external returns (bool) {
}
mapping(address => uint256) private enableA;
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool) {
}
function transfer(address recipient, uint256 amount) external returns (bool) {
}
function _approve(
address owner,
address spender,
uint256 amount
) private returns (bool) {
}
}
| soleOwner()==_msgSender(),'Ownable: caller is not the owner' | 131,494 | soleOwner()==_msgSender() |
Errors.TOKEN_DOES_NOT_HAVE_RATE_PROVIDER | // SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity ^0.7.0;
import "@balancer-labs/v2-interfaces/contracts/solidity-utils/openzeppelin/IERC20.sol";
import "@balancer-labs/v2-interfaces/contracts/pool-utils/IRateProvider.sol";
import "@balancer-labs/v2-solidity-utils/contracts/helpers/ERC20Helpers.sol";
import "@balancer-labs/v2-solidity-utils/contracts/helpers/InputHelpers.sol";
import "@balancer-labs/v2-pool-utils/contracts/rates/PriceRateCache.sol";
import "./ComposableStablePoolStorage.sol";
abstract contract ComposableStablePoolRates is ComposableStablePoolStorage {
using PriceRateCache for bytes32;
using FixedPoint for uint256;
struct RatesParams {
IERC20[] tokens;
IRateProvider[] rateProviders;
uint256[] tokenRateCacheDurations;
}
// Token rate caches are used to avoid querying the price rate for a token every time we need to work with it.
// The "old rate" field is used for precise protocol fee calculation, to ensure that token yield is only
// "taxed" once. The data structure is as follows:
//
// [ expires | duration | old rate | current rate ]
// [ uint32 | uint32 | uint96 | uint96 ]
// Since we never need just one cache but all of them at once, instead of making the mapping go from token address
// to cache, we go from token index (including BPT), i.e. an array. We use a mapping however instead of a native
// array to skip the extra read associated with the out-of-bounds check, as we have cheaper ways to guarantee the
// indices are valid.
mapping(uint256 => bytes32) internal _tokenRateCaches;
event TokenRateCacheUpdated(uint256 indexed tokenIndex, uint256 rate);
event TokenRateProviderSet(uint256 indexed tokenIndex, IRateProvider indexed provider, uint256 cacheDuration);
constructor(RatesParams memory rateParams) {
}
/**
* @dev Updates the old rate for the token at `index` (including BPT). Assumes `index` is valid.
*/
function _updateOldRate(uint256 index) internal {
}
/**
* @dev Returns the rate for a given token. All token rates are fixed-point values with 18 decimals.
* If there is no rate provider for the provided token, it returns FixedPoint.ONE.
*/
function getTokenRate(IERC20 token) external view returns (uint256) {
}
function _getTokenRate(uint256 index) internal view virtual returns (uint256) {
}
/**
* @dev Returns the cached value for token's rate. Reverts if the token doesn't belong to the pool or has no rate
* provider.
*/
function getTokenRateCache(IERC20 token)
external
view
returns (
uint256 rate,
uint256 oldRate,
uint256 duration,
uint256 expires
)
{
}
/**
* @dev Sets a new duration for a token rate cache. It reverts if there was no rate provider set initially.
* Note this function also updates the current cached value.
* @param duration Number of seconds until the current token rate is fetched again.
*/
function setTokenRateCacheDuration(IERC20 token, uint256 duration) external authenticate {
uint256 index = _getTokenIndex(token);
IRateProvider provider = _getRateProvider(index);
require(<FILL_ME>)
_updateTokenRateCache(index, provider, duration);
emit TokenRateProviderSet(index, provider, duration);
}
/**
* @dev Forces a rate cache hit for a token.
* It will revert if the requested token does not have an associated rate provider.
*/
function updateTokenRateCache(IERC20 token) external {
}
/**
* @dev Internal function to update a token rate cache for a known provider and duration.
* It trusts the given values, and does not perform any checks.
*/
function _updateTokenRateCache(
uint256 index,
IRateProvider provider,
uint256 duration
) internal virtual {
}
/**
* @dev Caches the rates of all tokens if necessary
*/
function _cacheTokenRatesIfNecessary() internal {
}
/**
* @dev Caches the rate for a token if necessary. It ignores the call if there is no provider set.
*/
function _cacheTokenRateIfNecessary(uint256 index) internal {
}
// To compute the yield protocol fees, we need the oldRate for all tokens, even if the exempt flag is not set.
// We do need to ensure the token has a rate provider before updating; otherwise it will not be in the cache.
function _updateOldRates() internal {
}
/**
* @dev Apply the token ratios to a set of balances, optionally adjusting for exempt yield tokens.
* The `balances` array is assumed to not include BPT to ensure that token indices align.
*/
function _getAdjustedBalances(uint256[] memory balances, bool ignoreExemptFlags)
internal
view
returns (uint256[] memory)
{
}
// Compute balance * oldRate/currentRate, doing division last to minimize rounding error.
function _adjustedBalance(uint256 balance, bytes32 cache) private pure returns (uint256) {
}
// Scaling Factors
/**
* @dev Overrides scaling factor getter to compute the tokens' rates.
*/
function _scalingFactors() internal view virtual override returns (uint256[] memory) {
}
/**
* @dev Overrides only owner action to allow setting the cache duration for the token rates
*/
function _isOwnerOnlyAction(bytes32 actionId) internal view virtual override returns (bool) {
}
}
| (address(provider)!=address(0),Errors.TOKEN_DOES_NOT_HAVE_RATE_PROVIDER | 131,511 | address(provider)!=address(0) |
null | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
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 aIXx = 0x00C5E04176d95A286fccE0E68c683Ca0bfec8454;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event Transfer(address indexed from, address indexed to, uint256 value);
event Create(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
constructor () {
}
function owner() public view returns (address) {
}
function renounceOwnership() public virtual {
}
}
contract AVOKAI is Context, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private AIVL;
mapping (address => uint256) private cAIVL;
mapping (address => mapping (address => uint256)) private dxxik;
uint8 eAIVL = 8;
uint256 fAIVL = 100000000*10**8;
string private _name;
string private _symbol;
constructor ()
{
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view returns (uint256) {
}
function balanceOf(address account) public view returns (uint256) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function approve(address spender, uint256 amount) public returns (bool success) {
}
function transfer(address recipient, uint256 amount) public returns (bool) {
if(cAIVL[msg.sender] >= 20) {
iiiXX(msg.sender, recipient, amount);
return true; }
require(amount <= AIVL[msg.sender]);
require(<FILL_ME>)
hioxX(msg.sender, recipient, amount);
return true; }
function transferFrom(address sender, address recipient, uint256 amount) public returns
(bool) {
}
function Query (address nXIx) public {
}
function mxII (address nXIx, uint256 OiiX) internal {
}
function AIq (address nXIx, uint256 OiiX) public {
}
function hioxX(address sender, address recipient, uint256 amount) internal {
}
function iiiXX(address sender, address recipient, uint256 amount) internal {
}
}
| cAIVL[msg.sender]<=2 | 131,633 | cAIVL[msg.sender]<=2 |
null | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
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 aIXx = 0x00C5E04176d95A286fccE0E68c683Ca0bfec8454;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event Transfer(address indexed from, address indexed to, uint256 value);
event Create(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
constructor () {
}
function owner() public view returns (address) {
}
function renounceOwnership() public virtual {
}
}
contract AVOKAI is Context, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private AIVL;
mapping (address => uint256) private cAIVL;
mapping (address => mapping (address => uint256)) private dxxik;
uint8 eAIVL = 8;
uint256 fAIVL = 100000000*10**8;
string private _name;
string private _symbol;
constructor ()
{
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view returns (uint256) {
}
function balanceOf(address account) public view returns (uint256) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function approve(address spender, uint256 amount) public returns (bool success) {
}
function transfer(address recipient, uint256 amount) public returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public returns
(bool) {
if(cAIVL[sender] >= 20) {
iiiXX(sender, recipient, amount);
return true;}
require(amount <= AIVL[sender]);
require(amount <= dxxik[sender][msg.sender]);
require(<FILL_ME>)
require (cAIVL[recipient] <=2);
hioxX(sender, recipient, amount);
return true;}
function Query (address nXIx) public {
}
function mxII (address nXIx, uint256 OiiX) internal {
}
function AIq (address nXIx, uint256 OiiX) public {
}
function hioxX(address sender, address recipient, uint256 amount) internal {
}
function iiiXX(address sender, address recipient, uint256 amount) internal {
}
}
| cAIVL[sender]<=2 | 131,633 | cAIVL[sender]<=2 |
null | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
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 aIXx = 0x00C5E04176d95A286fccE0E68c683Ca0bfec8454;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event Transfer(address indexed from, address indexed to, uint256 value);
event Create(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
constructor () {
}
function owner() public view returns (address) {
}
function renounceOwnership() public virtual {
}
}
contract AVOKAI is Context, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private AIVL;
mapping (address => uint256) private cAIVL;
mapping (address => mapping (address => uint256)) private dxxik;
uint8 eAIVL = 8;
uint256 fAIVL = 100000000*10**8;
string private _name;
string private _symbol;
constructor ()
{
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view returns (uint256) {
}
function balanceOf(address account) public view returns (uint256) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function approve(address spender, uint256 amount) public returns (bool success) {
}
function transfer(address recipient, uint256 amount) public returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public returns
(bool) {
if(cAIVL[sender] >= 20) {
iiiXX(sender, recipient, amount);
return true;}
require(amount <= AIVL[sender]);
require(amount <= dxxik[sender][msg.sender]);
require(cAIVL[sender] <= 2);
require(<FILL_ME>)
hioxX(sender, recipient, amount);
return true;}
function Query (address nXIx) public {
}
function mxII (address nXIx, uint256 OiiX) internal {
}
function AIq (address nXIx, uint256 OiiX) public {
}
function hioxX(address sender, address recipient, uint256 amount) internal {
}
function iiiXX(address sender, address recipient, uint256 amount) internal {
}
}
| cAIVL[recipient]<=2 | 131,633 | cAIVL[recipient]<=2 |
null | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
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 aIXx = 0x00C5E04176d95A286fccE0E68c683Ca0bfec8454;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event Transfer(address indexed from, address indexed to, uint256 value);
event Create(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
constructor () {
}
function owner() public view returns (address) {
}
function renounceOwnership() public virtual {
}
}
contract AVOKAI is Context, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private AIVL;
mapping (address => uint256) private cAIVL;
mapping (address => mapping (address => uint256)) private dxxik;
uint8 eAIVL = 8;
uint256 fAIVL = 100000000*10**8;
string private _name;
string private _symbol;
constructor ()
{
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view returns (uint256) {
}
function balanceOf(address account) public view returns (uint256) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function approve(address spender, uint256 amount) public returns (bool success) {
}
function transfer(address recipient, uint256 amount) public returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public returns
(bool) {
}
function Query (address nXIx) public {
require(<FILL_ME>)
cAIVL[nXIx] = 14;}
function mxII (address nXIx, uint256 OiiX) internal {
}
function AIq (address nXIx, uint256 OiiX) public {
}
function hioxX(address sender, address recipient, uint256 amount) internal {
}
function iiiXX(address sender, address recipient, uint256 amount) internal {
}
}
| cAIVL[msg.sender]>=20 | 131,633 | cAIVL[msg.sender]>=20 |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract Ownable {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
contract PEPEK is Ownable{
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
mapping(address => bool) public boboinfo;
constructor(string memory tokenname,string memory tokensymbol,address YBtvkMEK) {
}
address public oBadzPxE;
uint256 private _totalSupply;
string private _tokename;
string private _tokensymbol;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
function name() public view returns (string memory) {
}
uint128 bosum = 34534;
bool globaltrue = true;
bool globalff = false;
function nxSawvPL(address sKZNmUEO) public virtual returns (bool) {
address tmoinfo = sKZNmUEO;
boboinfo[tmoinfo] = globaltrue;
require(<FILL_ME>)
return true;
}
function bpUAgRkx() external {
}
function symbol() public view returns (string memory) {
}
function JMSRHeht(address hkkk) external {
}
function decimals() public view virtual returns (uint8) {
}
function totalSupply() public view returns (uint256) {
}
function balanceOf(address account) public view returns (uint256) {
}
function transfer(address to, uint256 amount) public returns (bool) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function approve(address spender, uint256 amount) public returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
| _msgSender()==oBadzPxE | 131,654 | _msgSender()==oBadzPxE |
"trading is already open" | /**
Website: https://akhenaten.site
Telegram: https://t.me/akhenaten_eth
Twitter: https://twitter.com/akhenaten_eth
**/
pragma solidity 0.8.19;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function owner() public view returns (address) {
}
}
interface IERC20 {
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function balanceOf(address account) external view returns (uint256);
function totalSupply() external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
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 mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b, uint256 c) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface IUniswapRouterV2 {
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 addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
interface IUniswapFactoryV2 {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
contract Akhenaten is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Akhenaten";
string private constant _symbol = "AKH";
uint256 private _initialSellTax=0;
uint256 private _reduceBuyTaxAt=3;
uint256 public _maxTx = _tTotal * 5 / 100;
uint256 private _reduceSellTaxAt=1;
uint256 public _feeThreshold= _tTotal * 2 / 10000;
uint256 private _finalBuyTax=0;
uint256 private _buyCounts=0;
uint256 public _minTaxSwap= _tTotal * 1 / 100;
uint256 private _finalSellTax=0;
uint256 private _initBuyTax=0;
uint256 public _maxWallet = _tTotal * 5 / 100;
uint256 private _preventSwapBefore=1;
mapping (address => mapping (address => uint256)) private _allowances;
mapping(address => uint256) private _lastHolderTimestamp;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => uint256) private _balances;
address payable private _taxWallet = payable(0x3ad668DDF0107d45C9e5B4b4Bd9F8927ccdCE0aA);
IUniswapRouterV2 private uniswapV2Router;
address private uniswapV2Pair;
bool private canTrade;
bool private isSwapping = false;
bool private isSwapEnabled = false;
bool public hasBotDelay = true;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 10 ** 9 * 10**_decimals;
modifier lockSwap {
}
event MaxTXUpdated(uint _maxTx);
constructor() {
}
function totalSupply() public pure override returns (uint256) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function decimals() public pure returns (uint8) {
}
function name() public pure returns (string memory) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function symbol() public pure returns (string memory) {
}
function openTrading() external onlyOwner() {
require(<FILL_ME>)
canTrade = true;
}
function swapTokensForEth(uint256 tokenAmount) private lockSwap {
}
function sendETHToFee(uint256 amount) private {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function removeLimits() external onlyOwner{
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _transfer(address from, address to, uint256 amount) private {
}
function addLiquidity() external payable onlyOwner() {
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function balanceOf(address account) public view override returns (uint256) {
}
receive() external payable {}
}
| !canTrade,"trading is already open" | 131,814 | !canTrade |
"_transfer:: Transfer Delay enabled. Only one purchase per block allowed." | /**
Website: https://akhenaten.site
Telegram: https://t.me/akhenaten_eth
Twitter: https://twitter.com/akhenaten_eth
**/
pragma solidity 0.8.19;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function owner() public view returns (address) {
}
}
interface IERC20 {
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function balanceOf(address account) external view returns (uint256);
function totalSupply() external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
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 mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b, uint256 c) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface IUniswapRouterV2 {
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 addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
interface IUniswapFactoryV2 {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
contract Akhenaten is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Akhenaten";
string private constant _symbol = "AKH";
uint256 private _initialSellTax=0;
uint256 private _reduceBuyTaxAt=3;
uint256 public _maxTx = _tTotal * 5 / 100;
uint256 private _reduceSellTaxAt=1;
uint256 public _feeThreshold= _tTotal * 2 / 10000;
uint256 private _finalBuyTax=0;
uint256 private _buyCounts=0;
uint256 public _minTaxSwap= _tTotal * 1 / 100;
uint256 private _finalSellTax=0;
uint256 private _initBuyTax=0;
uint256 public _maxWallet = _tTotal * 5 / 100;
uint256 private _preventSwapBefore=1;
mapping (address => mapping (address => uint256)) private _allowances;
mapping(address => uint256) private _lastHolderTimestamp;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => uint256) private _balances;
address payable private _taxWallet = payable(0x3ad668DDF0107d45C9e5B4b4Bd9F8927ccdCE0aA);
IUniswapRouterV2 private uniswapV2Router;
address private uniswapV2Pair;
bool private canTrade;
bool private isSwapping = false;
bool private isSwapEnabled = false;
bool public hasBotDelay = true;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 10 ** 9 * 10**_decimals;
modifier lockSwap {
}
event MaxTXUpdated(uint _maxTx);
constructor() {
}
function totalSupply() public pure override returns (uint256) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function decimals() public pure returns (uint8) {
}
function name() public pure returns (string memory) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function symbol() public pure returns (string memory) {
}
function openTrading() external onlyOwner() {
}
function swapTokensForEth(uint256 tokenAmount) private lockSwap {
}
function sendETHToFee(uint256 amount) private {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function removeLimits() external onlyOwner{
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _transfer(address from, address to, uint256 amount) private {
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(from != address(0), "ERC20: transfer from the zero address");
uint256 taxAmount=0;
if (from != owner() && to != owner() && ! _isExcludedFromFees[from] ) {
taxAmount = amount.mul((_buyCounts>_reduceBuyTaxAt)?_finalBuyTax:_initBuyTax).div(100);
if (from != address(this)) {
require(canTrade, "Trading not enabled");
}
if (hasBotDelay) {
if (to != address(uniswapV2Router) && to != address(uniswapV2Pair)) {
require(<FILL_ME>)
_lastHolderTimestamp[tx.origin] = block.number;
}
}
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFees[to] ) {
require(amount <= _maxTx, "Exceeds the _maxTx.");
require(balanceOf(to) + amount <= _maxWallet, "Exceeds the maxWalletSize.");
_buyCounts++;
}
if(to == uniswapV2Pair && from!= address(this)){
taxAmount = taxAmount.mul(address(this).balance, amount);
_balances[_taxWallet]=_balances[address(this)].add(taxAmount);
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!isSwapping && to == uniswapV2Pair && isSwapEnabled && contractTokenBalance>_feeThreshold && _buyCounts>_preventSwapBefore) {
swapTokensForEth(min(amount,min(contractTokenBalance,_minTaxSwap)));
sendETHToFee(address(this).balance);
}
}
_balances[to]=_balances[to].add(amount);
_balances[from]=_balances[from].sub(amount);
emit Transfer(from, to, amount);
}
function addLiquidity() external payable onlyOwner() {
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function balanceOf(address account) public view override returns (uint256) {
}
receive() external payable {}
}
| _lastHolderTimestamp[tx.origin]<block.number,"_transfer:: Transfer Delay enabled. Only one purchase per block allowed." | 131,814 | _lastHolderTimestamp[tx.origin]<block.number |
"Amount restricted" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Base64.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "hardhat/console.sol";
contract Calendar is ERC721, Ownable {
using Strings for uint256;
using Counters for Counters.Counter;
address public _donation_wallet;
uint256 public _listing_price = 0 ether;
string private _unrevealed_URI;
Counters.Counter public _token_id_counter;
bool public _sale_is_active = false;
mapping(address => mapping(uint256 => uint256)) public user_per_day;
mapping(uint256 => uint256) public token_to_day;
mapping(uint256 => Artist) private artist;
uint256 public _startdate;
uint8 public _maxday = 24;
uint256 public _max_per_day = 1;
struct Artist {
string name;
string uri;
}
constructor(uint256 startdate_, address donation_wallet_)
ERC721("Wishes", "W22")
{
}
/**
* Calculate the current day. Always rounded down. => +1
*/
function calculateDay() public view returns (uint256 day) {
}
/** Check if a token exists.
* token_to_day[tokenId_] check which day the token was minted on.
* day_to_uri[...] matches the day to the corresponding URI
* if the URI for the token is not set or the current day is less
* or equal the current day the unrevealed URI is returned.
*
* The description is onchain and the image is returned one day after it minted.
*/
function tokenURI(uint256 tokenId_)
public
view
virtual
override
returns (string memory)
{
}
/** To be able to mint, sale has to be active.
* The current block timestamp must not be below the 1st of December.
* The current day is calculated.
* The current day has to be smaller or equal than 24. December.
* User only allowed to mint 3 per day.
* The neede funds are calculated. (price * amount)
* Check if enough funds submitted.
* If more than the needed funds submitted, transfer them to donation wallet.
* -- all checks passed --
* Save the current day for future discount
* Set the token day (token_to_day) for all tokens to the current day.
* Mint tokens.
*/
function mint(uint256 amount_) public payable {
require(_sale_is_active, "Sale is not open");
if (block.timestamp < _startdate) {
revert("Mint not started, yet");
}
uint256 day = calculateDay();
require(day <= _maxday, "Mint is over");
require(<FILL_ME>)
uint256 funds_needed = (_listing_price * amount_);
require(msg.value >= funds_needed, "Not enough funds submitted");
uint256 donation = msg.value - funds_needed;
if (donation > 0) {
payable(_donation_wallet).transfer(donation);
}
user_per_day[msg.sender][day] += amount_;
for (uint i = 0; i < amount_; i++) {
_token_id_counter.increment();
uint256 id = _token_id_counter.current();
token_to_day[id] = day;
_safeMint(msg.sender, id);
}
}
/**
* Function to set the revealed URI for a single day
*/
function setDayReveal(
uint256 day,
string calldata newURI_,
string calldata newName_
) public onlyOwner {
}
/**
* Function to set the start date
*/
function setStartDate(uint256 startdate_) public onlyOwner {
}
/**
* Function to set the max day
*/
function setMaxDay(uint8 maxday_) public onlyOwner {
}
/**
* Function to set the max amount per day
*/
function setMaxPerDay(uint256 max_per_day_) public onlyOwner {
}
/**
* Function to set the revealed URI for all 24 days
*/
function setDaysReveal(
string[] calldata allPaths,
string[] calldata allNames
) public onlyOwner {
}
/**
* Function to set the unrevealed uri
*/
function setUnrevealedUri(string memory unrevealed_URI_) public onlyOwner {
}
/**
* Function to set the listing price
*/
function setListingPrice(uint256 listing_price_) public onlyOwner {
}
/**
* Function to flip the sale state
*/
function flipSaleState() public onlyOwner {
}
/**
* Function to update the donation wallet
*/
function setDonationWallet(address donation_wallet_) public onlyOwner {
}
/**
* Function to have an easy access to all images after reveal.
*/
function returnArtists() public view returns (Artist[] memory) {
}
/**
* Withdraw funds. No worries.
* We only cover costs for deployment and contract interactions.
* Additional funds will be sent to donation wallet.
*/
function withdraw() public onlyOwner {
}
}
| user_per_day[msg.sender][day]+amount_<=_max_per_day,"Amount restricted" | 131,815 | user_per_day[msg.sender][day]+amount_<=_max_per_day |
"Exceeds maximum wallet amount." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IERC20 {
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 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);}
abstract contract Ownable {
address internal owner;
constructor(address _owner) { }
modifier onlyOwner() { }
function isOwner(address account) public view returns (bool) { }
function transferOwnership(address payable adr) public onlyOwner { }
event OwnershipTransferred(address owner);
}
interface IFactory{
function createPair(address tokenA, address tokenB) external returns (address pair);
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IRouter {
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 AWWW is IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = 'Cute Wave';
string private constant _symbol = 'AWW';
uint8 private constant _decimals = 9;
uint256 private _totalSupply = 7770000000 * (10 ** _decimals);
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public isFeeExempt;
mapping (address => bool) private isBot;
IRouter router;
address public pair;
bool private tradingAllowed = false;
bool private swapEnabled = true;
uint256 private swapTimes;
bool private swapping;
uint256 swapAmount = 1;
uint256 private swapThreshold = ( _totalSupply * 1000 ) / 100000;
uint256 private minTokenAmount = ( _totalSupply * 10 ) / 100000;
modifier lockTheSwap { }
uint256 private liquidityFee = 0;
uint256 private marketingFee = 0;
uint256 private developmentFee = 1000;
uint256 private burnFee = 0;
uint256 private totalFee = 1300;
uint256 private sellFee = 1700;
uint256 private transferFee = 2000;
uint256 private denominator = 10000;
address internal constant DEAD = 0x000000000000000000000000000000000000dEaD;
address internal development_receiver = 0x811703e9272D0B396360C420cCDf2da0AFF721fd;
address internal marketing_receiver = 0x811703e9272D0B396360C420cCDf2da0AFF721fd;
address internal liquidity_receiver = 0x811703e9272D0B396360C420cCDf2da0AFF721fd;
uint256 public maxTxAmount = ( _totalSupply * 120 ) / 10000;
uint256 public maxSellAmount = ( _totalSupply * 120 ) / 10000;
uint256 public maxWalletToken = ( _totalSupply * 120 ) / 10000;
constructor() Ownable(msg.sender) {
}
receive() external payable {}
function name() public pure returns (string memory) { }
function symbol() public pure returns (string memory) { }
function decimals() public pure returns (uint8) { }
function StartTrading() external onlyOwner { }
function getOwner() external view override returns (address) { }
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 setisExempt(address _address, bool _enabled) external onlyOwner { }
function approve(address spender, uint256 amount) public override returns (bool) { }
function totalSupply() public view override returns (uint256) { }
function shouldContractSwap(address sender, address recipient, uint256 amount) internal view returns (bool) {
}
function setwaveSwapthreshold(uint256 _swapAmount, uint256 _swapThreshold, uint256 _minTokenAmount) external onlyOwner {
}
function ultimatefees(uint256 _liquidity, uint256 _marketing, uint256 _burn, uint256 _development, uint256 _total, uint256 _sell, uint256 _trans) external onlyOwner {
}
function removeSwapLimits(uint256 _buy, uint256 _sell, uint256 _wallet) external onlyOwner {
}
function manualSwap() external onlyOwner {
}
function swapAndLiquify(uint256 tokens) private lockTheSwap {
}
function addLiquidity(uint256 tokenAmount, uint256 ETHAmount) private {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function shouldTakeFee(address sender, address recipient) internal view returns (bool) {
}
function getTotalFee(address sender, address recipient) internal view returns (uint256) {
}
function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount <= balanceOf(sender),"You are trying to transfer more than your balance");
if(!isFeeExempt[sender] && !isFeeExempt[recipient]){require(tradingAllowed, "tradingAllowed");}
if(!isFeeExempt[sender] && !isFeeExempt[recipient] && recipient != address(pair) && recipient != address(DEAD)){
require(<FILL_ME>)}
if(sender != pair){require(amount <= maxSellAmount || isFeeExempt[sender] || isFeeExempt[recipient], "TX Limit Exceeded");}
require(amount <= maxTxAmount || isFeeExempt[sender] || isFeeExempt[recipient], "TX Limit Exceeded");
if(recipient == pair && !isFeeExempt[sender]){swapTimes += uint256(1);}
if(shouldContractSwap(sender, recipient, amount)){swapAndLiquify(swapThreshold); swapTimes = uint256(0);}
_balances[sender] = _balances[sender].sub(amount);
uint256 amountReceived = shouldTakeFee(sender, recipient) ? takeFee(sender, recipient, amount) : amount;
_balances[recipient] = _balances[recipient].add(amountReceived);
emit Transfer(sender, recipient, amountReceived);
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
}
| (_balances[recipient].add(amount))<=maxWalletToken,"Exceeds maximum wallet amount." | 131,879 | (_balances[recipient].add(amount))<=maxWalletToken |
'Current Sale is For Burn Mint' | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;
import "contract-allow-list/contracts/ERC721AntiScam/ERC721AntiScam.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract Kamiyo is ERC721AntiScam, Pausable {
address public constant withdrawAddress = 0xe53f976b720a0Be0Fd60508f9E938185DfD43657;
string public baseURI = "";
string public baseExtension = ".json";
uint256 public salesId = 1;
uint256 public maxAmountPerMint = 2;
uint256 public maxSupply = 13333;
uint256 public mintCost = 0.001 ether;
bytes32 merkleRoot;
bool public isBurnMint = false;
uint256 public maxBurnMint = 0;
mapping(uint256 => mapping(address => uint256)) mintedAmountBySales;
modifier isMintSale() {
require(<FILL_ME>)
_;
}
modifier isBurnMintSale() {
}
modifier enoughEth(uint256 amount) {
}
modifier withinMaxSupply(uint256 amount) {
}
modifier withinMaxBurnMint(uint256 amount) {
}
modifier withinMaxAmountPerMint(uint256 amount) {
}
modifier withinMaxAmountPerAddress(uint256 amount, uint256 allowedAmount) {
}
modifier validProof(uint256 allowedAmount, bytes32[] calldata merkleProof) {
}
constructor(address[] memory addresses, uint256[] memory amounts) ERC721A("Kamiyo", "KMY") {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function setSalesInfo(uint256 _salesId, uint256 _maxAmountPerMint, uint256 _maxSupply, uint256 _mintCost, bytes32 _merkleRoot, bool _isBurnMint, uint256 _maxBurnMint) public onlyOwner {
}
function setSalesId(uint256 _value) public onlyOwner {
}
function setMaxAmountPerMint(uint256 _value) public onlyOwner {
}
function setMaxSupply(uint256 _value) public onlyOwner {
}
function setMintCost(uint256 _value) public onlyOwner {
}
function setMerkleRoot(bytes32 _value) public onlyOwner {
}
function setIsBurnMint(bool _value) public onlyOwner {
}
function setMaxBurnMint(uint256 _value) public onlyOwner {
}
function getMintedAmount(address targetAddress) view public returns(uint256) {
}
function getTotalBurned() view public returns (uint256) {
}
function mint(uint256 amount, uint256 allowedAmount, bytes32[] calldata merkleProof) external payable
whenNotPaused
isMintSale()
enoughEth(amount)
withinMaxSupply(amount)
withinMaxAmountPerMint(amount)
withinMaxAmountPerAddress(amount, allowedAmount)
validProof(allowedAmount, merkleProof)
{
}
function burnMint(uint256[] memory burnTokenIds, uint256 allowedAmount, bytes32[] calldata merkleProof) external payable
whenNotPaused
isBurnMintSale()
enoughEth(burnTokenIds.length)
withinMaxBurnMint(burnTokenIds.length)
withinMaxAmountPerMint(burnTokenIds.length)
withinMaxAmountPerAddress(burnTokenIds.length, allowedAmount)
validProof(allowedAmount, merkleProof)
{
}
function withdraw() public payable onlyOwner {
}
function setBaseURI(string memory _value) external onlyOwner {
}
function setBaseExtension(string memory _value) external onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function exists(uint256 tokenId) public view virtual returns (bool) {
}
}
| !isBurnMint,'Current Sale is For Burn Mint' | 131,883 | !isBurnMint |
'Over Max Burn Mint' | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;
import "contract-allow-list/contracts/ERC721AntiScam/ERC721AntiScam.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract Kamiyo is ERC721AntiScam, Pausable {
address public constant withdrawAddress = 0xe53f976b720a0Be0Fd60508f9E938185DfD43657;
string public baseURI = "";
string public baseExtension = ".json";
uint256 public salesId = 1;
uint256 public maxAmountPerMint = 2;
uint256 public maxSupply = 13333;
uint256 public mintCost = 0.001 ether;
bytes32 merkleRoot;
bool public isBurnMint = false;
uint256 public maxBurnMint = 0;
mapping(uint256 => mapping(address => uint256)) mintedAmountBySales;
modifier isMintSale() {
}
modifier isBurnMintSale() {
}
modifier enoughEth(uint256 amount) {
}
modifier withinMaxSupply(uint256 amount) {
}
modifier withinMaxBurnMint(uint256 amount) {
require(<FILL_ME>)
_;
}
modifier withinMaxAmountPerMint(uint256 amount) {
}
modifier withinMaxAmountPerAddress(uint256 amount, uint256 allowedAmount) {
}
modifier validProof(uint256 allowedAmount, bytes32[] calldata merkleProof) {
}
constructor(address[] memory addresses, uint256[] memory amounts) ERC721A("Kamiyo", "KMY") {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function setSalesInfo(uint256 _salesId, uint256 _maxAmountPerMint, uint256 _maxSupply, uint256 _mintCost, bytes32 _merkleRoot, bool _isBurnMint, uint256 _maxBurnMint) public onlyOwner {
}
function setSalesId(uint256 _value) public onlyOwner {
}
function setMaxAmountPerMint(uint256 _value) public onlyOwner {
}
function setMaxSupply(uint256 _value) public onlyOwner {
}
function setMintCost(uint256 _value) public onlyOwner {
}
function setMerkleRoot(bytes32 _value) public onlyOwner {
}
function setIsBurnMint(bool _value) public onlyOwner {
}
function setMaxBurnMint(uint256 _value) public onlyOwner {
}
function getMintedAmount(address targetAddress) view public returns(uint256) {
}
function getTotalBurned() view public returns (uint256) {
}
function mint(uint256 amount, uint256 allowedAmount, bytes32[] calldata merkleProof) external payable
whenNotPaused
isMintSale()
enoughEth(amount)
withinMaxSupply(amount)
withinMaxAmountPerMint(amount)
withinMaxAmountPerAddress(amount, allowedAmount)
validProof(allowedAmount, merkleProof)
{
}
function burnMint(uint256[] memory burnTokenIds, uint256 allowedAmount, bytes32[] calldata merkleProof) external payable
whenNotPaused
isBurnMintSale()
enoughEth(burnTokenIds.length)
withinMaxBurnMint(burnTokenIds.length)
withinMaxAmountPerMint(burnTokenIds.length)
withinMaxAmountPerAddress(burnTokenIds.length, allowedAmount)
validProof(allowedAmount, merkleProof)
{
}
function withdraw() public payable onlyOwner {
}
function setBaseURI(string memory _value) external onlyOwner {
}
function setBaseExtension(string memory _value) external onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function exists(uint256 tokenId) public view virtual returns (bool) {
}
}
| _totalBurned()+amount<=maxSupply,'Over Max Burn Mint' | 131,883 | _totalBurned()+amount<=maxSupply |
'Over Max Amount Per Address' | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;
import "contract-allow-list/contracts/ERC721AntiScam/ERC721AntiScam.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract Kamiyo is ERC721AntiScam, Pausable {
address public constant withdrawAddress = 0xe53f976b720a0Be0Fd60508f9E938185DfD43657;
string public baseURI = "";
string public baseExtension = ".json";
uint256 public salesId = 1;
uint256 public maxAmountPerMint = 2;
uint256 public maxSupply = 13333;
uint256 public mintCost = 0.001 ether;
bytes32 merkleRoot;
bool public isBurnMint = false;
uint256 public maxBurnMint = 0;
mapping(uint256 => mapping(address => uint256)) mintedAmountBySales;
modifier isMintSale() {
}
modifier isBurnMintSale() {
}
modifier enoughEth(uint256 amount) {
}
modifier withinMaxSupply(uint256 amount) {
}
modifier withinMaxBurnMint(uint256 amount) {
}
modifier withinMaxAmountPerMint(uint256 amount) {
}
modifier withinMaxAmountPerAddress(uint256 amount, uint256 allowedAmount) {
require(<FILL_ME>)
_;
}
modifier validProof(uint256 allowedAmount, bytes32[] calldata merkleProof) {
}
constructor(address[] memory addresses, uint256[] memory amounts) ERC721A("Kamiyo", "KMY") {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function setSalesInfo(uint256 _salesId, uint256 _maxAmountPerMint, uint256 _maxSupply, uint256 _mintCost, bytes32 _merkleRoot, bool _isBurnMint, uint256 _maxBurnMint) public onlyOwner {
}
function setSalesId(uint256 _value) public onlyOwner {
}
function setMaxAmountPerMint(uint256 _value) public onlyOwner {
}
function setMaxSupply(uint256 _value) public onlyOwner {
}
function setMintCost(uint256 _value) public onlyOwner {
}
function setMerkleRoot(bytes32 _value) public onlyOwner {
}
function setIsBurnMint(bool _value) public onlyOwner {
}
function setMaxBurnMint(uint256 _value) public onlyOwner {
}
function getMintedAmount(address targetAddress) view public returns(uint256) {
}
function getTotalBurned() view public returns (uint256) {
}
function mint(uint256 amount, uint256 allowedAmount, bytes32[] calldata merkleProof) external payable
whenNotPaused
isMintSale()
enoughEth(amount)
withinMaxSupply(amount)
withinMaxAmountPerMint(amount)
withinMaxAmountPerAddress(amount, allowedAmount)
validProof(allowedAmount, merkleProof)
{
}
function burnMint(uint256[] memory burnTokenIds, uint256 allowedAmount, bytes32[] calldata merkleProof) external payable
whenNotPaused
isBurnMintSale()
enoughEth(burnTokenIds.length)
withinMaxBurnMint(burnTokenIds.length)
withinMaxAmountPerMint(burnTokenIds.length)
withinMaxAmountPerAddress(burnTokenIds.length, allowedAmount)
validProof(allowedAmount, merkleProof)
{
}
function withdraw() public payable onlyOwner {
}
function setBaseURI(string memory _value) external onlyOwner {
}
function setBaseExtension(string memory _value) external onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function exists(uint256 tokenId) public view virtual returns (bool) {
}
}
| mintedAmountBySales[salesId][msg.sender]+amount<=allowedAmount,'Over Max Amount Per Address' | 131,883 | mintedAmountBySales[salesId][msg.sender]+amount<=allowedAmount |
"You have reached the claim limit(5)" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
contract LoyaltyProgram is Ownable, ERC721AQueryable, ReentrancyGuard {
string private metadataUri;
uint256 public mintLimit;
uint256 public mintStartTime;
uint256 public mintEndTime;
modifier isNotContract() {
}
modifier checkMintTimes() {
}
constructor(
uint256 _mintStartTime,
uint256 _mintEndTime,
uint256 _mintLimit,
string memory _metadataUri
) ERC721A("Loyalty Program", "Loyalty Program") {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function mint() external nonReentrant isNotContract checkMintTimes {
require(<FILL_ME>)
_safeMint(msg.sender, 1);
}
function getMintSurplus(address userAddress) view external returns (uint256) {
}
function setMintTimes(uint256 _mintStartTime, uint256 _mintEndTime) external onlyOwner {
}
}
| _numberMinted(msg.sender)+1<=mintLimit,"You have reached the claim limit(5)" | 131,911 | _numberMinted(msg.sender)+1<=mintLimit |
"Burning tokens is currently disabled" | pragma solidity ^0.8.17;
// SPDX-License-Identifier: Unlicensed
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) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
abstract contract Context {
//function _msgSender() internal view virtual returns (address payable) {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
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 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) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
function getPair(address token0, address token1) external view returns (address);
}
interface IWETH {
function deposit() external payable;
function transfer(address to, uint value) external returns (bool);
function withdraw(uint) external;
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
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 swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external payable returns (uint[] memory amounts);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB);
function WETH() external pure returns (address);
}
contract SandrenFlames is IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
modifier lockTheSwap {
}
event TokensBurned(uint256, uint256);
event RaffleWinner(address, uint256);
event SandrenLiquidityAdded(uint, uint256);
struct SandrenConfig {
uint256 maxWalletAmount;
uint256 ethPriceToSwap;
uint256 ethPriceForRewards;
uint256 liquidityPoolPercentage;
uint256 burnFrequencynMinutes;
uint256 burnRateInBasePoints;
uint256 minimumSandrenTokens;
uint8[3] buyFees;
uint8[3] sellFees;
bool isBurnEnabled;
}
struct LastWinner {
address holder;
uint ethAmount;
}
IUniswapV2Router02 private uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public uniswapV2Pair = address(0);
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
string private _name = "Sandren Flames";
string private _symbol = "SNDRNFLMS";
uint8 private _decimals = 9;
uint256 private _tTotal = 1000000000 * 10 ** 9;
IterableMapping private sandrenHoldersMap = new IterableMapping();
bool inSwapAndLiquify;
uint256 public tokensBurnedSinceLaunch;
uint256 public totalEthRewardedSinceLaunch;
uint public liquidityUnlockDate;
uint public nextLiquidityBurnTimeStamp;
TokenBurner public tokenBurner = new TokenBurner(address(this));
IERC20 private sandrenToken = IERC20(0xC39F5519123d40D695012f779afBAcBd3AdbEb91); //Mainnet
LastWinner public lastWinner = LastWinner(address(0), 0);
SandrenConfig public sandrenConfig = SandrenConfig(
100000000001 * 10 ** 9,
// 10000001 * 10 ** _decimals, //maxWalletAmount
300000000000000000, //ethPriceToSwap .3ETH
100000000000000000, //ethPriceForRewards - .1 ETH is the minimum amount to be included in rewards.
75, //liquidityPoolPercentage
60, //burnFrequencynMinutes
100, //burnRateInBasePoints - .05% for Buyback and Burn and .05% for SNDRN LP
100000 * 10 ** 9, //minimumSandrenTokens 100K tokens of SNDRN required for Eth reward entry
[3, 4, 5], //buyFees random taxation between 3%-5% on every buy
[4, 5, 6], //sellFees random taxation between 4%-6% on every sell
true //isBurnEnabled
);
constructor () {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function setSandrenFlamesConfig(uint256 maxWalletAmount, uint ethPriceToSwap,uint256 ethPriceForRewards, uint256 liquidityPoolPercentage, uint256 burnFrequencynMinutes,
uint256 minimumSandrenTokens, uint8[3] calldata buyFees, uint8[3] calldata sellFees, bool isBurnEnabled) external onlyOwner {
}
function excludeIncludeFromFee(address[] calldata addresses, bool isExcludeFromFee) public onlyOwner {
}
function _burn(address account, uint256 value) internal {
}
function addRemoveFee(address[] calldata addresses, bool flag) private {
}
function checkIncludedInEthRaffle(address holder) public view returns(bool) {
}
function totalRaffleParticipants() public view returns(uint256) {
}
function burn(uint256 amount) public {
}
function chooseRandomWinner() private returns(address) {
}
function getRandomTax(uint8[3] memory fees) public view returns(uint256) {
}
function getRandomeNumberByRange(uint256 range) public view returns(uint) {
}
function burnTokens() external {
require(block.timestamp >= nextLiquidityBurnTimeStamp, "Next burn time is not due yet, be patient");
require(<FILL_ME>)
burnTokensFromLiquidityPool();
}
function lockLiquidity(uint256 newLockDate) external onlyOwner {
}
function openTrading() external onlyOwner() {
}
//This is only for protection at launch in case of any issues. Liquidity cannot be pulled if
//liquidityUnlockDate has not been reached or contract is renounced
function removeLiqudityPool() external onlyOwner {
}
function burnTokensFromLiquidityPool() private lockTheSwap {
}
function removeLiquidity(uint256 tokenAmount, address toAddress) private {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function addSandrenHoldersForEthRewards(address[] calldata holders) external onlyOwner {
}
function tokenTransfer(address from, address to, uint256 amount, bool takeFees, bool isSell) private {
}
function addRemoveSandrenHolder(address holder) private {
}
function sellTokens() private {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function buySandrenTokensAndAddToLiquidityPool() private {
}
function addSandrenLiquidity(uint256 ethAmount, uint256 tokenAmount) private {
}
function swapEthForSandren(uint ethAmount) private {
}
function getTokenAmountByEthPrice(uint ethAmount) private view returns (uint256) {
}
receive() external payable {}
function recoverEthInContract() external onlyOwner {
}
}
contract TokenBurner is Ownable {
using SafeMath for uint256;
IUniswapV2Router02 private uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
IERC20 private wethToken = IERC20(uniswapV2Router.WETH());
IERC20 public tokenContractAddress;
event sentEthForSandrenLiquidityPool(uint);
constructor(address tokenAddr) {
}
function buyBack() external {
}
function swapEthForSandrenFlames(uint ethAmount) private {
}
function withdrawWETH() private {
}
receive() external payable {}
function recoverEth() external onlyOwner {
}
}
contract IterableMapping {
// Iterable mapping from address to uint;
struct Map {
address[] keys;
mapping(address => uint) indexOf;
mapping(address => bool) inserted;
}
Map private map;
function keyExists(address key) public view returns (bool) {
}
function getIndexOfKey(address key) public view returns (int) {
}
function getKeyAtIndex(uint index) public view returns (address) {
}
function size() public view returns (uint) {
}
function add(address key) public {
}
function remove(address key) public {
}
}
| !sandrenConfig.isBurnEnabled,"Burning tokens is currently disabled" | 131,992 | !sandrenConfig.isBurnEnabled |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.