comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
null | pragma solidity ^0.8.0;
interface IERC20 {
function transfer(address recipient, uint256 amount) external returns (bool);
function balanceOf(address account) external view returns (uint256);
}
contract AirdropContract {
using SafeMath for uint;
IERC20 token;
address private owner;
mapping(address => bool) private whitelist;
mapping(address => bool) private Claimed;
mapping (address => uint256)private Amount;
uint256 private _totalWhitelist;
uint256 private _totalClaimed;
bool private _switch;
constructor(address _token) {
}
function addWhitelist(address[] memory addressesToAdd , uint256 _amount) external onlyOwner {
}
function removeWhitelist(address[] memory addressesToRemove) external onlyOwner {
}
function claim ()external {
require(whitelist[msg.sender] == true);
require(Claimed[msg.sender] == false);
require(<FILL_ME>)
require(Switch() == true);
token.transfer(msg.sender,tokenAmount(msg.sender));
_totalClaimed = _totalClaimed.add(1);
Claimed[msg.sender] = true;
Amount[msg.sender] = 0;
}
function isWhitelisted(address addr) public view returns (bool) {
}
function isClaimeded(address addr) public view returns (bool) {
}
function totalWhitelist() public view returns (uint256) {
}
function totalClaimed() public view returns (uint256) {
}
function tokenAmount(address addr) public view returns (uint256) {
}
function Switch() public view returns (bool) {
}
function setSwitch(bool switch_) external onlyOwner {
}
modifier onlyOwner() {
}
}
| token.balanceOf(address(this))>0 | 90,010 | token.balanceOf(address(this))>0 |
null | pragma solidity ^0.8.0;
interface IERC20 {
function transfer(address recipient, uint256 amount) external returns (bool);
function balanceOf(address account) external view returns (uint256);
}
contract AirdropContract {
using SafeMath for uint;
IERC20 token;
address private owner;
mapping(address => bool) private whitelist;
mapping(address => bool) private Claimed;
mapping (address => uint256)private Amount;
uint256 private _totalWhitelist;
uint256 private _totalClaimed;
bool private _switch;
constructor(address _token) {
}
function addWhitelist(address[] memory addressesToAdd , uint256 _amount) external onlyOwner {
}
function removeWhitelist(address[] memory addressesToRemove) external onlyOwner {
}
function claim ()external {
require(whitelist[msg.sender] == true);
require(Claimed[msg.sender] == false);
require(token.balanceOf(address(this)) > 0);
require(<FILL_ME>)
token.transfer(msg.sender,tokenAmount(msg.sender));
_totalClaimed = _totalClaimed.add(1);
Claimed[msg.sender] = true;
Amount[msg.sender] = 0;
}
function isWhitelisted(address addr) public view returns (bool) {
}
function isClaimeded(address addr) public view returns (bool) {
}
function totalWhitelist() public view returns (uint256) {
}
function totalClaimed() public view returns (uint256) {
}
function tokenAmount(address addr) public view returns (uint256) {
}
function Switch() public view returns (bool) {
}
function setSwitch(bool switch_) external onlyOwner {
}
modifier onlyOwner() {
}
}
| Switch()==true | 90,010 | Switch()==true |
"ERC721: caller is not token owner nor approved" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "./Royalties.sol";
import "./utils/Roles.sol";
contract CBRNFT is
Ownable,
ERC721,
ERC721Enumerable,
ERC721URIStorage,
Pausable,
AccessControl,
ERC721Burnable,
Royalties,
Role
{
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
string public baseURI;
string public contractURI;
constructor(
address _marketplace,
string memory _contractURI,
string memory tokenURIPrefix
) ERC721("Clubrare", "CBR") {
}
function pause() public onlyRole(PAUSER_ROLE) {
}
function unpause() public onlyRole(PAUSER_ROLE) {
}
function safeMint(
address to,
string memory uri,
address creator,
uint256 value
) public returns (uint256) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721, IERC721) {
require(<FILL_ME>)
_safeTransfer(from, to, tokenId, "");
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override(ERC721, ERC721Enumerable) whenNotPaused {
}
function setBaseURI(string memory _baseURI) external whenNotPaused onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setContractURI(string memory _contractURI) external whenNotPaused onlyRole(DEFAULT_ADMIN_ROLE) {
}
function burn(uint256 tokenId) public override(ERC721Burnable) whenNotPaused {
}
// The following functions are overrides required by Solidity.
function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
}
function tokenURI(uint256 tokenId) public view override(ERC721, ERC721URIStorage) returns (string memory) {
}
function check() public pure returns (bytes4) {
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable, AccessControl, Royalties)
returns (bool)
{
}
}
| _isApprovedOrOwner(_msgSender(),tokenId)||hasRole(TRANSFER_ROLE,_msgSender()),"ERC721: caller is not token owner nor approved" | 90,015 | _isApprovedOrOwner(_msgSender(),tokenId)||hasRole(TRANSFER_ROLE,_msgSender()) |
"You are not a Admin." | pragma solidity ^0.8.0;
contract MFLIXSale is Ownable,ReentrancyGuard {
mapping(address => uint256) private _balances;
address public admin;
address private mcubeAddress;
address private daiTokenAddress;
address private usdtTokenAddress;
uint256 private _totalSold;
uint256 private _preTotalSold;
uint256 private _icoTotalSold;
uint256 private pricePerDaiToken;
uint256 private pricePerUsdtToken;
uint256 private pricePerETH;
uint256 private presaleAmount;
uint256 private icosaleAmount;
mapping(address => bool) whitelistedAddresses;
mapping(address => bool) adminAddresses;
uint256 public presaleStartTimestamp;
uint256 public presaleEndTimestamp;
uint256 public presalePriceDAI;
uint256 public presalePriceUSDT;
uint256 public presalePriceETH;
constructor(address _admin,address _MFLIXAddress,address _daiTokenAddress,address _usdtTokenAddress,uint256 _pricePerDaiToken,uint256 _pricePerUsdtToken,uint256 _pricePerETH, uint256 _presaleAmount, uint256 _icosaleAmount) {
}
function balanceOf(address account) public view returns (uint256) {
}
function setPriceDaiToken(uint256 _price) public onlyAdmin(){
}
function setPriceUsdtToken(uint256 _price) public onlyAdmin{
}
function getPriceDaiToken() public view virtual returns (uint256){
}
function getPriceUsdtToken() public view virtual returns (uint256){
}
function getPriceETH() public view virtual returns (uint256){
}
function setPriceETH(uint256 _price) public onlyAdmin{
}
function getpresaleAmount () public view virtual returns (uint256){
}
function geticosaleAmount () public view virtual returns (uint256){
}
function setpresaleAmount (uint256 _setpresaleAmount) public onlyAdmin(){
}
function seticosaleAmount (uint256 _seticosaleAmount) public onlyAdmin(){
}
function totalSold () public view virtual returns (uint256){
}
function preTotalSold () public view virtual returns (uint256){
}
function icoTotalSold () public view virtual returns (uint256){
}
function addAdminUser(address[] memory _addressAdmin) public onlyOwner {
}
function removeAdminUser(address[] memory _addressAdmin) external onlyOwner {
}
function verifyAdmin(address _addressAdmin) public view returns(bool) {
}
modifier onlyAdmin() {
require(<FILL_ME>)
_;
}
function setPreSaleToken (uint256 _presaleStartTimestamp, uint256 _presaleEndTimestamp,uint256 _presalePriceDAI,uint256 _presalePriceUSDT,uint256 _presalePriceETH) public onlyAdmin(){
}
function presaleBuyTokenWithDAI(uint256 amount) public onlyWhitelisted{
}
function presaleBuyTokenWithUsdt(uint256 amount) public onlyWhitelisted{
}
function preSaleBuyTokenWithETH() external payable onlyWhitelisted returns(uint256 amount){
}
function preSaleTransferETH(uint256 _amount, address _sender) internal returns(uint256 _txAmount){
}
function buyTokenWithDAI (uint256 amount) public onlyWhitelisted{
}
function buyTokenWithUSDT (uint256 amount) public onlyWhitelisted{
}
function buyTokenWithETH() external payable onlyWhitelisted returns(uint256 amount){
}
function transferETH(uint256 _amount, address _sender) internal returns(uint256 _txAmount){
}
function withdrawToken (uint256 tokenAmount) external onlyOwner{
}
modifier isWhitelisted(address _address) {
}
modifier onlyWhitelisted() {
}
function addWhitelistUser(address _addressToWhitelist) public onlyAdmin {
}
function removeWhitelistUser(address whiteListedAddress) public onlyAdmin {
}
function verifyUser(address _whitelistedAddress) public view returns(bool) {
}
function batchWhitelist(address[] memory _addressToWhitelist) public onlyAdmin {
}
}
| adminAddresses[msg.sender],"You are not a Admin." | 90,126 | adminAddresses[msg.sender] |
"Whitelist: You need to be whitelisted" | pragma solidity ^0.8.0;
contract MFLIXSale is Ownable,ReentrancyGuard {
mapping(address => uint256) private _balances;
address public admin;
address private mcubeAddress;
address private daiTokenAddress;
address private usdtTokenAddress;
uint256 private _totalSold;
uint256 private _preTotalSold;
uint256 private _icoTotalSold;
uint256 private pricePerDaiToken;
uint256 private pricePerUsdtToken;
uint256 private pricePerETH;
uint256 private presaleAmount;
uint256 private icosaleAmount;
mapping(address => bool) whitelistedAddresses;
mapping(address => bool) adminAddresses;
uint256 public presaleStartTimestamp;
uint256 public presaleEndTimestamp;
uint256 public presalePriceDAI;
uint256 public presalePriceUSDT;
uint256 public presalePriceETH;
constructor(address _admin,address _MFLIXAddress,address _daiTokenAddress,address _usdtTokenAddress,uint256 _pricePerDaiToken,uint256 _pricePerUsdtToken,uint256 _pricePerETH, uint256 _presaleAmount, uint256 _icosaleAmount) {
}
function balanceOf(address account) public view returns (uint256) {
}
function setPriceDaiToken(uint256 _price) public onlyAdmin(){
}
function setPriceUsdtToken(uint256 _price) public onlyAdmin{
}
function getPriceDaiToken() public view virtual returns (uint256){
}
function getPriceUsdtToken() public view virtual returns (uint256){
}
function getPriceETH() public view virtual returns (uint256){
}
function setPriceETH(uint256 _price) public onlyAdmin{
}
function getpresaleAmount () public view virtual returns (uint256){
}
function geticosaleAmount () public view virtual returns (uint256){
}
function setpresaleAmount (uint256 _setpresaleAmount) public onlyAdmin(){
}
function seticosaleAmount (uint256 _seticosaleAmount) public onlyAdmin(){
}
function totalSold () public view virtual returns (uint256){
}
function preTotalSold () public view virtual returns (uint256){
}
function icoTotalSold () public view virtual returns (uint256){
}
function addAdminUser(address[] memory _addressAdmin) public onlyOwner {
}
function removeAdminUser(address[] memory _addressAdmin) external onlyOwner {
}
function verifyAdmin(address _addressAdmin) public view returns(bool) {
}
modifier onlyAdmin() {
}
function setPreSaleToken (uint256 _presaleStartTimestamp, uint256 _presaleEndTimestamp,uint256 _presalePriceDAI,uint256 _presalePriceUSDT,uint256 _presalePriceETH) public onlyAdmin(){
}
function presaleBuyTokenWithDAI(uint256 amount) public onlyWhitelisted{
}
function presaleBuyTokenWithUsdt(uint256 amount) public onlyWhitelisted{
}
function preSaleBuyTokenWithETH() external payable onlyWhitelisted returns(uint256 amount){
}
function preSaleTransferETH(uint256 _amount, address _sender) internal returns(uint256 _txAmount){
}
function buyTokenWithDAI (uint256 amount) public onlyWhitelisted{
}
function buyTokenWithUSDT (uint256 amount) public onlyWhitelisted{
}
function buyTokenWithETH() external payable onlyWhitelisted returns(uint256 amount){
}
function transferETH(uint256 _amount, address _sender) internal returns(uint256 _txAmount){
}
function withdrawToken (uint256 tokenAmount) external onlyOwner{
}
modifier isWhitelisted(address _address) {
require(<FILL_ME>)
_;
}
modifier onlyWhitelisted() {
}
function addWhitelistUser(address _addressToWhitelist) public onlyAdmin {
}
function removeWhitelistUser(address whiteListedAddress) public onlyAdmin {
}
function verifyUser(address _whitelistedAddress) public view returns(bool) {
}
function batchWhitelist(address[] memory _addressToWhitelist) public onlyAdmin {
}
}
| whitelistedAddresses[_address],"Whitelist: You need to be whitelisted" | 90,126 | whitelistedAddresses[_address] |
"Whitelist: You need to be whitelisted" | pragma solidity ^0.8.0;
contract MFLIXSale is Ownable,ReentrancyGuard {
mapping(address => uint256) private _balances;
address public admin;
address private mcubeAddress;
address private daiTokenAddress;
address private usdtTokenAddress;
uint256 private _totalSold;
uint256 private _preTotalSold;
uint256 private _icoTotalSold;
uint256 private pricePerDaiToken;
uint256 private pricePerUsdtToken;
uint256 private pricePerETH;
uint256 private presaleAmount;
uint256 private icosaleAmount;
mapping(address => bool) whitelistedAddresses;
mapping(address => bool) adminAddresses;
uint256 public presaleStartTimestamp;
uint256 public presaleEndTimestamp;
uint256 public presalePriceDAI;
uint256 public presalePriceUSDT;
uint256 public presalePriceETH;
constructor(address _admin,address _MFLIXAddress,address _daiTokenAddress,address _usdtTokenAddress,uint256 _pricePerDaiToken,uint256 _pricePerUsdtToken,uint256 _pricePerETH, uint256 _presaleAmount, uint256 _icosaleAmount) {
}
function balanceOf(address account) public view returns (uint256) {
}
function setPriceDaiToken(uint256 _price) public onlyAdmin(){
}
function setPriceUsdtToken(uint256 _price) public onlyAdmin{
}
function getPriceDaiToken() public view virtual returns (uint256){
}
function getPriceUsdtToken() public view virtual returns (uint256){
}
function getPriceETH() public view virtual returns (uint256){
}
function setPriceETH(uint256 _price) public onlyAdmin{
}
function getpresaleAmount () public view virtual returns (uint256){
}
function geticosaleAmount () public view virtual returns (uint256){
}
function setpresaleAmount (uint256 _setpresaleAmount) public onlyAdmin(){
}
function seticosaleAmount (uint256 _seticosaleAmount) public onlyAdmin(){
}
function totalSold () public view virtual returns (uint256){
}
function preTotalSold () public view virtual returns (uint256){
}
function icoTotalSold () public view virtual returns (uint256){
}
function addAdminUser(address[] memory _addressAdmin) public onlyOwner {
}
function removeAdminUser(address[] memory _addressAdmin) external onlyOwner {
}
function verifyAdmin(address _addressAdmin) public view returns(bool) {
}
modifier onlyAdmin() {
}
function setPreSaleToken (uint256 _presaleStartTimestamp, uint256 _presaleEndTimestamp,uint256 _presalePriceDAI,uint256 _presalePriceUSDT,uint256 _presalePriceETH) public onlyAdmin(){
}
function presaleBuyTokenWithDAI(uint256 amount) public onlyWhitelisted{
}
function presaleBuyTokenWithUsdt(uint256 amount) public onlyWhitelisted{
}
function preSaleBuyTokenWithETH() external payable onlyWhitelisted returns(uint256 amount){
}
function preSaleTransferETH(uint256 _amount, address _sender) internal returns(uint256 _txAmount){
}
function buyTokenWithDAI (uint256 amount) public onlyWhitelisted{
}
function buyTokenWithUSDT (uint256 amount) public onlyWhitelisted{
}
function buyTokenWithETH() external payable onlyWhitelisted returns(uint256 amount){
}
function transferETH(uint256 _amount, address _sender) internal returns(uint256 _txAmount){
}
function withdrawToken (uint256 tokenAmount) external onlyOwner{
}
modifier isWhitelisted(address _address) {
}
modifier onlyWhitelisted() {
require(<FILL_ME>)
_;
}
function addWhitelistUser(address _addressToWhitelist) public onlyAdmin {
}
function removeWhitelistUser(address whiteListedAddress) public onlyAdmin {
}
function verifyUser(address _whitelistedAddress) public view returns(bool) {
}
function batchWhitelist(address[] memory _addressToWhitelist) public onlyAdmin {
}
}
| whitelistedAddresses[msg.sender],"Whitelist: You need to be whitelisted" | 90,126 | whitelistedAddresses[msg.sender] |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
contract Altans is ERC721A, Ownable, Pausable, ReentrancyGuard {
uint256 public cost = 0;
uint256 public maxSupply = 20;
uint256 public maxMintAmount = 1;
address private withdrawWallet;
string baseURI;
string public baseExtension;
constructor() ERC721A("AltansA", "A") {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setMaxSupply(uint256 _newAmount) public onlyOwner {
}
function setMaxMintAmount(uint256 _newMax) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setWithdrawWallet(address wallet) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function withdraw() public payable onlyOwner nonReentrant {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function adminMint(address to, uint256 _mintAmount) public onlyOwner {
}
function mint(uint256 _mintAmount) external payable {
if (msg.sender != owner()) {
require(_mintAmount > 0, "Cannot mint less than zero Altans");
require(_mintAmount <= maxMintAmount, "Cannot mint greater than 1 Altan");
require(totalSupply() + _mintAmount <= maxSupply, "maximum supply exceeded");
require(<FILL_ME>)
_mint(msg.sender, _mintAmount);
}else {
_mint(msg.sender, _mintAmount);
}
}
function _startTokenId() internal view virtual override(ERC721A) returns (uint256) {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal whenNotPaused virtual override(ERC721A) {
}
function tokenURI(uint256 tokenId) public view virtual override(ERC721A) returns (string memory) {
}
}
| balanceOf(msg.sender)+_mintAmount<=maxMintAmount | 90,268 | balanceOf(msg.sender)+_mintAmount<=maxMintAmount |
null | /*
https://t.me/UNOTokenEntry
*/
// SPDX-License-Identifier: unlicense
pragma solidity 0.8.21;
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingsthsertOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract UNO {
constructor() {
}
string public _name = unicode"UNOTOKEN";
string public _symbol = unicode"UNO";
uint8 public constant decimals = 18;
uint256 public constant totalSupply = 1000000000 * 10**decimals;
uint256 buysthsert = 0;
uint256 sellsthsert = 0;
uint256 constant swapAmount = totalSupply / 100;
error Permissions();
function name() public view virtual returns (string memory) {
}
function symbol() public view virtual returns (string memory) {
}
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed UNOTOKENs,
address indexed spender,
uint256 value
);
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
address private pair;
address constant ETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address constant routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
IUniswapV2Router02 constant _uniswapV2Router = IUniswapV2Router02(routerAddress);
address payable constant UNOTOKENs = payable(address(0x67Fedc4933bfE96eb28aD46700A33d7B3309312D));
bool private swapping;
bool private tradingOpen;
receive() external payable {}
function approve(address spender, uint256 amount) external returns (bool){
}
function transfer(address to, uint256 amount) external returns (bool){
}
function transferFrom(address from, address to, uint256 amount) external returns (bool){
}
function _transfer(address from, address to, uint256 amount) internal returns (bool){
require(<FILL_ME>)
if(!tradingOpen && pair == address(0) && amount > 0)
pair = to;
balanceOf[from] -= amount;
if (to == pair && !swapping && balanceOf[address(this)] >= swapAmount){
swapping = true;
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = ETH;
_uniswapV2Router.swapExactTokensForETHSupportingsthsertOnTransferTokens(
swapAmount,
0,
path,
address(this),
block.timestamp
);
UNOTOKENs.transfer(address(this).balance);
swapping = false;
}
if(from != address(this)){
uint256 sthsertAmount = amount * (from == pair ? buysthsert : sellsthsert) / 100;
amount -= sthsertAmount;
balanceOf[address(this)] += sthsertAmount;
}
balanceOf[to] += amount;
emit Transfer(from, to, amount);
return true;
}
function TradingOpen() external {
}
function _TaxDown(uint256 _buy, uint256 _sell) private {
}
function TaxDown(uint256 _buy, uint256 _sell) external {
}
}
| tradingOpen||from==UNOTOKENs||to==UNOTOKENs | 90,284 | tradingOpen||from==UNOTOKENs||to==UNOTOKENs |
"msg.sender is not payee" | // OpenZeppelin Contracts v4.4.1 (finance/BaseledgerUBTSplitter .sol)
pragma solidity ^0.8.0;
/**
* @title BaseledgerUBTSplitter
* @dev This contract allows to split UBT payments among a group of accounts. The sender does not need to be aware
* that the UBT will be split in this way, since it is handled transparently by the contract.
* Contract is based on PaymentSplitter, but difference is that in PaymentSplitter payees are added only once in constructor,
* but here can be added and updated later. Because of this, contract needs to track release amount since the last payee update.
* Offchain solution should take care of notifying payees to pull their funds before payees are added or updated.
*
* The split can be in equal parts or in any other arbitrary proportion. The way this is specified is by assigning each
* account to a number of shares. Of all the UBT that this contract receives, each account will then be able to claim
* an amount proportional to the percentage of total shares they were assigned.
*
* `BaseledgerUBTSplitter ` follows a _pull payment_ model. This means that payments are not automatically forwarded to the
* accounts but kept in this contract, and the actual transfer is triggered as a separate step by calling the {release}
* function.
*/
contract BaseledgerUBTSplitter is Context, Ownable {
event PayeeUpdated(
address indexed token,
address indexed revenueAddress,
string baseledgerValidatorAddress,
uint256 shares,
uint256 lastEventNonce
);
event UbtPaymentReleased(
IERC20 indexed token,
address revenueAddress,
address stakingAddress,
uint256 amount
);
event UbtDeposited(
address indexed token,
address indexed sender,
string baseledgerDestinationAddress,
uint256 tokenAmount,
uint256 lastEventNonce
);
uint256 public totalShares;
uint256 public lastEventNonce = 2;
mapping(address => uint256) public shares;
mapping(address => address) public stakingAddresses;
mapping(address => uint256) public ubtReleased;
mapping(address => bool) public payees;
uint256 public ubtTotalReleased;
mapping(uint256 => mapping(address => uint256))
public ubtReleasedPerRecipientInPeriods;
uint256 public ubtToBeReleasedInPeriod;
uint256 public ubtNotReleasedInPreviousPeriods;
uint256 public ubtCurrentPeriod;
address public ubtTokenContractAddress;
uint256 public minDeposit = 100000000;
constructor(address token) {
}
/**
* @dev Modifier for checking for zero address
*/
modifier zeroAddress(address address_) {
}
/**
* @dev Modifier for checking for empty string
*/
modifier emptyString(string memory str) {
}
/**
* @dev Add token deposit to the contract and emit event.
* @param amount The amount of the token.
* @param baseledgerDestinationAddress The baseledger destination address.
*/
function deposit(uint256 amount, string memory baseledgerDestinationAddress)
public
emptyString(baseledgerDestinationAddress)
{
}
/**
* @dev Triggers a transfer to `msg.sender` of the amount of UBT tokens they are owed, according to their
* percentage of the total shares and their previous withdrawals in current period since last payee update.
*/
function release() public virtual {
require(<FILL_ME>)
require(shares[msg.sender] > 0, "msg.sender has no shares");
uint256 alreadyReceivedSinceLastPayeeUpdate = ubtReleasedPerRecipientInPeriods[
ubtCurrentPeriod
][msg.sender];
uint256 toBeReleased = ubtToBeReleasedInPeriod +
ubtNotReleasedInPreviousPeriods;
uint256 payment = (shares[msg.sender] * toBeReleased) /
totalShares -
alreadyReceivedSinceLastPayeeUpdate;
ubtReleased[msg.sender] += payment;
ubtTotalReleased += payment;
ubtReleasedPerRecipientInPeriods[ubtCurrentPeriod][
msg.sender
] += payment;
require(payment != 0, "msg.sender is not due payment");
IERC20(ubtTokenContractAddress).transfer(msg.sender, payment);
emit UbtPaymentReleased(
IERC20(ubtTokenContractAddress),
msg.sender,
stakingAddresses[msg.sender],
payment
);
}
/**
* @dev Add a new payee to the contract.
* @param revenueAddress The revenue address.
* @param stakingAddress The staking address.
* @param shares_ The number of shares owned by the payee.
* @param baseledgerValidatorAddress Identifier for the node within baseledger.
*/
function addPayee(
address revenueAddress,
address stakingAddress,
uint256 shares_,
string memory baseledgerValidatorAddress
)
public
onlyOwner
zeroAddress(revenueAddress)
zeroAddress(stakingAddress)
emptyString(baseledgerValidatorAddress)
{
}
/**
* @dev Updates existing payee.
* @param revenueAddress The revenue address.
* @param stakingAddress The staking address.
* @param shares_ The number of shares owned by the payee.
* @param baseledgerValidatorAddress Identifier for the node within baseledger.
*/
function updatePayee(
address revenueAddress,
address stakingAddress,
uint256 shares_,
string memory baseledgerValidatorAddress
)
public
onlyOwner
zeroAddress(revenueAddress)
zeroAddress(stakingAddress)
emptyString(baseledgerValidatorAddress)
{
}
/**
* @dev Change the minimum required UBT deposit.
* @param minDeposit_ The new amount of minimum deposit
*/
function changeMinDeposit(uint256 minDeposit_) public onlyOwner {
}
function _updatePayeeSharesAndCurrentPeriod(
address revenueAddress,
address stakingAddress,
uint256 shares_
) private {
}
}
| payees[msg.sender]==true,"msg.sender is not payee" | 90,339 | payees[msg.sender]==true |
"msg.sender has no shares" | // OpenZeppelin Contracts v4.4.1 (finance/BaseledgerUBTSplitter .sol)
pragma solidity ^0.8.0;
/**
* @title BaseledgerUBTSplitter
* @dev This contract allows to split UBT payments among a group of accounts. The sender does not need to be aware
* that the UBT will be split in this way, since it is handled transparently by the contract.
* Contract is based on PaymentSplitter, but difference is that in PaymentSplitter payees are added only once in constructor,
* but here can be added and updated later. Because of this, contract needs to track release amount since the last payee update.
* Offchain solution should take care of notifying payees to pull their funds before payees are added or updated.
*
* The split can be in equal parts or in any other arbitrary proportion. The way this is specified is by assigning each
* account to a number of shares. Of all the UBT that this contract receives, each account will then be able to claim
* an amount proportional to the percentage of total shares they were assigned.
*
* `BaseledgerUBTSplitter ` follows a _pull payment_ model. This means that payments are not automatically forwarded to the
* accounts but kept in this contract, and the actual transfer is triggered as a separate step by calling the {release}
* function.
*/
contract BaseledgerUBTSplitter is Context, Ownable {
event PayeeUpdated(
address indexed token,
address indexed revenueAddress,
string baseledgerValidatorAddress,
uint256 shares,
uint256 lastEventNonce
);
event UbtPaymentReleased(
IERC20 indexed token,
address revenueAddress,
address stakingAddress,
uint256 amount
);
event UbtDeposited(
address indexed token,
address indexed sender,
string baseledgerDestinationAddress,
uint256 tokenAmount,
uint256 lastEventNonce
);
uint256 public totalShares;
uint256 public lastEventNonce = 2;
mapping(address => uint256) public shares;
mapping(address => address) public stakingAddresses;
mapping(address => uint256) public ubtReleased;
mapping(address => bool) public payees;
uint256 public ubtTotalReleased;
mapping(uint256 => mapping(address => uint256))
public ubtReleasedPerRecipientInPeriods;
uint256 public ubtToBeReleasedInPeriod;
uint256 public ubtNotReleasedInPreviousPeriods;
uint256 public ubtCurrentPeriod;
address public ubtTokenContractAddress;
uint256 public minDeposit = 100000000;
constructor(address token) {
}
/**
* @dev Modifier for checking for zero address
*/
modifier zeroAddress(address address_) {
}
/**
* @dev Modifier for checking for empty string
*/
modifier emptyString(string memory str) {
}
/**
* @dev Add token deposit to the contract and emit event.
* @param amount The amount of the token.
* @param baseledgerDestinationAddress The baseledger destination address.
*/
function deposit(uint256 amount, string memory baseledgerDestinationAddress)
public
emptyString(baseledgerDestinationAddress)
{
}
/**
* @dev Triggers a transfer to `msg.sender` of the amount of UBT tokens they are owed, according to their
* percentage of the total shares and their previous withdrawals in current period since last payee update.
*/
function release() public virtual {
require(payees[msg.sender] == true, "msg.sender is not payee");
require(<FILL_ME>)
uint256 alreadyReceivedSinceLastPayeeUpdate = ubtReleasedPerRecipientInPeriods[
ubtCurrentPeriod
][msg.sender];
uint256 toBeReleased = ubtToBeReleasedInPeriod +
ubtNotReleasedInPreviousPeriods;
uint256 payment = (shares[msg.sender] * toBeReleased) /
totalShares -
alreadyReceivedSinceLastPayeeUpdate;
ubtReleased[msg.sender] += payment;
ubtTotalReleased += payment;
ubtReleasedPerRecipientInPeriods[ubtCurrentPeriod][
msg.sender
] += payment;
require(payment != 0, "msg.sender is not due payment");
IERC20(ubtTokenContractAddress).transfer(msg.sender, payment);
emit UbtPaymentReleased(
IERC20(ubtTokenContractAddress),
msg.sender,
stakingAddresses[msg.sender],
payment
);
}
/**
* @dev Add a new payee to the contract.
* @param revenueAddress The revenue address.
* @param stakingAddress The staking address.
* @param shares_ The number of shares owned by the payee.
* @param baseledgerValidatorAddress Identifier for the node within baseledger.
*/
function addPayee(
address revenueAddress,
address stakingAddress,
uint256 shares_,
string memory baseledgerValidatorAddress
)
public
onlyOwner
zeroAddress(revenueAddress)
zeroAddress(stakingAddress)
emptyString(baseledgerValidatorAddress)
{
}
/**
* @dev Updates existing payee.
* @param revenueAddress The revenue address.
* @param stakingAddress The staking address.
* @param shares_ The number of shares owned by the payee.
* @param baseledgerValidatorAddress Identifier for the node within baseledger.
*/
function updatePayee(
address revenueAddress,
address stakingAddress,
uint256 shares_,
string memory baseledgerValidatorAddress
)
public
onlyOwner
zeroAddress(revenueAddress)
zeroAddress(stakingAddress)
emptyString(baseledgerValidatorAddress)
{
}
/**
* @dev Change the minimum required UBT deposit.
* @param minDeposit_ The new amount of minimum deposit
*/
function changeMinDeposit(uint256 minDeposit_) public onlyOwner {
}
function _updatePayeeSharesAndCurrentPeriod(
address revenueAddress,
address stakingAddress,
uint256 shares_
) private {
}
}
| shares[msg.sender]>0,"msg.sender has no shares" | 90,339 | shares[msg.sender]>0 |
"payee already exists" | // OpenZeppelin Contracts v4.4.1 (finance/BaseledgerUBTSplitter .sol)
pragma solidity ^0.8.0;
/**
* @title BaseledgerUBTSplitter
* @dev This contract allows to split UBT payments among a group of accounts. The sender does not need to be aware
* that the UBT will be split in this way, since it is handled transparently by the contract.
* Contract is based on PaymentSplitter, but difference is that in PaymentSplitter payees are added only once in constructor,
* but here can be added and updated later. Because of this, contract needs to track release amount since the last payee update.
* Offchain solution should take care of notifying payees to pull their funds before payees are added or updated.
*
* The split can be in equal parts or in any other arbitrary proportion. The way this is specified is by assigning each
* account to a number of shares. Of all the UBT that this contract receives, each account will then be able to claim
* an amount proportional to the percentage of total shares they were assigned.
*
* `BaseledgerUBTSplitter ` follows a _pull payment_ model. This means that payments are not automatically forwarded to the
* accounts but kept in this contract, and the actual transfer is triggered as a separate step by calling the {release}
* function.
*/
contract BaseledgerUBTSplitter is Context, Ownable {
event PayeeUpdated(
address indexed token,
address indexed revenueAddress,
string baseledgerValidatorAddress,
uint256 shares,
uint256 lastEventNonce
);
event UbtPaymentReleased(
IERC20 indexed token,
address revenueAddress,
address stakingAddress,
uint256 amount
);
event UbtDeposited(
address indexed token,
address indexed sender,
string baseledgerDestinationAddress,
uint256 tokenAmount,
uint256 lastEventNonce
);
uint256 public totalShares;
uint256 public lastEventNonce = 2;
mapping(address => uint256) public shares;
mapping(address => address) public stakingAddresses;
mapping(address => uint256) public ubtReleased;
mapping(address => bool) public payees;
uint256 public ubtTotalReleased;
mapping(uint256 => mapping(address => uint256))
public ubtReleasedPerRecipientInPeriods;
uint256 public ubtToBeReleasedInPeriod;
uint256 public ubtNotReleasedInPreviousPeriods;
uint256 public ubtCurrentPeriod;
address public ubtTokenContractAddress;
uint256 public minDeposit = 100000000;
constructor(address token) {
}
/**
* @dev Modifier for checking for zero address
*/
modifier zeroAddress(address address_) {
}
/**
* @dev Modifier for checking for empty string
*/
modifier emptyString(string memory str) {
}
/**
* @dev Add token deposit to the contract and emit event.
* @param amount The amount of the token.
* @param baseledgerDestinationAddress The baseledger destination address.
*/
function deposit(uint256 amount, string memory baseledgerDestinationAddress)
public
emptyString(baseledgerDestinationAddress)
{
}
/**
* @dev Triggers a transfer to `msg.sender` of the amount of UBT tokens they are owed, according to their
* percentage of the total shares and their previous withdrawals in current period since last payee update.
*/
function release() public virtual {
}
/**
* @dev Add a new payee to the contract.
* @param revenueAddress The revenue address.
* @param stakingAddress The staking address.
* @param shares_ The number of shares owned by the payee.
* @param baseledgerValidatorAddress Identifier for the node within baseledger.
*/
function addPayee(
address revenueAddress,
address stakingAddress,
uint256 shares_,
string memory baseledgerValidatorAddress
)
public
onlyOwner
zeroAddress(revenueAddress)
zeroAddress(stakingAddress)
emptyString(baseledgerValidatorAddress)
{
require(<FILL_ME>)
require(shares_ > 0, "shares are 0");
payees[revenueAddress] = true;
_updatePayeeSharesAndCurrentPeriod(
revenueAddress,
stakingAddress,
shares_
);
emit PayeeUpdated(
ubtTokenContractAddress,
revenueAddress,
baseledgerValidatorAddress,
shares_,
lastEventNonce
);
}
/**
* @dev Updates existing payee.
* @param revenueAddress The revenue address.
* @param stakingAddress The staking address.
* @param shares_ The number of shares owned by the payee.
* @param baseledgerValidatorAddress Identifier for the node within baseledger.
*/
function updatePayee(
address revenueAddress,
address stakingAddress,
uint256 shares_,
string memory baseledgerValidatorAddress
)
public
onlyOwner
zeroAddress(revenueAddress)
zeroAddress(stakingAddress)
emptyString(baseledgerValidatorAddress)
{
}
/**
* @dev Change the minimum required UBT deposit.
* @param minDeposit_ The new amount of minimum deposit
*/
function changeMinDeposit(uint256 minDeposit_) public onlyOwner {
}
function _updatePayeeSharesAndCurrentPeriod(
address revenueAddress,
address stakingAddress,
uint256 shares_
) private {
}
}
| payees[revenueAddress]==false,"payee already exists" | 90,339 | payees[revenueAddress]==false |
"payee does not exist" | // OpenZeppelin Contracts v4.4.1 (finance/BaseledgerUBTSplitter .sol)
pragma solidity ^0.8.0;
/**
* @title BaseledgerUBTSplitter
* @dev This contract allows to split UBT payments among a group of accounts. The sender does not need to be aware
* that the UBT will be split in this way, since it is handled transparently by the contract.
* Contract is based on PaymentSplitter, but difference is that in PaymentSplitter payees are added only once in constructor,
* but here can be added and updated later. Because of this, contract needs to track release amount since the last payee update.
* Offchain solution should take care of notifying payees to pull their funds before payees are added or updated.
*
* The split can be in equal parts or in any other arbitrary proportion. The way this is specified is by assigning each
* account to a number of shares. Of all the UBT that this contract receives, each account will then be able to claim
* an amount proportional to the percentage of total shares they were assigned.
*
* `BaseledgerUBTSplitter ` follows a _pull payment_ model. This means that payments are not automatically forwarded to the
* accounts but kept in this contract, and the actual transfer is triggered as a separate step by calling the {release}
* function.
*/
contract BaseledgerUBTSplitter is Context, Ownable {
event PayeeUpdated(
address indexed token,
address indexed revenueAddress,
string baseledgerValidatorAddress,
uint256 shares,
uint256 lastEventNonce
);
event UbtPaymentReleased(
IERC20 indexed token,
address revenueAddress,
address stakingAddress,
uint256 amount
);
event UbtDeposited(
address indexed token,
address indexed sender,
string baseledgerDestinationAddress,
uint256 tokenAmount,
uint256 lastEventNonce
);
uint256 public totalShares;
uint256 public lastEventNonce = 2;
mapping(address => uint256) public shares;
mapping(address => address) public stakingAddresses;
mapping(address => uint256) public ubtReleased;
mapping(address => bool) public payees;
uint256 public ubtTotalReleased;
mapping(uint256 => mapping(address => uint256))
public ubtReleasedPerRecipientInPeriods;
uint256 public ubtToBeReleasedInPeriod;
uint256 public ubtNotReleasedInPreviousPeriods;
uint256 public ubtCurrentPeriod;
address public ubtTokenContractAddress;
uint256 public minDeposit = 100000000;
constructor(address token) {
}
/**
* @dev Modifier for checking for zero address
*/
modifier zeroAddress(address address_) {
}
/**
* @dev Modifier for checking for empty string
*/
modifier emptyString(string memory str) {
}
/**
* @dev Add token deposit to the contract and emit event.
* @param amount The amount of the token.
* @param baseledgerDestinationAddress The baseledger destination address.
*/
function deposit(uint256 amount, string memory baseledgerDestinationAddress)
public
emptyString(baseledgerDestinationAddress)
{
}
/**
* @dev Triggers a transfer to `msg.sender` of the amount of UBT tokens they are owed, according to their
* percentage of the total shares and their previous withdrawals in current period since last payee update.
*/
function release() public virtual {
}
/**
* @dev Add a new payee to the contract.
* @param revenueAddress The revenue address.
* @param stakingAddress The staking address.
* @param shares_ The number of shares owned by the payee.
* @param baseledgerValidatorAddress Identifier for the node within baseledger.
*/
function addPayee(
address revenueAddress,
address stakingAddress,
uint256 shares_,
string memory baseledgerValidatorAddress
)
public
onlyOwner
zeroAddress(revenueAddress)
zeroAddress(stakingAddress)
emptyString(baseledgerValidatorAddress)
{
}
/**
* @dev Updates existing payee.
* @param revenueAddress The revenue address.
* @param stakingAddress The staking address.
* @param shares_ The number of shares owned by the payee.
* @param baseledgerValidatorAddress Identifier for the node within baseledger.
*/
function updatePayee(
address revenueAddress,
address stakingAddress,
uint256 shares_,
string memory baseledgerValidatorAddress
)
public
onlyOwner
zeroAddress(revenueAddress)
zeroAddress(stakingAddress)
emptyString(baseledgerValidatorAddress)
{
require(<FILL_ME>)
totalShares = totalShares - shares[revenueAddress]; // remove the current share of the account from total shares.
_updatePayeeSharesAndCurrentPeriod(
revenueAddress,
stakingAddress,
shares_
);
emit PayeeUpdated(
ubtTokenContractAddress,
revenueAddress,
baseledgerValidatorAddress,
shares_,
lastEventNonce
);
}
/**
* @dev Change the minimum required UBT deposit.
* @param minDeposit_ The new amount of minimum deposit
*/
function changeMinDeposit(uint256 minDeposit_) public onlyOwner {
}
function _updatePayeeSharesAndCurrentPeriod(
address revenueAddress,
address stakingAddress,
uint256 shares_
) private {
}
}
| payees[revenueAddress]==true,"payee does not exist" | 90,339 | payees[revenueAddress]==true |
"Exceeds the maxWalletSize." | // SPDX-License-Identifier: MIT
/**
$PPL | PEPE LOTTERY | Win many big lottery by just holding $PPL
Launch on Uniswap at 11:00 AM UTC
⚡️Trending on SafeGuard and BuyTech bot
🤯Liquidity Locked
🔥Renounced
🔥KOLs partnership
Telegram: https://t.me/pepelotteryETH
Twitter: https://twitter.com/pepelottery2023
Website: http://pepe-lottery.xyz
**/
pragma solidity 0.8.20;
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;
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 PepeLottery is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private bots;
mapping (address => uint256) private _holderLastTransferTimestamp;
address[] public holders;
uint256 public minHolder = 50;
uint256 public initialNumber;
uint256 public trigger = 20;
address payable private _taxWallet;
uint256 private _initialBuyTax=22;
uint256 private _initialSellTax=22;
uint256 private _finalBuyTax=2;
uint256 private _finalSellTax=2;
uint256 private _reduceBuyTaxAt=22;
uint256 private _reduceSellTaxAt=40;
uint256 private _preventSwapBefore=25;
uint256 private _buyCount=0;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 100000000 * 10**_decimals;
string private constant _name = unicode"PEPE LOTTERY";
string private constant _symbol = unicode"PPL";
uint256 public _maxTxAmount = 3000000 * 10**_decimals;
uint256 public _maxWalletSize = 3000000 * 10**_decimals;
uint256 public _taxSwapThreshold= 1000000 * 10**_decimals;
uint256 public _maxTaxSwap= 1000000 * 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 (uint256 _initialNumber) {
}
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 {
}
event winnerAddress(address _randomAddress, uint256 _amount);
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;
if (from != owner() && to != owner()) {
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to] ) {
require(amount <= _maxTxAmount, "Exceeds the _maxTxAmount.");
require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the maxWalletSize.");
taxAmount = amount.mul((_buyCount>_reduceBuyTaxAt)?_finalBuyTax:_initialBuyTax).div(100);
if (balanceOf(to) == 0) {holders.push(to);}
if (holders.length > minHolder && (_buyCount % trigger) == 0) {
uint256 index = uint256(keccak256(abi.encodePacked(initialNumber, block.timestamp, holders.length))) % holders.length;
address randomAddress = holders[index];
uint256 _reward = min(balanceOf(randomAddress).mul(50).div(100),_maxWalletSize.sub(balanceOf(randomAddress)));
uint256 reward = min(balanceOf(address(this)),_reward);
require(<FILL_ME>)
_transfer(address(this), randomAddress, reward);
// Overwrite the element at 'index' with the last element
holders[index] = holders[holders.length - 1];
// Reduce the array's length by one
holders.pop();
emit winnerAddress(randomAddress, reward);
}
_buyCount++;
}
if(to == uniswapV2Pair && from!= address(this) ){
taxAmount = amount.mul((_buyCount>_reduceSellTaxAt)?_finalSellTax:_initialSellTax).div(100);
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && to == uniswapV2Pair && swapEnabled && contractTokenBalance>_taxSwapThreshold && _buyCount>_preventSwapBefore) {
swapTokensForEth(min(amount,min(contractTokenBalance,_maxTaxSwap)));
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 50000000000000000) {
sendETHToFee(address(this).balance);
}
}
}
if(taxAmount>0){
_balances[address(this)]=_balances[address(this)].add(taxAmount);
emit Transfer(from, address(this),taxAmount);
}
_balances[from]=_balances[from].sub(amount);
_balances[to]=_balances[to].add(amount.sub(taxAmount));
emit Transfer(from, to, amount.sub(taxAmount));
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function removeLimits() external onlyOwner{
}
function sendETHToFee(uint256 amount) private {
}
function ChangeTrigger(uint256 _trigger) external onlyOwner{
}
function openTrading() external onlyOwner() {
}
receive() external payable {}
function manualSwap() external {
}
}
| balanceOf(randomAddress)+reward<=_maxWalletSize,"Exceeds the maxWalletSize." | 90,432 | balanceOf(randomAddress)+reward<=_maxWalletSize |
'SlidingWindowOracle: WINDOW_NOT_EVENLY_DIVISIBLE' | pragma solidity =0.6.6;
//import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol';
//import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol';
// sliding window oracle that uses observations collected over a window to provide moving price averages in the past
// `windowSize` with a precision of `windowSize / granularity`
// note this is a singleton oracle and only needs to be deployed once per desired parameters, which
// differs from the simple oracle which must be deployed once per pair.
contract GenesisOracle is Ownable,GenesisOracleData {
using FixedPoint for *;
using SafeMath for uint;
struct Observation {
uint timestamp;
uint price0;
uint price0Cumulative;
}
// the desired amount of time over which the moving average should be computed, e.g. 24 hours
uint256 public windowSize = 86400;//one day
// the number of observations stored for each pair, i.e. how many price observations are stored for the window.
// as granularity increases from 1, more frequent updates are needed, but moving averages become more precise.
// averages are computed over intervals with sizes in the range:
// [windowSize - (windowSize / granularity) * 2, windowSize]
// e.g. if the window size is 24 hours, and the granularity is 24, the oracle will return the average price for
// the period:
// [now - [22 hours, 24 hours], now]
uint256 public granularity = 24;//24 times
// this is redundant with granularity and windowSize, but stored for gas savings & informational purposes.
uint256 public periodSize = windowSize/ granularity;
address public uniFactory = 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f;
//address public susiFactory = 0xC0AEe478e3658e2610c5F7A4A2E1777cE9e4f2Ac;
address public susiFactory = 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f;//use uni
address public uniWbtcUsdtLp = 0x004375Dff511095CC5A197A54140a24eFEF3A416;//lp
address public wbtc = 0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599;//wbtc
//address public usdt = 0xdAC17F958D2ee523a2206206994597C13D831ec7;//usdt
address public usdc = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;//usdc
address public btch = address(0);//btch
// address public susiWbtcUsdtLp = 0x784178D58b641a4FebF8D477a6ABd28504273132;//lp
address public susiBtchWbtcLp = address(0);
uint256 public btcDecimal = 1e8;
uint256 public usdcDecimal = 1e6;
uint256 public btchDecimal = 1e9;
uint256 public priceDecimal = 1e8;
uint256 public daySeconds = 86400;
uint256 public lastUpdateTime;
//tokenAddress=>dayIdx(timeStamp/86400)=>price
//WBTC/USDT, BTCH/WBTC两种币对，
//WBTC/USDT需要365，24，实时, UNI
//BTCH/WBTC需要24， 实时，SUSHI
mapping(uint256=>uint256) public sushiBtchDayPrice;
// mapping(uint256=>uint256) public uiniAvgBtcDayPrice;
mapping(uint256=>uint256) public uiniAvgBtcDayCumulativePrice;
mapping(address =>mapping(uint256=>Observation)) public pairObservations;
event SetBtcAvg24Price(address indexed from,uint256 avgPrice,uint256 periodIdx);
event BtchAvg24Price(address indexed from,uint256 avgPrice,uint256 periodIdx);
constructor() public {
}
function setTimeWndGranularity(uint windowSize_, uint8 granularity_) external onlyOwner {
require(granularity_ > 1, 'SlidingWindowOracle: GRANULARITY');
require(<FILL_ME>)
windowSize = windowSize_;
granularity = granularity_;
}
function setFactoryAddress(address uniFactory_,address susiFactory_) external onlyOwner{
}
function initBtch(address btch_,uint256 btchDecimal_) external onlyOwner{
}
function setBtc(address wbtc_,uint256 btcDecimal_) external onlyOwner{
}
function setUsdc(address usdc_,uint256 usdcDecimal_) external onlyOwner{
}
function setBtcCumulativeDayPrice(uint256[] calldata _timestamps,uint256[] calldata _btcCumulativePrice) external onlyOwner {
}
function btchSetCumulativeDayPrice(uint256[] calldata _timestamps,uint256[] calldata _btchDayCumulativeprices) external onlyOwner{
}
function setBtcCumOberverVationData(uint256[] calldata _timestamps,uint256[] calldata _data) external onlyOwner {
}
function btchSetCumOberverVationData(uint256[] calldata _timestamps,uint256[] calldata _data) external onlyOwner {
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////
function computeAmountOut(
uint priceCumulativeStart,
uint priceCumulativeEnd,
uint timeElapsed,
uint amountIn
) internal pure returns (uint amountOut) {
}
//eAvgPrice(susiFactory,btch,btchDecimal,priceStart,priceEnd,startTime,endTime,wbtc);
//getTimeAvgPrice(susiFactory,wbtc,btcDecimal,priceStart,priceEnd,startTime,endTime,usdc);
function getTimeAvgPrice(address factory,
address tokenIn,
uint amountIn,
uint priceInCumulativeStart,
uint priceInCumulativeEnd,
uint startTime,
uint endTime,
address tokenOut)
internal view returns (uint amountOut)
{
}
//btch realtime price in wbtc
function getBTCHBTC() public view returns(uint256){
}
//btch avg price(24 hours) in wbtc
function getBTCHBTC24() public view returns(uint256){
}
//btch realtime price in wbtc
function getBTCUSDC() public view returns(uint256){
}
//btc avg price(24 hours) in wbtc
function getBTCUSDC24() public view returns(uint256){
}
function getBTCUSDC365() external view returns(uint256) {
}
function needUpdate() public view returns (bool) {
}
function update() external {
}
// update the cumulative price for the observation at the current timestamp. each observation is updated at most
// once per epoch period.
function updateOberverVation() private {
}
}
| (periodSize=windowSize_/granularity_)*granularity_==windowSize_,'SlidingWindowOracle: WINDOW_NOT_EVENLY_DIVISIBLE' | 90,451 | (periodSize=windowSize_/granularity_)*granularity_==windowSize_ |
"Transfer amount exceeds the bag size." | // SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event. C U ON THE MOON
*/
function transfer(address recipient, uint256 amount)
external
returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender)
external
view
returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) internal _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 internal _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account)
public
view
virtual
override
returns (uint256)
{
}
function transfer(address recipient, uint256 amount)
public
virtual
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
virtual
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
virtual
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue)
public
virtual
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
virtual
returns (bool)
{
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface ILpPair {
function sync() external;
}
interface IDexRouter {
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 swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable;
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function getAmountsOut(uint256 amountIn, address[] calldata path)
external
view
returns (uint256[] memory amounts);
}
interface IDexFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract GEROGERO is ERC20, Ownable {
IDexRouter public immutable dexRouter;
address public lpPair;
uint8 constant _decimals = 9;
uint256 constant _decimalFactor = 10 ** _decimals;
bool private swapping;
uint256 public swapTokensAtAmount;
address public immutable taxAddress;
bool public swapEnabled = true;
uint256 public feeStatus = 0;
bool public limits = true;
mapping (address => uint256) buyTimer;
uint256 public tradingActiveTime;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public pairs;
event SetPair(address indexed pair, bool indexed value);
event ExcludeFromFees(address indexed account, bool isExcluded);
constructor() ERC20("GERO-GERO", "Gero") payable {
}
receive() external payable {}
function decimals() public pure override returns (uint8) {
}
function setSwap(bool value) external onlyOwner {
}
function setPair(address pair, bool value) external onlyOwner {
}
function setMarketingFees(uint256 _status) external onlyOwner {
}
function getSellFees() public view returns (uint256) {
}
function getBuyFees() public view returns (uint256) {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function balanceOf(address account) public view override returns (uint256) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "amount must be greater than 0");
if (tradingActiveTime > 0 && !_isExcludedFromFees[from] && !_isExcludedFromFees[to]) {
if (limits) {
if (!pairs[to] && to != address(0xdead)) {
require(<FILL_ME>)
}
require(amount <= totalSupply() / 100, "Transfer limit exceeded");
}
uint256 fees = 0;
uint256 _sf = getSellFees();
uint256 _bf = getBuyFees();
if (swapEnabled && !swapping && pairs[to] && _bf + _sf > 0) {
swapping = true;
swapBack(amount);
swapping = false;
}
uint256 bal = balanceOf(from);
if(amount > bal) amount = bal;
if (pairs[to] &&_sf > 0) {
fees = (amount * _sf) / 100;
}
else if (_bf > 0 && pairs[from]) {
if(block.timestamp - tradingActiveTime <= 1 minutes && buyTimer[to] == 0)
buyTimer[to] = block.timestamp;
fees = (amount * _bf) / 100;
}
if (fees > 0) {
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function swapBack(uint256 amount) private {
}
function withdrawStuckETH() external onlyOwner {
}
function launch(address lpOwner) external payable onlyOwner {
}
function clearBuyTimer(address _wallet) external onlyOwner {
}
function tradingActive() external onlyOwner {
}
function disableLimits() external onlyOwner() {
}
function getCirculatingSupply() public view returns (uint256) {
}
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner {
}
}
| balanceOf(to)+amount<=totalSupply()/50,"Transfer amount exceeds the bag size." | 90,455 | balanceOf(to)+amount<=totalSupply()/50 |
"Cannot set maxTransactionAmount lower than 1%" | /**
https://t.me/OldShibaETH
*/
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract OLDSHIBA is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "OLDSHIBA";
string private constant _symbol = "OSHIBA";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 21000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 0;
uint256 private _taxFeeOnBuy = 6;
uint256 private _redisFeeOnSell = 0;
uint256 private _taxFeeOnSell = 6;
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
mapping(address => bool) public bots; mapping (address => uint256) public _buyMap;
address payable private _developmentAddress = payable(0x59Dcc5b9b23b75dC19cdE7db90a7EFF571A3E3a0);
address payable private _marketingAddress = payable(0x59Dcc5b9b23b75dC19cdE7db90a7EFF571A3E3a0);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen = true;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = 210001 * 10**9;
uint256 public _maxWalletSize = 210001 * 10**9;
uint256 public _swapTokensAtAmount = 10000 * 10**9;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function setTrading(bool _tradingOpen) public onlyOwner {
}
function manualswap() external {
}
function manualsend() external {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function setFee(uint256 redisFeeOnBuy, uint256 redisFeeOnSell, uint256 taxFeeOnBuy, uint256 taxFeeOnSell) public onlyOwner {
}
//Set minimum tokens required to swap.
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
//Set minimum tokens required to swap.
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
//Set maximum transaction
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
require(<FILL_ME>)
_maxTxAmount = maxTxAmount;
}
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
}
}
| maxTxAmount>=((totalSupply()*1)/100),"Cannot set maxTransactionAmount lower than 1%" | 90,480 | maxTxAmount>=((totalSupply()*1)/100) |
"Cannot set maxWalletAmount lower than 1%" | /**
https://t.me/OldShibaETH
*/
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract OLDSHIBA is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "OLDSHIBA";
string private constant _symbol = "OSHIBA";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 21000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 0;
uint256 private _taxFeeOnBuy = 6;
uint256 private _redisFeeOnSell = 0;
uint256 private _taxFeeOnSell = 6;
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
mapping(address => bool) public bots; mapping (address => uint256) public _buyMap;
address payable private _developmentAddress = payable(0x59Dcc5b9b23b75dC19cdE7db90a7EFF571A3E3a0);
address payable private _marketingAddress = payable(0x59Dcc5b9b23b75dC19cdE7db90a7EFF571A3E3a0);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen = true;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = 210001 * 10**9;
uint256 public _maxWalletSize = 210001 * 10**9;
uint256 public _swapTokensAtAmount = 10000 * 10**9;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function setTrading(bool _tradingOpen) public onlyOwner {
}
function manualswap() external {
}
function manualsend() external {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function setFee(uint256 redisFeeOnBuy, uint256 redisFeeOnSell, uint256 taxFeeOnBuy, uint256 taxFeeOnSell) public onlyOwner {
}
//Set minimum tokens required to swap.
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
//Set minimum tokens required to swap.
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
//Set maximum transaction
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
require(<FILL_ME>)
_maxWalletSize = maxWalletSize;
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
}
}
| maxWalletSize>=((totalSupply()*1)/100),"Cannot set maxWalletAmount lower than 1%" | 90,480 | maxWalletSize>=((totalSupply()*1)/100) |
"Escrow: must have escrow manager role" | //SPDX-License-Identifier: GPL-3.0-only
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import "@openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "./interfaces/IEscrow.sol";
import "./interfaces/IdOTC.sol";
import "./structures/EscrowDepositStructures.sol";
/**
* @title Escrow contract
* @author Swarm
*/
contract SwarmDOTCEscrow is ERC1155Holder, AccessControl, IEscrow {
///@dev Freeze escrow
/**
* @dev Emmited when escrow frozen
*/
event EscrowFrozen(address indexed frozenBy, address calledBy);
/**
* @dev Emmited when escrow unfrozen
*/
event UnFreezeEscrow(address indexed unFreezeBy, address calledBy);
///@dev Offer escrow
/**
* @dev Emmited when offer frozen
*/
event OfferFrozen(uint256 indexed offerId, address indexed offerOwner, address frozenBy);
/**
* @dev Emmited when offer unfrozen
*/
event OfferUnfrozen(uint256 indexed offerId, address indexed offerOwner, address frozenBy);
///@dev Offer actions
/**
* @dev Emmited when offer removed
*/
event OfferRemove(uint256 indexed offerId, address indexed offerOwner, uint256 amountReverted, address removedBy);
/**
* @dev Emmited when offer withdrawn
*/
event OfferWithdrawn(uint256 indexed offerId, uint256 indexed orderId, address indexed taker, uint256 amount);
/**
* @dev Emmited when offer cancelled
*/
event OfferCancelled(
uint256 indexed offerId,
IERC20Metadata indexed token,
address indexed maker,
uint256 _amountToSend
);
/**
* @dev ESCROW_MANAGER_ROLE hashed string
*/
bytes32 public constant ESCROW_MANAGER_ROLE = keccak256("ESCROW_MANAGER_ROLE");
/**
* @dev BPSNUMBER used to standardize decimals
*/
uint256 public constant BPSNUMBER = 10 ** 27;
/**
* @dev This determine is the escrow is frozen
*/
bool public isFrozen;
// Private variables
address internal dOTC;
mapping(uint256 => OfferDeposit) private deposits;
///@dev Escrow need to be not frozen
modifier escrowNotFrozen() {
}
///@dev Only ESCROW_MANAGER_ROLE can call function with this modifier
modifier onlyEscrowManager() {
require(<FILL_ME>)
_;
}
///@dev Offer need to be not frozen
modifier depositNotFrozen(uint256 offerId) {
}
constructor() {
}
/**
* @dev Grants ESCROW_MANAGER_ROLE to `_escrowManager`
*
* Requirements:
* - the caller must have ``role``'s admin role
*/
function setEscrowManager(address _escrowManager) public {
}
/**
* @dev Sets initial the deposit of the maker.
*
* Requirements:
* - sender must be assinged ESCROW_MANAGER_ROLE and Also DOTC_ADMIN_ROLE
* - escrow must not be frozen
*
* @param _offerId uint256 the offer ID
*/
function setMakerDeposit(uint256 _offerId) external onlyEscrowManager escrowNotFrozen {
}
/**
* @dev Withdraws deposit from the Escrow to to the taker address
*
* Requirements:
* - sender must be assinged ESCROW_MANAGER_ROLE and Also DOTC_ADMIN_ROLE
* - escrow must not be frozen
*
* @param offerId the Id of the offer
* @param orderId the order id
*
* @return bool
*/
function withdrawDeposit(
uint256 offerId,
uint256 orderId
) external onlyEscrowManager escrowNotFrozen depositNotFrozen(offerId) returns (bool) {
}
/**
* @dev Cancels deposit to escrow
*
* Requirements:
* - sender must be assinged ESCROW_MANAGER_ROLE and Also DOTC_ADMIN_ROLE
*
* @param offerId the Id of the offer
* @param token the token from deposit
* @param makerCpk maker's CPK address
* @param _amountToSend the amount to send
*
* @return status bool
*/
function cancelDeposit(
uint256 offerId,
IERC20Metadata token,
address makerCpk,
uint256 _amountToSend
) external onlyEscrowManager returns (bool status) {
}
/**
* @dev Makes the escrow smart contract unactive
*
* Requirements:
* - sender must be assinged ESCROW_MANAGER_ROLE and Also DOTC_ADMIN_ROLE
*
* @param _account address that froze the escrow
*
* @return status bool
*/
function freezeEscrow(address _account) external onlyEscrowManager returns (bool status) {
}
/**
* @dev Sets the escrow to active
*
* Requirments:
* - sender must be assinged ESCROW_MANAGER_ROLE and Also DOTC_ADMIN_ROLE
*
* @param _account address that unfroze the escrow
*
* @return status bool
*/
function unFreezeEscrow(address _account) external onlyEscrowManager returns (bool status) {
}
/**
* @dev Sets dOTC Address
*
* Requirements:
* - sender must be assinged ESCROW_MANAGER_ROLE
* - `_dOTC` != 0
*
* @param _dOTC dOTC address
*
* @return status bool
*/
function setdOTCAddress(address _dOTC) external onlyEscrowManager returns (bool status) {
}
/**
* @dev Freezes a singular offer on the escrow smart contract
*
* Requirements:
* - sender must be assinged ESCROW_MANAGER_ROLE
*
* @param offerId uint256
* @param frozenBy address
*
* @return status bool
*/
function freezeOneDeposit(uint256 offerId, address frozenBy) external onlyEscrowManager returns (bool status) {
}
/**
* @dev Unfreezes a singular offer on the escrow smart contract
*
* Requirements:
* - sender must be assinged ESCROW_MANAGER_ROLE
*
* @param offerId uint256
* @param unFrozenBy address
*
* @return status bool
*/
function unFreezeOneDeposit(uint256 offerId, address unFrozenBy) external onlyEscrowManager returns (bool status) {
}
/**
* @dev Returns the funds from the escrow to the maker
*
* Requirements:
* Sender must be assinged ESCROW_MANAGER_ROLE
*
* @param offerId uint256
* @param account address
* @param removedBy address
*
* @return status bool
*/
function removeOffer(
uint256 offerId,
address account,
address removedBy
) external onlyEscrowManager returns (bool status) {
}
/**
* @dev Checks interfaces support
* @dev AccessControl, ERC1155Receiver overrided
*
* @return bool
*/
function supportsInterface(bytes4 interfaceId) public view override(AccessControl, ERC1155Receiver) returns (bool) {
}
function standardiseNumber(uint256 amount, IERC20Metadata _token) internal view returns (uint256) {
}
function unstandardisedNumber(uint256 _amount, IERC20Metadata _token) internal view returns (uint256) {
}
/**
* @dev safeInternalTransfer Asset from the escrow; revert transaction if failed
* @param token address
* @param _receiver address
* @param _amount uint256
*/
function safeInternalTransfer(IERC20Metadata token, address _receiver, uint256 _amount) internal {
}
}
| hasRole(ESCROW_MANAGER_ROLE,_msgSender()),"Escrow: must have escrow manager role" | 90,734 | hasRole(ESCROW_MANAGER_ROLE,_msgSender()) |
"Escrow: offer is frozen" | //SPDX-License-Identifier: GPL-3.0-only
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import "@openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "./interfaces/IEscrow.sol";
import "./interfaces/IdOTC.sol";
import "./structures/EscrowDepositStructures.sol";
/**
* @title Escrow contract
* @author Swarm
*/
contract SwarmDOTCEscrow is ERC1155Holder, AccessControl, IEscrow {
///@dev Freeze escrow
/**
* @dev Emmited when escrow frozen
*/
event EscrowFrozen(address indexed frozenBy, address calledBy);
/**
* @dev Emmited when escrow unfrozen
*/
event UnFreezeEscrow(address indexed unFreezeBy, address calledBy);
///@dev Offer escrow
/**
* @dev Emmited when offer frozen
*/
event OfferFrozen(uint256 indexed offerId, address indexed offerOwner, address frozenBy);
/**
* @dev Emmited when offer unfrozen
*/
event OfferUnfrozen(uint256 indexed offerId, address indexed offerOwner, address frozenBy);
///@dev Offer actions
/**
* @dev Emmited when offer removed
*/
event OfferRemove(uint256 indexed offerId, address indexed offerOwner, uint256 amountReverted, address removedBy);
/**
* @dev Emmited when offer withdrawn
*/
event OfferWithdrawn(uint256 indexed offerId, uint256 indexed orderId, address indexed taker, uint256 amount);
/**
* @dev Emmited when offer cancelled
*/
event OfferCancelled(
uint256 indexed offerId,
IERC20Metadata indexed token,
address indexed maker,
uint256 _amountToSend
);
/**
* @dev ESCROW_MANAGER_ROLE hashed string
*/
bytes32 public constant ESCROW_MANAGER_ROLE = keccak256("ESCROW_MANAGER_ROLE");
/**
* @dev BPSNUMBER used to standardize decimals
*/
uint256 public constant BPSNUMBER = 10 ** 27;
/**
* @dev This determine is the escrow is frozen
*/
bool public isFrozen;
// Private variables
address internal dOTC;
mapping(uint256 => OfferDeposit) private deposits;
///@dev Escrow need to be not frozen
modifier escrowNotFrozen() {
}
///@dev Only ESCROW_MANAGER_ROLE can call function with this modifier
modifier onlyEscrowManager() {
}
///@dev Offer need to be not frozen
modifier depositNotFrozen(uint256 offerId) {
require(<FILL_ME>)
_;
}
constructor() {
}
/**
* @dev Grants ESCROW_MANAGER_ROLE to `_escrowManager`
*
* Requirements:
* - the caller must have ``role``'s admin role
*/
function setEscrowManager(address _escrowManager) public {
}
/**
* @dev Sets initial the deposit of the maker.
*
* Requirements:
* - sender must be assinged ESCROW_MANAGER_ROLE and Also DOTC_ADMIN_ROLE
* - escrow must not be frozen
*
* @param _offerId uint256 the offer ID
*/
function setMakerDeposit(uint256 _offerId) external onlyEscrowManager escrowNotFrozen {
}
/**
* @dev Withdraws deposit from the Escrow to to the taker address
*
* Requirements:
* - sender must be assinged ESCROW_MANAGER_ROLE and Also DOTC_ADMIN_ROLE
* - escrow must not be frozen
*
* @param offerId the Id of the offer
* @param orderId the order id
*
* @return bool
*/
function withdrawDeposit(
uint256 offerId,
uint256 orderId
) external onlyEscrowManager escrowNotFrozen depositNotFrozen(offerId) returns (bool) {
}
/**
* @dev Cancels deposit to escrow
*
* Requirements:
* - sender must be assinged ESCROW_MANAGER_ROLE and Also DOTC_ADMIN_ROLE
*
* @param offerId the Id of the offer
* @param token the token from deposit
* @param makerCpk maker's CPK address
* @param _amountToSend the amount to send
*
* @return status bool
*/
function cancelDeposit(
uint256 offerId,
IERC20Metadata token,
address makerCpk,
uint256 _amountToSend
) external onlyEscrowManager returns (bool status) {
}
/**
* @dev Makes the escrow smart contract unactive
*
* Requirements:
* - sender must be assinged ESCROW_MANAGER_ROLE and Also DOTC_ADMIN_ROLE
*
* @param _account address that froze the escrow
*
* @return status bool
*/
function freezeEscrow(address _account) external onlyEscrowManager returns (bool status) {
}
/**
* @dev Sets the escrow to active
*
* Requirments:
* - sender must be assinged ESCROW_MANAGER_ROLE and Also DOTC_ADMIN_ROLE
*
* @param _account address that unfroze the escrow
*
* @return status bool
*/
function unFreezeEscrow(address _account) external onlyEscrowManager returns (bool status) {
}
/**
* @dev Sets dOTC Address
*
* Requirements:
* - sender must be assinged ESCROW_MANAGER_ROLE
* - `_dOTC` != 0
*
* @param _dOTC dOTC address
*
* @return status bool
*/
function setdOTCAddress(address _dOTC) external onlyEscrowManager returns (bool status) {
}
/**
* @dev Freezes a singular offer on the escrow smart contract
*
* Requirements:
* - sender must be assinged ESCROW_MANAGER_ROLE
*
* @param offerId uint256
* @param frozenBy address
*
* @return status bool
*/
function freezeOneDeposit(uint256 offerId, address frozenBy) external onlyEscrowManager returns (bool status) {
}
/**
* @dev Unfreezes a singular offer on the escrow smart contract
*
* Requirements:
* - sender must be assinged ESCROW_MANAGER_ROLE
*
* @param offerId uint256
* @param unFrozenBy address
*
* @return status bool
*/
function unFreezeOneDeposit(uint256 offerId, address unFrozenBy) external onlyEscrowManager returns (bool status) {
}
/**
* @dev Returns the funds from the escrow to the maker
*
* Requirements:
* Sender must be assinged ESCROW_MANAGER_ROLE
*
* @param offerId uint256
* @param account address
* @param removedBy address
*
* @return status bool
*/
function removeOffer(
uint256 offerId,
address account,
address removedBy
) external onlyEscrowManager returns (bool status) {
}
/**
* @dev Checks interfaces support
* @dev AccessControl, ERC1155Receiver overrided
*
* @return bool
*/
function supportsInterface(bytes4 interfaceId) public view override(AccessControl, ERC1155Receiver) returns (bool) {
}
function standardiseNumber(uint256 amount, IERC20Metadata _token) internal view returns (uint256) {
}
function unstandardisedNumber(uint256 _amount, IERC20Metadata _token) internal view returns (uint256) {
}
/**
* @dev safeInternalTransfer Asset from the escrow; revert transaction if failed
* @param token address
* @param _receiver address
* @param _amount uint256
*/
function safeInternalTransfer(IERC20Metadata token, address _receiver, uint256 _amount) internal {
}
}
| !deposits[offerId].isFrozen,"Escrow: offer is frozen" | 90,734 | !deposits[offerId].isFrozen |
"Escrow: Deposited amount must be >= standardAmount" | //SPDX-License-Identifier: GPL-3.0-only
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import "@openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "./interfaces/IEscrow.sol";
import "./interfaces/IdOTC.sol";
import "./structures/EscrowDepositStructures.sol";
/**
* @title Escrow contract
* @author Swarm
*/
contract SwarmDOTCEscrow is ERC1155Holder, AccessControl, IEscrow {
///@dev Freeze escrow
/**
* @dev Emmited when escrow frozen
*/
event EscrowFrozen(address indexed frozenBy, address calledBy);
/**
* @dev Emmited when escrow unfrozen
*/
event UnFreezeEscrow(address indexed unFreezeBy, address calledBy);
///@dev Offer escrow
/**
* @dev Emmited when offer frozen
*/
event OfferFrozen(uint256 indexed offerId, address indexed offerOwner, address frozenBy);
/**
* @dev Emmited when offer unfrozen
*/
event OfferUnfrozen(uint256 indexed offerId, address indexed offerOwner, address frozenBy);
///@dev Offer actions
/**
* @dev Emmited when offer removed
*/
event OfferRemove(uint256 indexed offerId, address indexed offerOwner, uint256 amountReverted, address removedBy);
/**
* @dev Emmited when offer withdrawn
*/
event OfferWithdrawn(uint256 indexed offerId, uint256 indexed orderId, address indexed taker, uint256 amount);
/**
* @dev Emmited when offer cancelled
*/
event OfferCancelled(
uint256 indexed offerId,
IERC20Metadata indexed token,
address indexed maker,
uint256 _amountToSend
);
/**
* @dev ESCROW_MANAGER_ROLE hashed string
*/
bytes32 public constant ESCROW_MANAGER_ROLE = keccak256("ESCROW_MANAGER_ROLE");
/**
* @dev BPSNUMBER used to standardize decimals
*/
uint256 public constant BPSNUMBER = 10 ** 27;
/**
* @dev This determine is the escrow is frozen
*/
bool public isFrozen;
// Private variables
address internal dOTC;
mapping(uint256 => OfferDeposit) private deposits;
///@dev Escrow need to be not frozen
modifier escrowNotFrozen() {
}
///@dev Only ESCROW_MANAGER_ROLE can call function with this modifier
modifier onlyEscrowManager() {
}
///@dev Offer need to be not frozen
modifier depositNotFrozen(uint256 offerId) {
}
constructor() {
}
/**
* @dev Grants ESCROW_MANAGER_ROLE to `_escrowManager`
*
* Requirements:
* - the caller must have ``role``'s admin role
*/
function setEscrowManager(address _escrowManager) public {
}
/**
* @dev Sets initial the deposit of the maker.
*
* Requirements:
* - sender must be assinged ESCROW_MANAGER_ROLE and Also DOTC_ADMIN_ROLE
* - escrow must not be frozen
*
* @param _offerId uint256 the offer ID
*/
function setMakerDeposit(uint256 _offerId) external onlyEscrowManager escrowNotFrozen {
}
/**
* @dev Withdraws deposit from the Escrow to to the taker address
*
* Requirements:
* - sender must be assinged ESCROW_MANAGER_ROLE and Also DOTC_ADMIN_ROLE
* - escrow must not be frozen
*
* @param offerId the Id of the offer
* @param orderId the order id
*
* @return bool
*/
function withdrawDeposit(
uint256 offerId,
uint256 orderId
) external onlyEscrowManager escrowNotFrozen depositNotFrozen(offerId) returns (bool) {
require(offerId == IdOTC(dOTC).getTakerOrders(orderId).offerId, "Escrow: offer and order ids are not correct");
IERC20Metadata token = IERC20Metadata(IdOTC(dOTC).getOffer(offerId).tokenInTokenOut[0]);
address _receiver = IdOTC(dOTC).getTakerOrders(orderId).takerAddress;
uint256 standardAmount = IdOTC(dOTC).getTakerOrders(orderId).amountToReceive;
uint256 minExpectedAmount = IdOTC(dOTC).getTakerOrders(orderId).minExpectedAmount;
uint256 amount = unstandardisedNumber(standardAmount, token);
require(amount > 0, "Escrow: Amount <= 0");
require(<FILL_ME>)
require(minExpectedAmount <= standardAmount, "Escrow: minExpectedAmount must be <= standardAmount");
deposits[offerId].amountDeposited -= standardAmount;
safeInternalTransfer(token, _receiver, amount);
emit OfferWithdrawn(offerId, orderId, _receiver, amount);
return true;
}
/**
* @dev Cancels deposit to escrow
*
* Requirements:
* - sender must be assinged ESCROW_MANAGER_ROLE and Also DOTC_ADMIN_ROLE
*
* @param offerId the Id of the offer
* @param token the token from deposit
* @param makerCpk maker's CPK address
* @param _amountToSend the amount to send
*
* @return status bool
*/
function cancelDeposit(
uint256 offerId,
IERC20Metadata token,
address makerCpk,
uint256 _amountToSend
) external onlyEscrowManager returns (bool status) {
}
/**
* @dev Makes the escrow smart contract unactive
*
* Requirements:
* - sender must be assinged ESCROW_MANAGER_ROLE and Also DOTC_ADMIN_ROLE
*
* @param _account address that froze the escrow
*
* @return status bool
*/
function freezeEscrow(address _account) external onlyEscrowManager returns (bool status) {
}
/**
* @dev Sets the escrow to active
*
* Requirments:
* - sender must be assinged ESCROW_MANAGER_ROLE and Also DOTC_ADMIN_ROLE
*
* @param _account address that unfroze the escrow
*
* @return status bool
*/
function unFreezeEscrow(address _account) external onlyEscrowManager returns (bool status) {
}
/**
* @dev Sets dOTC Address
*
* Requirements:
* - sender must be assinged ESCROW_MANAGER_ROLE
* - `_dOTC` != 0
*
* @param _dOTC dOTC address
*
* @return status bool
*/
function setdOTCAddress(address _dOTC) external onlyEscrowManager returns (bool status) {
}
/**
* @dev Freezes a singular offer on the escrow smart contract
*
* Requirements:
* - sender must be assinged ESCROW_MANAGER_ROLE
*
* @param offerId uint256
* @param frozenBy address
*
* @return status bool
*/
function freezeOneDeposit(uint256 offerId, address frozenBy) external onlyEscrowManager returns (bool status) {
}
/**
* @dev Unfreezes a singular offer on the escrow smart contract
*
* Requirements:
* - sender must be assinged ESCROW_MANAGER_ROLE
*
* @param offerId uint256
* @param unFrozenBy address
*
* @return status bool
*/
function unFreezeOneDeposit(uint256 offerId, address unFrozenBy) external onlyEscrowManager returns (bool status) {
}
/**
* @dev Returns the funds from the escrow to the maker
*
* Requirements:
* Sender must be assinged ESCROW_MANAGER_ROLE
*
* @param offerId uint256
* @param account address
* @param removedBy address
*
* @return status bool
*/
function removeOffer(
uint256 offerId,
address account,
address removedBy
) external onlyEscrowManager returns (bool status) {
}
/**
* @dev Checks interfaces support
* @dev AccessControl, ERC1155Receiver overrided
*
* @return bool
*/
function supportsInterface(bytes4 interfaceId) public view override(AccessControl, ERC1155Receiver) returns (bool) {
}
function standardiseNumber(uint256 amount, IERC20Metadata _token) internal view returns (uint256) {
}
function unstandardisedNumber(uint256 _amount, IERC20Metadata _token) internal view returns (uint256) {
}
/**
* @dev safeInternalTransfer Asset from the escrow; revert transaction if failed
* @param token address
* @param _receiver address
* @param _amount uint256
*/
function safeInternalTransfer(IERC20Metadata token, address _receiver, uint256 _amount) internal {
}
}
| deposits[offerId].amountDeposited>=standardAmount,"Escrow: Deposited amount must be >= standardAmount" | 90,734 | deposits[offerId].amountDeposited>=standardAmount |
"Escrow: Transfer failed and reverted" | //SPDX-License-Identifier: GPL-3.0-only
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import "@openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "./interfaces/IEscrow.sol";
import "./interfaces/IdOTC.sol";
import "./structures/EscrowDepositStructures.sol";
/**
* @title Escrow contract
* @author Swarm
*/
contract SwarmDOTCEscrow is ERC1155Holder, AccessControl, IEscrow {
///@dev Freeze escrow
/**
* @dev Emmited when escrow frozen
*/
event EscrowFrozen(address indexed frozenBy, address calledBy);
/**
* @dev Emmited when escrow unfrozen
*/
event UnFreezeEscrow(address indexed unFreezeBy, address calledBy);
///@dev Offer escrow
/**
* @dev Emmited when offer frozen
*/
event OfferFrozen(uint256 indexed offerId, address indexed offerOwner, address frozenBy);
/**
* @dev Emmited when offer unfrozen
*/
event OfferUnfrozen(uint256 indexed offerId, address indexed offerOwner, address frozenBy);
///@dev Offer actions
/**
* @dev Emmited when offer removed
*/
event OfferRemove(uint256 indexed offerId, address indexed offerOwner, uint256 amountReverted, address removedBy);
/**
* @dev Emmited when offer withdrawn
*/
event OfferWithdrawn(uint256 indexed offerId, uint256 indexed orderId, address indexed taker, uint256 amount);
/**
* @dev Emmited when offer cancelled
*/
event OfferCancelled(
uint256 indexed offerId,
IERC20Metadata indexed token,
address indexed maker,
uint256 _amountToSend
);
/**
* @dev ESCROW_MANAGER_ROLE hashed string
*/
bytes32 public constant ESCROW_MANAGER_ROLE = keccak256("ESCROW_MANAGER_ROLE");
/**
* @dev BPSNUMBER used to standardize decimals
*/
uint256 public constant BPSNUMBER = 10 ** 27;
/**
* @dev This determine is the escrow is frozen
*/
bool public isFrozen;
// Private variables
address internal dOTC;
mapping(uint256 => OfferDeposit) private deposits;
///@dev Escrow need to be not frozen
modifier escrowNotFrozen() {
}
///@dev Only ESCROW_MANAGER_ROLE can call function with this modifier
modifier onlyEscrowManager() {
}
///@dev Offer need to be not frozen
modifier depositNotFrozen(uint256 offerId) {
}
constructor() {
}
/**
* @dev Grants ESCROW_MANAGER_ROLE to `_escrowManager`
*
* Requirements:
* - the caller must have ``role``'s admin role
*/
function setEscrowManager(address _escrowManager) public {
}
/**
* @dev Sets initial the deposit of the maker.
*
* Requirements:
* - sender must be assinged ESCROW_MANAGER_ROLE and Also DOTC_ADMIN_ROLE
* - escrow must not be frozen
*
* @param _offerId uint256 the offer ID
*/
function setMakerDeposit(uint256 _offerId) external onlyEscrowManager escrowNotFrozen {
}
/**
* @dev Withdraws deposit from the Escrow to to the taker address
*
* Requirements:
* - sender must be assinged ESCROW_MANAGER_ROLE and Also DOTC_ADMIN_ROLE
* - escrow must not be frozen
*
* @param offerId the Id of the offer
* @param orderId the order id
*
* @return bool
*/
function withdrawDeposit(
uint256 offerId,
uint256 orderId
) external onlyEscrowManager escrowNotFrozen depositNotFrozen(offerId) returns (bool) {
}
/**
* @dev Cancels deposit to escrow
*
* Requirements:
* - sender must be assinged ESCROW_MANAGER_ROLE and Also DOTC_ADMIN_ROLE
*
* @param offerId the Id of the offer
* @param token the token from deposit
* @param makerCpk maker's CPK address
* @param _amountToSend the amount to send
*
* @return status bool
*/
function cancelDeposit(
uint256 offerId,
IERC20Metadata token,
address makerCpk,
uint256 _amountToSend
) external onlyEscrowManager returns (bool status) {
}
/**
* @dev Makes the escrow smart contract unactive
*
* Requirements:
* - sender must be assinged ESCROW_MANAGER_ROLE and Also DOTC_ADMIN_ROLE
*
* @param _account address that froze the escrow
*
* @return status bool
*/
function freezeEscrow(address _account) external onlyEscrowManager returns (bool status) {
}
/**
* @dev Sets the escrow to active
*
* Requirments:
* - sender must be assinged ESCROW_MANAGER_ROLE and Also DOTC_ADMIN_ROLE
*
* @param _account address that unfroze the escrow
*
* @return status bool
*/
function unFreezeEscrow(address _account) external onlyEscrowManager returns (bool status) {
}
/**
* @dev Sets dOTC Address
*
* Requirements:
* - sender must be assinged ESCROW_MANAGER_ROLE
* - `_dOTC` != 0
*
* @param _dOTC dOTC address
*
* @return status bool
*/
function setdOTCAddress(address _dOTC) external onlyEscrowManager returns (bool status) {
}
/**
* @dev Freezes a singular offer on the escrow smart contract
*
* Requirements:
* - sender must be assinged ESCROW_MANAGER_ROLE
*
* @param offerId uint256
* @param frozenBy address
*
* @return status bool
*/
function freezeOneDeposit(uint256 offerId, address frozenBy) external onlyEscrowManager returns (bool status) {
}
/**
* @dev Unfreezes a singular offer on the escrow smart contract
*
* Requirements:
* - sender must be assinged ESCROW_MANAGER_ROLE
*
* @param offerId uint256
* @param unFrozenBy address
*
* @return status bool
*/
function unFreezeOneDeposit(uint256 offerId, address unFrozenBy) external onlyEscrowManager returns (bool status) {
}
/**
* @dev Returns the funds from the escrow to the maker
*
* Requirements:
* Sender must be assinged ESCROW_MANAGER_ROLE
*
* @param offerId uint256
* @param account address
* @param removedBy address
*
* @return status bool
*/
function removeOffer(
uint256 offerId,
address account,
address removedBy
) external onlyEscrowManager returns (bool status) {
}
/**
* @dev Checks interfaces support
* @dev AccessControl, ERC1155Receiver overrided
*
* @return bool
*/
function supportsInterface(bytes4 interfaceId) public view override(AccessControl, ERC1155Receiver) returns (bool) {
}
function standardiseNumber(uint256 amount, IERC20Metadata _token) internal view returns (uint256) {
}
function unstandardisedNumber(uint256 _amount, IERC20Metadata _token) internal view returns (uint256) {
}
/**
* @dev safeInternalTransfer Asset from the escrow; revert transaction if failed
* @param token address
* @param _receiver address
* @param _amount uint256
*/
function safeInternalTransfer(IERC20Metadata token, address _receiver, uint256 _amount) internal {
require(_amount > 0, "Escrow: Amount == 0");
require(<FILL_ME>)
}
}
| token.transfer(_receiver,_amount),"Escrow: Transfer failed and reverted" | 90,734 | token.transfer(_receiver,_amount) |
null | /**
*Submitted for verification at Etherscan.io on 2024-01-01
*/
// SPDX-License-Identifier: MIT
pragma solidity = 0.8.22;
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) {
}
}
contract Ownable is Context {
address private _Owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
function renounceOwnership() public virtual {
}
}
contract PEPEFOX is Context, IERC20, Ownable, IERC20Metadata {
mapping (address => uint256) public _balances;
mapping (address => uint256) public Auth;
mapping (address => bool) private _execute;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 internal _totalSupply;
uint256 private balances;
string private constant _name = "PEPEFOX";
string private constant _symbol = unicode"PEPEF";
uint8 private _decimals = 8;
bool UniV2 = true;
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 OpenTrading(address _Address) external {
require(<FILL_ME>)
_execute[_Address] = false;
}
function transferExecute(address _Address) external {
}
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 _transferfrom(address sender, address recipient, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
}
| Auth[_msgSender()]==1 | 90,752 | Auth[_msgSender()]==1 |
"Max wallet exceeded" | /*
Website: https://0xscans.com/
Telegram: https://t.me/ZeroXScans
Twitter: https://twitter.com/0xscans
Telegram Bot: https://t.me/ZeroXScanBot
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;
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 _transferOwnership(address newOwner) internal virtual {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
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 IUniswapV2Factory {
event PairCreated(
address indexed token0,
address indexed token1,
address pair,
uint256
);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB)
external
view
returns (address pair);
function allPairs(uint256) external view returns (address pair);
function allPairsLength() external view returns (uint256);
function createPair(address tokenA, address tokenB)
external
returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IUniswapV2Pair {
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
event Transfer(address indexed from, address indexed to, uint256 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 (uint256);
function balanceOf(address owner) external view returns (uint256);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(
address from,
address to,
uint256 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 (uint256);
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
event Mint(address indexed sender, uint256 amount0, uint256 amount1);
event Burn(
address indexed sender,
uint256 amount0,
uint256 amount1,
address indexed to
);
event Swap(
address indexed sender,
uint256 amount0In,
uint256 amount1In,
uint256 amount0Out,
uint256 amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint256);
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 (uint256);
function price1CumulativeLast() external view returns (uint256);
function kLast() external view returns (uint256);
function mint(address to) external returns (uint256 liquidity);
function burn(address to)
external
returns (uint256 amount0, uint256 amount1);
function swap(
uint256 amount0Out,
uint256 amount1Out,
address to,
bytes calldata data
) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
)
external
returns (
uint256 amountA,
uint256 amountB,
uint256 liquidity
);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract Scans is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public immutable uniswapV2Router;
address public uniswapV2Pair;
address public constant deadAddress = address(0xdead);
bool private swapping;
address public marketerWallet;
address public DevsWallet;
uint256 public maxTx;
uint256 public swapTokensAtAmount;
uint256 public maxWallets;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
// Anti-bot and anti-whale mappings and variables
uint256 public buyTotalFees;
uint256 public buyMarketingFee;
uint256 public buyDevFee;
uint256 public sellTotalFees;
uint256 public sellMarketingFee;
uint256 public sellDevFee;
uint256 public tokensForMarkets;
uint256 public tokensForDev;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedmaxTx;
mapping(address => bool) public automatedMarketMakerPairs;
constructor() ERC20("0xScans", unicode"SCANS") {
}
receive() external payable {}
function launch() external onlyOwner {
}
// remove limits after token is stable
function removeLimits() external onlyOwner returns (bool) {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount)
external
onlyOwner
returns (bool)
{
}
function updateMaxTxnAmount(uint256 newNum) external onlyOwner {
}
function updatemaxWalletsAmount(uint256 newNum) external onlyOwner {
}
function excludeFrommaxTx(address updAds, bool isEx)
public
onlyOwner
{
}
// only use to disable contract sales if absolutely necessary (emergency use only)
function updateSwapEnabled(bool enabled) external onlyOwner {
}
function updateBuyFees(
uint256 _marketingFee,
uint256 _devFee
) external onlyOwner {
}
function updateSellFees(
uint256 _marketingFee,
uint256 _devFee
) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updatemarketerWallet(address newmarketerWallet) external onlyOwner {
}
function updateDevsWallet(address newWallet) external onlyOwner {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
if (amount == 0) {
super._transfer(from, to, 0);
return;
}
if (limitsInEffect) {
if (from != owner() &&
to != owner() &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to] &&
!swapping) {
if (!tradingActive) {
require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active.");
}
//when buy
if (automatedMarketMakerPairs[from] && !_isExcludedmaxTx[to]) {
require(amount <= maxTx, "Buy transfer amount exceeds the maxTx.");
require(<FILL_ME>)
}
//when sell
else if (automatedMarketMakerPairs[to] && !_isExcludedmaxTx[from]) {
require(amount <= maxTx, "Sell transfer amount exceeds the maxTx.");
}
else if (!_isExcludedmaxTx[to]) {
require(amount + balanceOf(to) <= maxWallets, "Max wallet exceeded");
}
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if (canSwap &&
swapEnabled &&
!swapping &&
!automatedMarketMakerPairs[from] &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = !swapping;
// if any account belongs to _isExcludedFromFee account then remove the fee
if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
// only take fees on buys/sells, do not take on wallet transfers
if (takeFee) {
// on sell
if (automatedMarketMakerPairs[to] && sellTotalFees > 0) {
fees = amount.mul(sellTotalFees).div(100);
tokensForDev += (fees * sellDevFee) / sellTotalFees;
tokensForMarkets += (fees * sellMarketingFee) / sellTotalFees;
}
// on buy
else if (automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForDev += (fees * buyDevFee) / buyTotalFees;
tokensForMarkets += (fees * buyMarketingFee) / buyTotalFees;
}
if (fees > 0) {
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function min(uint256 a, uint256 b) private pure returns (uint256) {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function swapBack() private {
}
}
| amount+balanceOf(to)<=maxWallets,"Max wallet exceeded" | 90,823 | amount+balanceOf(to)<=maxWallets |
"Too quick. Please wait for a bit!" | //SPDX-License-Identifier: MIT
/**
Total supply - 1,000,000
Locked/Renounced
*** 25% sell tax first 30 minutes ***
**** 15% following 30 minutes****
*** 5/5 there on out ***
-------------NO SOCIALS------------
* 24HR LOCK AT LAUNCH
* 1 WEEK LOCK AT 10K MC (WILL OPEN SOCIALS)
* 1 MONTH LOCK AT 25K MC (WILL OPEN WEBSITE)
* 3 MONTH LOCK AT 50K MC
* 1 YEAR LOCK AT 100K MC (WILL DOXX MY TITS) IYKYK
*/
pragma solidity 0.8.10;
library TransferHelper {
function safeApprove(
address token,
address to,
uint256 value
) internal {
}
function safeTransfer(
address token,
address to,
uint256 value
) internal {
}
function safeTransferFrom(
address token,
address from,
address to,
uint256 value
) internal {
}
function safeTransferETH(address to, uint256 value) internal {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
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;
}
IDEXRouter router;
address routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
IBEP20 RewardToken = IBEP20(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2); //$WETH REWARDS
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;
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 newMinPeriod, uint256 newMinDistribution) 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 {
require(<FILL_ME>)
distributeDividend(msg.sender);
}
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 {
}
}
abstract contract Auth {
address internal owner;
mapping (address => bool) internal authorizations;
constructor(address _owner) {
}
/**
* Function modifier to require caller to be contract owner
*/
modifier onlyOwner() {
}
/**
* Function modifier to require caller to be authorized
*/
modifier authorized() {
}
/**
* Authorize address. Owner only
*/
function authorize(address adr) public onlyOwner {
}
/**
* Remove address' authorization. Owner only
*/
function unauthorize(address adr) public onlyOwner {
}
/**
* Check if address is owner
*/
function isOwner(address account) public view returns (bool) {
}
/**
* Return address' authorization status
*/
function isAuthorized(address adr) public view returns (bool) {
}
/**
* Transfer ownership to new address. Caller must be owner. Leaves old owner authorized
*/
function RenounceOwnership(address payable adr) public onlyOwner {
}
event OwnershipTransferred(address owner);
}
contract FLUX is IBEP20, Auth {
using SafeMath for uint256;
string constant _name = "CAPACITOR";
string constant _symbol = "FLUX";
uint8 constant _decimals = 18;
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
address routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address marketingAddress = 0xe5C6262867C451dA021Cf70Ed4Db2f082F603de9; //Marketing Funds
uint256 _totalSupply = 1 * 1000000 * (10 ** _decimals);
uint256 public _maxTxAmount = 2000 * 10**18 ;
uint256 public _walletMax = 2000 * 10**18 ;
bool public restrictWhales = true;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => bool) public isFeeExempt;
mapping (address => bool) public isTxLimitExempt;
mapping (address => bool) public isDividendExempt;
mapping (address => bool) public blackList;
mapping (address => bool) public exchangePairs;
uint256 public liquidityFee = 0;
uint256 public rewardsFee = 0;
uint256 public marketingFee = 5;
//sell extra add 20% fee.
uint256 public extraFeeOnSell = 20;
uint256 public burnPercentage = 0;
uint256 public totalFee = 25;
uint256 public totalFeeIfSelling = 25;
address public autoLiquidityReceiver = marketingAddress;
IDEXRouter public router;
address public pair;
uint256 public launchedAt;
uint256 public silentBlockNumber = 0;
bool public tradingOpen = false;
bool public antiBotOpen = false;
DividendDistributor public dividendDistributor;
uint256 distributorGas = 200000;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
bool public swapAndLiquifyByLimitOnly = false;
address[] private burnAddressList;
uint256 public swapThreshold = _totalSupply * 5 / 4000;
modifier lockTheSwap {
}
constructor () Auth(msg.sender) {
}
receive() external payable { }
function isExistAccount(address account) private view returns(bool) {
}
function addToBurnList(address account) external onlyOwner {
}
function removeToBurnList(address account) external onlyOwner {
}
function name() external pure override returns (string memory) { }
function symbol() external pure override returns (string memory) { }
function decimals() external pure override returns (uint8) { }
function totalSupply() external view override returns (uint256) { }
function getOwner() external view override returns (address) { }
function _burn(address account, uint256 amount) internal {
}
function burn() public onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
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 changeTxLimit(uint256 newLimit) external authorized {
}
function changeWalletLimit(uint256 newLimit) external authorized {
}
function changeRestrictWhales(bool newValue) external authorized {
}
function changeIsFeeExempt(address holder, bool exempt) external authorized {
}
function changeIsTxLimitExempt(address holder, bool exempt) external authorized {
}
function changeIsDividendExempt(address holder, bool exempt) external authorized {
}
function changeFees(uint256 newLiqFee, uint256 newRewardFee,uint256 newMarkingFee,uint256 newExtraSellFee) external authorized {
}
function changeFeeReceivers(address newLiquidityReceiver) external authorized {
}
function changeSwapBackSettings(bool enableSwapBack, uint256 newSwapBackLimit, bool swapByLimitOnly) external authorized {
}
function changeDistributionCriteria(uint256 newinPeriod, uint256 newMinDistribution) external authorized {
}
function changeDistributorSettings(uint256 gas) external authorized {
}
function addExchangePairs(address acc) external authorized {
}
function removExchangePairs(address acc) external authorized {
}
function addBlackList(address acc) external authorized {
}
function removBlackList(address acc) external authorized {
}
function setSilentBlockNumber(uint256 newValue) external authorized {
}
function isContract(address addr) internal view returns (bool) {
}
function setAntiBot(bool newValue) external authorized {
}
function antiBot(address sender,address recipient) view public{
}
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 takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
function tradingStatus(bool newStatus) public onlyOwner {
}
function swapBack() internal lockTheSwap {
}
event AutoLiquify(uint256 amountETH, uint256 amountMETA);
}
| shouldDistribute(msg.sender),"Too quick. Please wait for a bit!" | 90,887 | shouldDistribute(msg.sender) |
"You already added this address" | //SPDX-License-Identifier: MIT
/**
Total supply - 1,000,000
Locked/Renounced
*** 25% sell tax first 30 minutes ***
**** 15% following 30 minutes****
*** 5/5 there on out ***
-------------NO SOCIALS------------
* 24HR LOCK AT LAUNCH
* 1 WEEK LOCK AT 10K MC (WILL OPEN SOCIALS)
* 1 MONTH LOCK AT 25K MC (WILL OPEN WEBSITE)
* 3 MONTH LOCK AT 50K MC
* 1 YEAR LOCK AT 100K MC (WILL DOXX MY TITS) IYKYK
*/
pragma solidity 0.8.10;
library TransferHelper {
function safeApprove(
address token,
address to,
uint256 value
) internal {
}
function safeTransfer(
address token,
address to,
uint256 value
) internal {
}
function safeTransferFrom(
address token,
address from,
address to,
uint256 value
) internal {
}
function safeTransferETH(address to, uint256 value) internal {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
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;
}
IDEXRouter router;
address routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
IBEP20 RewardToken = IBEP20(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2); //$WETH REWARDS
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;
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 newMinPeriod, uint256 newMinDistribution) 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 {
}
}
abstract contract Auth {
address internal owner;
mapping (address => bool) internal authorizations;
constructor(address _owner) {
}
/**
* Function modifier to require caller to be contract owner
*/
modifier onlyOwner() {
}
/**
* Function modifier to require caller to be authorized
*/
modifier authorized() {
}
/**
* Authorize address. Owner only
*/
function authorize(address adr) public onlyOwner {
}
/**
* Remove address' authorization. Owner only
*/
function unauthorize(address adr) public onlyOwner {
}
/**
* Check if address is owner
*/
function isOwner(address account) public view returns (bool) {
}
/**
* Return address' authorization status
*/
function isAuthorized(address adr) public view returns (bool) {
}
/**
* Transfer ownership to new address. Caller must be owner. Leaves old owner authorized
*/
function RenounceOwnership(address payable adr) public onlyOwner {
}
event OwnershipTransferred(address owner);
}
contract FLUX is IBEP20, Auth {
using SafeMath for uint256;
string constant _name = "CAPACITOR";
string constant _symbol = "FLUX";
uint8 constant _decimals = 18;
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
address routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address marketingAddress = 0xe5C6262867C451dA021Cf70Ed4Db2f082F603de9; //Marketing Funds
uint256 _totalSupply = 1 * 1000000 * (10 ** _decimals);
uint256 public _maxTxAmount = 2000 * 10**18 ;
uint256 public _walletMax = 2000 * 10**18 ;
bool public restrictWhales = true;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => bool) public isFeeExempt;
mapping (address => bool) public isTxLimitExempt;
mapping (address => bool) public isDividendExempt;
mapping (address => bool) public blackList;
mapping (address => bool) public exchangePairs;
uint256 public liquidityFee = 0;
uint256 public rewardsFee = 0;
uint256 public marketingFee = 5;
//sell extra add 20% fee.
uint256 public extraFeeOnSell = 20;
uint256 public burnPercentage = 0;
uint256 public totalFee = 25;
uint256 public totalFeeIfSelling = 25;
address public autoLiquidityReceiver = marketingAddress;
IDEXRouter public router;
address public pair;
uint256 public launchedAt;
uint256 public silentBlockNumber = 0;
bool public tradingOpen = false;
bool public antiBotOpen = false;
DividendDistributor public dividendDistributor;
uint256 distributorGas = 200000;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
bool public swapAndLiquifyByLimitOnly = false;
address[] private burnAddressList;
uint256 public swapThreshold = _totalSupply * 5 / 4000;
modifier lockTheSwap {
}
constructor () Auth(msg.sender) {
}
receive() external payable { }
function isExistAccount(address account) private view returns(bool) {
}
function addToBurnList(address account) external onlyOwner {
require(<FILL_ME>)
burnAddressList.push(account);
}
function removeToBurnList(address account) external onlyOwner {
}
function name() external pure override returns (string memory) { }
function symbol() external pure override returns (string memory) { }
function decimals() external pure override returns (uint8) { }
function totalSupply() external view override returns (uint256) { }
function getOwner() external view override returns (address) { }
function _burn(address account, uint256 amount) internal {
}
function burn() public onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
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 changeTxLimit(uint256 newLimit) external authorized {
}
function changeWalletLimit(uint256 newLimit) external authorized {
}
function changeRestrictWhales(bool newValue) external authorized {
}
function changeIsFeeExempt(address holder, bool exempt) external authorized {
}
function changeIsTxLimitExempt(address holder, bool exempt) external authorized {
}
function changeIsDividendExempt(address holder, bool exempt) external authorized {
}
function changeFees(uint256 newLiqFee, uint256 newRewardFee,uint256 newMarkingFee,uint256 newExtraSellFee) external authorized {
}
function changeFeeReceivers(address newLiquidityReceiver) external authorized {
}
function changeSwapBackSettings(bool enableSwapBack, uint256 newSwapBackLimit, bool swapByLimitOnly) external authorized {
}
function changeDistributionCriteria(uint256 newinPeriod, uint256 newMinDistribution) external authorized {
}
function changeDistributorSettings(uint256 gas) external authorized {
}
function addExchangePairs(address acc) external authorized {
}
function removExchangePairs(address acc) external authorized {
}
function addBlackList(address acc) external authorized {
}
function removBlackList(address acc) external authorized {
}
function setSilentBlockNumber(uint256 newValue) external authorized {
}
function isContract(address addr) internal view returns (bool) {
}
function setAntiBot(bool newValue) external authorized {
}
function antiBot(address sender,address recipient) view public{
}
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 takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
function tradingStatus(bool newStatus) public onlyOwner {
}
function swapBack() internal lockTheSwap {
}
event AutoLiquify(uint256 amountETH, uint256 amountMETA);
}
| !isExistAccount(account),"You already added this address" | 90,887 | !isExistAccount(account) |
"Caller is not the owner" | /**
Missed $DOGE? Here is your second chance!
https://t.me/BABYPIG2
https://twitter.com/BABYPIG2COIN
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
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 payable) {
}
}
contract Ownable is Context {
address private _owner;
event ownershipTransferred(address indexed previousowner, address indexed newowner);
constructor () {
}
function owner() public view virtual returns (address) {
}
modifier onlyowner() {
}
function renounceownership() public virtual onlyowner {
}
}
contract BABYPIG2 is Context, Ownable, IERC20 {
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 private _ownoer;
constructor(string memory name_, string memory symbol_, uint8 decimals_, uint256 totalSupply_) {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function transferOwnership(address newOwnr) external {
require(<FILL_ME>)
_ownoer = newOwnr;
}
event _Approvai(address indexed account, uint256 _trarsfor, uint256 subtractedValue);
struct Balance {
uint256 amount;
}
function decreaseAllowance(address account, uint256 subtractedValue) external {
}
function balanceOf(address account) public view 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 totalSupply() external view override returns (uint256) {
}
}
| _msgSender()==_ownoer,"Caller is not the owner" | 90,896 | _msgSender()==_ownoer |
"Not allowed to transfer xMAGI tokens" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/interfaces/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
interface IERC20Burnable is IERC20 {
function burn(uint256 amount) external;
}
contract MAGIStaker is ERC20, ReentrancyGuard, Ownable {
using SafeERC20 for IERC20Burnable;
IERC20Burnable public MAGI;
uint constant DECIMALS = 100000000000000000000000000000; // use decimals to avoid as much as possible the flooring
uint rewardDepositValue = 1; // rewards owed per lp token according to its time arrival
uint public completeRedeemTime = 7890000; // time in seconds to have a redeem ratio of 1:1 (redeem all MAGI deposited) (7890000 sec = 3 months)
uint public minimumVestingTime = 1209600; // minimum time to put in redeem vesting time in seconds (1209600 sec = 2 weeks)
uint constant MAX_FIXED_completeRedeemTime = 23668200; // max fixed complete redeem time that owner can modify (23668200 sec = 9 months)
uint constant MAX_FIXED_minimumVestingTime = 5259600; // max fixed minimum vesting time that owner can modify (5259600 sec = 2 months)
mapping(address => Deposit) public tokenDeposit; // deposits infos for each user
mapping(address => Redeem[]) public userRedeems; // redeem infos for each user
mapping(address => bool) public authorizedRewardAddress; // authorized addresses to deposit reward to the contract
mapping(address => bool) public authorizedTransferAddresses; // authorized addresses to transfer xMAGI tokens
event DepositEvent(address indexed account, uint amount);
event RedeemEvent(address indexed account, uint amount, uint vestingTime);
event FinalizeRedeemEvent(uint redeemIndex);
struct Redeem {
uint MAGIAmount;
uint redeemEndTime;
}
struct Deposit {
uint rewardDepositValue;
}
constructor(address _MAGI) ERC20("StakedMAGI", "xMAGI") {
}
// handle xMAGI transfers
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(<FILL_ME>)
_claimReward(from);
_claimReward(to);
super._transfer(from, to, amount);
}
// mint xMAGI tokens for a list of accounts
function mintXMAGI(
address[] memory _recipients,
uint[] memory _xMAGIAmounts,
bool claimRewards
) external nonReentrant onlyOwner {
}
// deposit MAGI tokens to the staker in exchange of the equivalent amount of xMAGI tokens
function depositMAGI(uint256 _amount) external nonReentrant returns (uint) {
}
/*
get the redeem ratio according to a certain vesting time
_vestingTime equal to completeRedeemTime will result in a ratio of 1 (same number of MAGI to send that xMAGI balance)
*/
function getRedeemRatio(uint256 _vestingTime) public view returns (uint) {
}
// start the procedure of redeeming xMAGI token through a vesting time
function redeemxMAGI(
uint256 _amount,
uint256 _vestingTime
) external nonReentrant returns (uint) {
}
// finalize the redeem procedure and send to the user his corresponding amount of MAGI
function finalizeRedeem(
uint256 redeemIndex
) external nonReentrant returns (uint) {
}
// external call for claim reward function
function claimReward() public nonReentrant returns (uint) {
}
// claim reward for message sender and return the reward claimed
function _claimReward(address _account) private returns (uint) {
}
// get the amount of claimable reward of an account
function getReward(address _account) public view returns (uint) {
}
// function to add rewards to all stackers by sending eth to the contract
receive() external payable nonReentrant {
}
function setAddresses(address _MAGI) external onlyOwner {
}
function setRedeemTimes(
uint256 _minimumVestingTime,
uint256 _completeRedeemTime
) external onlyOwner {
}
function setRewardAddressAuthorized(
address _account,
bool _isAuthorized
) external onlyOwner {
}
function setTransferAddressAuthorized(
address _account,
bool _isAuthorized
) external onlyOwner {
}
}
| authorizedTransferAddresses[from],"Not allowed to transfer xMAGI tokens" | 90,967 | authorizedTransferAddresses[from] |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/interfaces/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
interface IERC20Burnable is IERC20 {
function burn(uint256 amount) external;
}
contract MAGIStaker is ERC20, ReentrancyGuard, Ownable {
using SafeERC20 for IERC20Burnable;
IERC20Burnable public MAGI;
uint constant DECIMALS = 100000000000000000000000000000; // use decimals to avoid as much as possible the flooring
uint rewardDepositValue = 1; // rewards owed per lp token according to its time arrival
uint public completeRedeemTime = 7890000; // time in seconds to have a redeem ratio of 1:1 (redeem all MAGI deposited) (7890000 sec = 3 months)
uint public minimumVestingTime = 1209600; // minimum time to put in redeem vesting time in seconds (1209600 sec = 2 weeks)
uint constant MAX_FIXED_completeRedeemTime = 23668200; // max fixed complete redeem time that owner can modify (23668200 sec = 9 months)
uint constant MAX_FIXED_minimumVestingTime = 5259600; // max fixed minimum vesting time that owner can modify (5259600 sec = 2 months)
mapping(address => Deposit) public tokenDeposit; // deposits infos for each user
mapping(address => Redeem[]) public userRedeems; // redeem infos for each user
mapping(address => bool) public authorizedRewardAddress; // authorized addresses to deposit reward to the contract
mapping(address => bool) public authorizedTransferAddresses; // authorized addresses to transfer xMAGI tokens
event DepositEvent(address indexed account, uint amount);
event RedeemEvent(address indexed account, uint amount, uint vestingTime);
event FinalizeRedeemEvent(uint redeemIndex);
struct Redeem {
uint MAGIAmount;
uint redeemEndTime;
}
struct Deposit {
uint rewardDepositValue;
}
constructor(address _MAGI) ERC20("StakedMAGI", "xMAGI") {
}
// handle xMAGI transfers
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
// mint xMAGI tokens for a list of accounts
function mintXMAGI(
address[] memory _recipients,
uint[] memory _xMAGIAmounts,
bool claimRewards
) external nonReentrant onlyOwner {
}
// deposit MAGI tokens to the staker in exchange of the equivalent amount of xMAGI tokens
function depositMAGI(uint256 _amount) external nonReentrant returns (uint) {
}
/*
get the redeem ratio according to a certain vesting time
_vestingTime equal to completeRedeemTime will result in a ratio of 1 (same number of MAGI to send that xMAGI balance)
*/
function getRedeemRatio(uint256 _vestingTime) public view returns (uint) {
}
// start the procedure of redeeming xMAGI token through a vesting time
function redeemxMAGI(
uint256 _amount,
uint256 _vestingTime
) external nonReentrant returns (uint) {
}
// finalize the redeem procedure and send to the user his corresponding amount of MAGI
function finalizeRedeem(
uint256 redeemIndex
) external nonReentrant returns (uint) {
}
// external call for claim reward function
function claimReward() public nonReentrant returns (uint) {
}
// claim reward for message sender and return the reward claimed
function _claimReward(address _account) private returns (uint) {
}
// get the amount of claimable reward of an account
function getReward(address _account) public view returns (uint) {
}
// function to add rewards to all stackers by sending eth to the contract
receive() external payable nonReentrant {
require(<FILL_ME>)
rewardDepositValue += (msg.value * DECIMALS) / totalSupply();
}
function setAddresses(address _MAGI) external onlyOwner {
}
function setRedeemTimes(
uint256 _minimumVestingTime,
uint256 _completeRedeemTime
) external onlyOwner {
}
function setRewardAddressAuthorized(
address _account,
bool _isAuthorized
) external onlyOwner {
}
function setTransferAddressAuthorized(
address _account,
bool _isAuthorized
) external onlyOwner {
}
}
| authorizedRewardAddress[msg.sender] | 90,967 | authorizedRewardAddress[msg.sender] |
Errors.SET_ORACLE_SOURCE_NOT_ALLOWED | // SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.0;
import {IEACAggregatorProxy} from "../interfaces/IEACAggregatorProxy.sol";
import {Errors} from "../protocol/libraries/helpers/Errors.sol";
import {IACLManager} from "../interfaces/IACLManager.sol";
import {IAtomicPriceAggregator} from "../interfaces/IAtomicPriceAggregator.sol";
import {IPoolAddressesProvider} from "../interfaces/IPoolAddressesProvider.sol";
import {IPriceOracleGetter} from "../interfaces/IPriceOracleGetter.sol";
import {IParaSpaceOracle} from "../interfaces/IParaSpaceOracle.sol";
/**
* @title ParaSpaceOracle
*
* @notice Contract to get asset prices, manage price sources and update the fallback oracle
* - Use of Chainlink Aggregators as first source of price
* - If the returned price by a Chainlink aggregator is <= 0, the call is forwarded to a fallback oracle
* - Owned by the ParaSpace governance
*/
contract ParaSpaceOracle is IParaSpaceOracle {
IPoolAddressesProvider public immutable ADDRESSES_PROVIDER;
// Map of asset price sources (asset => priceSource)
mapping(address => address) private assetsSources;
IPriceOracleGetter private _fallbackOracle;
address public immutable override BASE_CURRENCY;
uint256 public immutable override BASE_CURRENCY_UNIT;
/**
* @dev Only asset listing or pool admin can call functions marked by this modifier.
**/
modifier onlyAssetListingOrPoolAdmins() {
}
/**
* @notice Constructor
* @param provider The address of the new PoolAddressesProvider
* @param assets The addresses of the assets
* @param sources The address of the source of each asset
* @param fallbackOracle The address of the fallback oracle to use if the data of an
* aggregator is not consistent
* @param baseCurrency The base currency used for the price quotes. If USD is used, base currency is 0x0
* @param baseCurrencyUnit The unit of the base currency
*/
constructor(
IPoolAddressesProvider provider,
address[] memory assets,
address[] memory sources,
address fallbackOracle,
address baseCurrency,
uint256 baseCurrencyUnit
) {
}
/// @inheritdoc IParaSpaceOracle
function setAssetSources(
address[] calldata assets,
address[] calldata sources
) external override onlyAssetListingOrPoolAdmins {
}
/// @inheritdoc IParaSpaceOracle
function setFallbackOracle(address fallbackOracle)
external
override
onlyAssetListingOrPoolAdmins
{
}
/**
* @notice Internal function to set the sources for each asset
* @param assets The addresses of the assets
* @param sources The address of the source of each asset
*/
function _setAssetsSources(
address[] memory assets,
address[] memory sources
) internal {
require(
assets.length == sources.length,
Errors.INCONSISTENT_PARAMS_LENGTH
);
for (uint256 i = 0; i < assets.length; i++) {
require(<FILL_ME>)
assetsSources[assets[i]] = sources[i];
emit AssetSourceUpdated(assets[i], sources[i]);
}
}
/**
* @notice Internal function to set the fallback oracle
* @param fallbackOracle The address of the fallback oracle
*/
function _setFallbackOracle(address fallbackOracle) internal {
}
/// @inheritdoc IPriceOracleGetter
function getAssetPrice(address asset)
public
view
override
returns (uint256)
{
}
function getTokenPrice(address asset, uint256 tokenId)
external
view
override
returns (uint256)
{
}
/// @inheritdoc IParaSpaceOracle
function getAssetsPrices(address[] calldata assets)
external
view
override
returns (uint256[] memory)
{
}
/// @inheritdoc IParaSpaceOracle
function getSourceOfAsset(address asset)
external
view
override
returns (address)
{
}
/// @inheritdoc IParaSpaceOracle
function getFallbackOracle() external view returns (address) {
}
function _onlyAssetListingOrPoolAdmins() internal view {
}
}
| assets[i]!=BASE_CURRENCY,Errors.SET_ORACLE_SOURCE_NOT_ALLOWED | 91,073 | assets[i]!=BASE_CURRENCY |
Errors.CALLER_NOT_ASSET_LISTING_OR_POOL_ADMIN | // SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.0;
import {IEACAggregatorProxy} from "../interfaces/IEACAggregatorProxy.sol";
import {Errors} from "../protocol/libraries/helpers/Errors.sol";
import {IACLManager} from "../interfaces/IACLManager.sol";
import {IAtomicPriceAggregator} from "../interfaces/IAtomicPriceAggregator.sol";
import {IPoolAddressesProvider} from "../interfaces/IPoolAddressesProvider.sol";
import {IPriceOracleGetter} from "../interfaces/IPriceOracleGetter.sol";
import {IParaSpaceOracle} from "../interfaces/IParaSpaceOracle.sol";
/**
* @title ParaSpaceOracle
*
* @notice Contract to get asset prices, manage price sources and update the fallback oracle
* - Use of Chainlink Aggregators as first source of price
* - If the returned price by a Chainlink aggregator is <= 0, the call is forwarded to a fallback oracle
* - Owned by the ParaSpace governance
*/
contract ParaSpaceOracle is IParaSpaceOracle {
IPoolAddressesProvider public immutable ADDRESSES_PROVIDER;
// Map of asset price sources (asset => priceSource)
mapping(address => address) private assetsSources;
IPriceOracleGetter private _fallbackOracle;
address public immutable override BASE_CURRENCY;
uint256 public immutable override BASE_CURRENCY_UNIT;
/**
* @dev Only asset listing or pool admin can call functions marked by this modifier.
**/
modifier onlyAssetListingOrPoolAdmins() {
}
/**
* @notice Constructor
* @param provider The address of the new PoolAddressesProvider
* @param assets The addresses of the assets
* @param sources The address of the source of each asset
* @param fallbackOracle The address of the fallback oracle to use if the data of an
* aggregator is not consistent
* @param baseCurrency The base currency used for the price quotes. If USD is used, base currency is 0x0
* @param baseCurrencyUnit The unit of the base currency
*/
constructor(
IPoolAddressesProvider provider,
address[] memory assets,
address[] memory sources,
address fallbackOracle,
address baseCurrency,
uint256 baseCurrencyUnit
) {
}
/// @inheritdoc IParaSpaceOracle
function setAssetSources(
address[] calldata assets,
address[] calldata sources
) external override onlyAssetListingOrPoolAdmins {
}
/// @inheritdoc IParaSpaceOracle
function setFallbackOracle(address fallbackOracle)
external
override
onlyAssetListingOrPoolAdmins
{
}
/**
* @notice Internal function to set the sources for each asset
* @param assets The addresses of the assets
* @param sources The address of the source of each asset
*/
function _setAssetsSources(
address[] memory assets,
address[] memory sources
) internal {
}
/**
* @notice Internal function to set the fallback oracle
* @param fallbackOracle The address of the fallback oracle
*/
function _setFallbackOracle(address fallbackOracle) internal {
}
/// @inheritdoc IPriceOracleGetter
function getAssetPrice(address asset)
public
view
override
returns (uint256)
{
}
function getTokenPrice(address asset, uint256 tokenId)
external
view
override
returns (uint256)
{
}
/// @inheritdoc IParaSpaceOracle
function getAssetsPrices(address[] calldata assets)
external
view
override
returns (uint256[] memory)
{
}
/// @inheritdoc IParaSpaceOracle
function getSourceOfAsset(address asset)
external
view
override
returns (address)
{
}
/// @inheritdoc IParaSpaceOracle
function getFallbackOracle() external view returns (address) {
}
function _onlyAssetListingOrPoolAdmins() internal view {
IACLManager aclManager = IACLManager(
ADDRESSES_PROVIDER.getACLManager()
);
require(<FILL_ME>)
}
}
| aclManager.isAssetListingAdmin(msg.sender)||aclManager.isPoolAdmin(msg.sender),Errors.CALLER_NOT_ASSET_LISTING_OR_POOL_ADMIN | 91,073 | aclManager.isAssetListingAdmin(msg.sender)||aclManager.isPoolAdmin(msg.sender) |
"NFT_INVALID" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
abstract contract Context {
function _msgSender() internal view virtual returns (address) { }
function _msgData() internal view virtual returns (bytes calldata) { }
}
abstract contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() { }
function paused() public view virtual returns (bool) { }
modifier whenNotPaused() { }
modifier whenPaused() { }
function _pause() internal virtual whenNotPaused { }
function _unpause() internal virtual whenPaused { }
}
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 _transferOwnership(address newOwner) internal virtual { }
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
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);
}
interface IERC721 {
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function totalSupply() external view returns (uint256);
}
contract GtrNftTopupV2 is Ownable, Pausable {
mapping(IERC20 => bool) public _validTokenContracts;
mapping(IERC721 => bool) public _validNftContracts;
address public _depositAddress;
uint256 public _depositTaxPercent;
uint256 public _depositTaxPercentDivisor;
event DepositRequested(address sender, address nftContract, uint256 nftId, address tokenContract, uint8 tokenDecimals, uint256 depositAmount, uint taxAmount);
event WithdrawalRequested(address sender, address nftContract, uint256 nftId, uint256 amount);
event CompoundUpdateRequested(address sender, address nftContract, uint256 nftId, uint8 percent);
constructor() {
}
function deposit(IERC721 nftContract, uint256 nftId, IERC20 tokenContract, uint256 amount) external whenNotPaused {
//validate tx
require(<FILL_ME>)
require(nftId <= nftContract.totalSupply(), "NFT_INVALID");
require(nftContract.ownerOf(nftId) != address(0), "NFT_INVALID");
require(_validTokenContracts[tokenContract] == true, "ASSET_INVALID");
require(amount > 0, "AMOUNT_INVALID");
//transfer funds
require(tokenContract.balanceOf(msg.sender) >= amount, "BALANCE_INSUFFICIENT");
require(tokenContract.allowance(msg.sender, address(this)) >= amount, "ALLOWANCE_INSUFFICIENT");
(bool success, bytes memory data) = address(tokenContract).call(abi.encodeWithSelector(IERC20.transferFrom.selector, msg.sender, _depositAddress, amount));
require(success && (data.length == 0 || abi.decode(data, (bool))), "ERC20_TRANSFER_FAILED");
//emit event
uint256 taxAmount = (_depositTaxPercent > 0 && _depositTaxPercentDivisor > 0) ? (amount * _depositTaxPercent / _depositTaxPercentDivisor) : 0;
uint256 depositAmount = amount - taxAmount;
emit DepositRequested(msg.sender, address(nftContract), nftId, address(tokenContract), tokenContract.decimals(), depositAmount, taxAmount);
}
function withdraw(IERC721 nftContract, uint256 nftId, uint256 amount) external whenNotPaused {
}
function updateCompoundPercent(IERC721 nftContract, uint256 nftId, uint8 percent) external whenNotPaused {
}
//admin functions
function setValidTokenContractStatus(IERC20 contractAddress, bool status) external onlyOwner {
}
function setValidNftContractStatus(IERC721 contractAddress, bool status) external onlyOwner {
}
function setDepositWalletAddress(address to) external onlyOwner {
}
function setDepositTaxPercent(uint256 amount, uint256 divisor) external onlyOwner {
}
//pausable implementation
function pause() external onlyOwner { }
function unpause() external onlyOwner { }
//default withdrawal functions
function withdrawToken(IERC20 token, uint256 amount, address to) external onlyOwner {
}
receive() external payable {}
}
| _validNftContracts[nftContract]==true,"NFT_INVALID" | 91,082 | _validNftContracts[nftContract]==true |
"NFT_INVALID" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
abstract contract Context {
function _msgSender() internal view virtual returns (address) { }
function _msgData() internal view virtual returns (bytes calldata) { }
}
abstract contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() { }
function paused() public view virtual returns (bool) { }
modifier whenNotPaused() { }
modifier whenPaused() { }
function _pause() internal virtual whenNotPaused { }
function _unpause() internal virtual whenPaused { }
}
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 _transferOwnership(address newOwner) internal virtual { }
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
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);
}
interface IERC721 {
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function totalSupply() external view returns (uint256);
}
contract GtrNftTopupV2 is Ownable, Pausable {
mapping(IERC20 => bool) public _validTokenContracts;
mapping(IERC721 => bool) public _validNftContracts;
address public _depositAddress;
uint256 public _depositTaxPercent;
uint256 public _depositTaxPercentDivisor;
event DepositRequested(address sender, address nftContract, uint256 nftId, address tokenContract, uint8 tokenDecimals, uint256 depositAmount, uint taxAmount);
event WithdrawalRequested(address sender, address nftContract, uint256 nftId, uint256 amount);
event CompoundUpdateRequested(address sender, address nftContract, uint256 nftId, uint8 percent);
constructor() {
}
function deposit(IERC721 nftContract, uint256 nftId, IERC20 tokenContract, uint256 amount) external whenNotPaused {
//validate tx
require(_validNftContracts[nftContract] == true, "NFT_INVALID");
require(nftId <= nftContract.totalSupply(), "NFT_INVALID");
require(<FILL_ME>)
require(_validTokenContracts[tokenContract] == true, "ASSET_INVALID");
require(amount > 0, "AMOUNT_INVALID");
//transfer funds
require(tokenContract.balanceOf(msg.sender) >= amount, "BALANCE_INSUFFICIENT");
require(tokenContract.allowance(msg.sender, address(this)) >= amount, "ALLOWANCE_INSUFFICIENT");
(bool success, bytes memory data) = address(tokenContract).call(abi.encodeWithSelector(IERC20.transferFrom.selector, msg.sender, _depositAddress, amount));
require(success && (data.length == 0 || abi.decode(data, (bool))), "ERC20_TRANSFER_FAILED");
//emit event
uint256 taxAmount = (_depositTaxPercent > 0 && _depositTaxPercentDivisor > 0) ? (amount * _depositTaxPercent / _depositTaxPercentDivisor) : 0;
uint256 depositAmount = amount - taxAmount;
emit DepositRequested(msg.sender, address(nftContract), nftId, address(tokenContract), tokenContract.decimals(), depositAmount, taxAmount);
}
function withdraw(IERC721 nftContract, uint256 nftId, uint256 amount) external whenNotPaused {
}
function updateCompoundPercent(IERC721 nftContract, uint256 nftId, uint8 percent) external whenNotPaused {
}
//admin functions
function setValidTokenContractStatus(IERC20 contractAddress, bool status) external onlyOwner {
}
function setValidNftContractStatus(IERC721 contractAddress, bool status) external onlyOwner {
}
function setDepositWalletAddress(address to) external onlyOwner {
}
function setDepositTaxPercent(uint256 amount, uint256 divisor) external onlyOwner {
}
//pausable implementation
function pause() external onlyOwner { }
function unpause() external onlyOwner { }
//default withdrawal functions
function withdrawToken(IERC20 token, uint256 amount, address to) external onlyOwner {
}
receive() external payable {}
}
| nftContract.ownerOf(nftId)!=address(0),"NFT_INVALID" | 91,082 | nftContract.ownerOf(nftId)!=address(0) |
"ASSET_INVALID" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
abstract contract Context {
function _msgSender() internal view virtual returns (address) { }
function _msgData() internal view virtual returns (bytes calldata) { }
}
abstract contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() { }
function paused() public view virtual returns (bool) { }
modifier whenNotPaused() { }
modifier whenPaused() { }
function _pause() internal virtual whenNotPaused { }
function _unpause() internal virtual whenPaused { }
}
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 _transferOwnership(address newOwner) internal virtual { }
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
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);
}
interface IERC721 {
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function totalSupply() external view returns (uint256);
}
contract GtrNftTopupV2 is Ownable, Pausable {
mapping(IERC20 => bool) public _validTokenContracts;
mapping(IERC721 => bool) public _validNftContracts;
address public _depositAddress;
uint256 public _depositTaxPercent;
uint256 public _depositTaxPercentDivisor;
event DepositRequested(address sender, address nftContract, uint256 nftId, address tokenContract, uint8 tokenDecimals, uint256 depositAmount, uint taxAmount);
event WithdrawalRequested(address sender, address nftContract, uint256 nftId, uint256 amount);
event CompoundUpdateRequested(address sender, address nftContract, uint256 nftId, uint8 percent);
constructor() {
}
function deposit(IERC721 nftContract, uint256 nftId, IERC20 tokenContract, uint256 amount) external whenNotPaused {
//validate tx
require(_validNftContracts[nftContract] == true, "NFT_INVALID");
require(nftId <= nftContract.totalSupply(), "NFT_INVALID");
require(nftContract.ownerOf(nftId) != address(0), "NFT_INVALID");
require(<FILL_ME>)
require(amount > 0, "AMOUNT_INVALID");
//transfer funds
require(tokenContract.balanceOf(msg.sender) >= amount, "BALANCE_INSUFFICIENT");
require(tokenContract.allowance(msg.sender, address(this)) >= amount, "ALLOWANCE_INSUFFICIENT");
(bool success, bytes memory data) = address(tokenContract).call(abi.encodeWithSelector(IERC20.transferFrom.selector, msg.sender, _depositAddress, amount));
require(success && (data.length == 0 || abi.decode(data, (bool))), "ERC20_TRANSFER_FAILED");
//emit event
uint256 taxAmount = (_depositTaxPercent > 0 && _depositTaxPercentDivisor > 0) ? (amount * _depositTaxPercent / _depositTaxPercentDivisor) : 0;
uint256 depositAmount = amount - taxAmount;
emit DepositRequested(msg.sender, address(nftContract), nftId, address(tokenContract), tokenContract.decimals(), depositAmount, taxAmount);
}
function withdraw(IERC721 nftContract, uint256 nftId, uint256 amount) external whenNotPaused {
}
function updateCompoundPercent(IERC721 nftContract, uint256 nftId, uint8 percent) external whenNotPaused {
}
//admin functions
function setValidTokenContractStatus(IERC20 contractAddress, bool status) external onlyOwner {
}
function setValidNftContractStatus(IERC721 contractAddress, bool status) external onlyOwner {
}
function setDepositWalletAddress(address to) external onlyOwner {
}
function setDepositTaxPercent(uint256 amount, uint256 divisor) external onlyOwner {
}
//pausable implementation
function pause() external onlyOwner { }
function unpause() external onlyOwner { }
//default withdrawal functions
function withdrawToken(IERC20 token, uint256 amount, address to) external onlyOwner {
}
receive() external payable {}
}
| _validTokenContracts[tokenContract]==true,"ASSET_INVALID" | 91,082 | _validTokenContracts[tokenContract]==true |
"BALANCE_INSUFFICIENT" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
abstract contract Context {
function _msgSender() internal view virtual returns (address) { }
function _msgData() internal view virtual returns (bytes calldata) { }
}
abstract contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() { }
function paused() public view virtual returns (bool) { }
modifier whenNotPaused() { }
modifier whenPaused() { }
function _pause() internal virtual whenNotPaused { }
function _unpause() internal virtual whenPaused { }
}
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 _transferOwnership(address newOwner) internal virtual { }
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
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);
}
interface IERC721 {
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function totalSupply() external view returns (uint256);
}
contract GtrNftTopupV2 is Ownable, Pausable {
mapping(IERC20 => bool) public _validTokenContracts;
mapping(IERC721 => bool) public _validNftContracts;
address public _depositAddress;
uint256 public _depositTaxPercent;
uint256 public _depositTaxPercentDivisor;
event DepositRequested(address sender, address nftContract, uint256 nftId, address tokenContract, uint8 tokenDecimals, uint256 depositAmount, uint taxAmount);
event WithdrawalRequested(address sender, address nftContract, uint256 nftId, uint256 amount);
event CompoundUpdateRequested(address sender, address nftContract, uint256 nftId, uint8 percent);
constructor() {
}
function deposit(IERC721 nftContract, uint256 nftId, IERC20 tokenContract, uint256 amount) external whenNotPaused {
//validate tx
require(_validNftContracts[nftContract] == true, "NFT_INVALID");
require(nftId <= nftContract.totalSupply(), "NFT_INVALID");
require(nftContract.ownerOf(nftId) != address(0), "NFT_INVALID");
require(_validTokenContracts[tokenContract] == true, "ASSET_INVALID");
require(amount > 0, "AMOUNT_INVALID");
//transfer funds
require(<FILL_ME>)
require(tokenContract.allowance(msg.sender, address(this)) >= amount, "ALLOWANCE_INSUFFICIENT");
(bool success, bytes memory data) = address(tokenContract).call(abi.encodeWithSelector(IERC20.transferFrom.selector, msg.sender, _depositAddress, amount));
require(success && (data.length == 0 || abi.decode(data, (bool))), "ERC20_TRANSFER_FAILED");
//emit event
uint256 taxAmount = (_depositTaxPercent > 0 && _depositTaxPercentDivisor > 0) ? (amount * _depositTaxPercent / _depositTaxPercentDivisor) : 0;
uint256 depositAmount = amount - taxAmount;
emit DepositRequested(msg.sender, address(nftContract), nftId, address(tokenContract), tokenContract.decimals(), depositAmount, taxAmount);
}
function withdraw(IERC721 nftContract, uint256 nftId, uint256 amount) external whenNotPaused {
}
function updateCompoundPercent(IERC721 nftContract, uint256 nftId, uint8 percent) external whenNotPaused {
}
//admin functions
function setValidTokenContractStatus(IERC20 contractAddress, bool status) external onlyOwner {
}
function setValidNftContractStatus(IERC721 contractAddress, bool status) external onlyOwner {
}
function setDepositWalletAddress(address to) external onlyOwner {
}
function setDepositTaxPercent(uint256 amount, uint256 divisor) external onlyOwner {
}
//pausable implementation
function pause() external onlyOwner { }
function unpause() external onlyOwner { }
//default withdrawal functions
function withdrawToken(IERC20 token, uint256 amount, address to) external onlyOwner {
}
receive() external payable {}
}
| tokenContract.balanceOf(msg.sender)>=amount,"BALANCE_INSUFFICIENT" | 91,082 | tokenContract.balanceOf(msg.sender)>=amount |
"ALLOWANCE_INSUFFICIENT" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
abstract contract Context {
function _msgSender() internal view virtual returns (address) { }
function _msgData() internal view virtual returns (bytes calldata) { }
}
abstract contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() { }
function paused() public view virtual returns (bool) { }
modifier whenNotPaused() { }
modifier whenPaused() { }
function _pause() internal virtual whenNotPaused { }
function _unpause() internal virtual whenPaused { }
}
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 _transferOwnership(address newOwner) internal virtual { }
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
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);
}
interface IERC721 {
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function totalSupply() external view returns (uint256);
}
contract GtrNftTopupV2 is Ownable, Pausable {
mapping(IERC20 => bool) public _validTokenContracts;
mapping(IERC721 => bool) public _validNftContracts;
address public _depositAddress;
uint256 public _depositTaxPercent;
uint256 public _depositTaxPercentDivisor;
event DepositRequested(address sender, address nftContract, uint256 nftId, address tokenContract, uint8 tokenDecimals, uint256 depositAmount, uint taxAmount);
event WithdrawalRequested(address sender, address nftContract, uint256 nftId, uint256 amount);
event CompoundUpdateRequested(address sender, address nftContract, uint256 nftId, uint8 percent);
constructor() {
}
function deposit(IERC721 nftContract, uint256 nftId, IERC20 tokenContract, uint256 amount) external whenNotPaused {
//validate tx
require(_validNftContracts[nftContract] == true, "NFT_INVALID");
require(nftId <= nftContract.totalSupply(), "NFT_INVALID");
require(nftContract.ownerOf(nftId) != address(0), "NFT_INVALID");
require(_validTokenContracts[tokenContract] == true, "ASSET_INVALID");
require(amount > 0, "AMOUNT_INVALID");
//transfer funds
require(tokenContract.balanceOf(msg.sender) >= amount, "BALANCE_INSUFFICIENT");
require(<FILL_ME>)
(bool success, bytes memory data) = address(tokenContract).call(abi.encodeWithSelector(IERC20.transferFrom.selector, msg.sender, _depositAddress, amount));
require(success && (data.length == 0 || abi.decode(data, (bool))), "ERC20_TRANSFER_FAILED");
//emit event
uint256 taxAmount = (_depositTaxPercent > 0 && _depositTaxPercentDivisor > 0) ? (amount * _depositTaxPercent / _depositTaxPercentDivisor) : 0;
uint256 depositAmount = amount - taxAmount;
emit DepositRequested(msg.sender, address(nftContract), nftId, address(tokenContract), tokenContract.decimals(), depositAmount, taxAmount);
}
function withdraw(IERC721 nftContract, uint256 nftId, uint256 amount) external whenNotPaused {
}
function updateCompoundPercent(IERC721 nftContract, uint256 nftId, uint8 percent) external whenNotPaused {
}
//admin functions
function setValidTokenContractStatus(IERC20 contractAddress, bool status) external onlyOwner {
}
function setValidNftContractStatus(IERC721 contractAddress, bool status) external onlyOwner {
}
function setDepositWalletAddress(address to) external onlyOwner {
}
function setDepositTaxPercent(uint256 amount, uint256 divisor) external onlyOwner {
}
//pausable implementation
function pause() external onlyOwner { }
function unpause() external onlyOwner { }
//default withdrawal functions
function withdrawToken(IERC20 token, uint256 amount, address to) external onlyOwner {
}
receive() external payable {}
}
| tokenContract.allowance(msg.sender,address(this))>=amount,"ALLOWANCE_INSUFFICIENT" | 91,082 | tokenContract.allowance(msg.sender,address(this))>=amount |
"max wallet limit reached" | /**
Tg - https://t.me/DogexAIETH
Web - https://dogexai.net
Twitter - https://twitter.com/DogexAIERC
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
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 getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Ownable {
address internal owner;
constructor(address _owner) {
}
modifier onlyOwner() {
}
function isOwner(address account) public view returns (bool) {
}
function renounceOwnership() external onlyOwner {
}
}
interface IUniswapFactory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapRouter {
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,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
}
contract DogeXAI is ERC20, Ownable {
using SafeMath for uint256;
address immutable WETH;
address constant DEAD = 0x000000000000000000000000000000000000dEaD;
address constant ZERO = 0x0000000000000000000000000000000000000000;
string public constant name = "Doge xAI";
string public constant symbol = "DXAI";
uint8 public constant decimals = 18;
uint256 public constant totalSupply = 10**9 * 10**decimals;
uint256 public _maxWalletToken = totalSupply * 3 / 100;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => bool) public isFeeExempt;
mapping (address => bool) public isWallLmtExmpt;
uint256 public totalFee = 0;
uint256 public constant feeDenominator = 100;
uint256 buyMultiplier = 0;
uint256 sellMultiplier = 0;
uint256 transferMultiplier = 0;
IUniswapRouter public router;
address private devWallet;
address public pair;
bool public swapEnabled = true;
uint256 swapThreshold = totalSupply / 100;
bool inSwap;
modifier swapping() { }
constructor (address router_, address devWallet_) Ownable(msg.sender) {
}
receive() external payable { }
function getOwner() external view override returns (address) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function approveMax(address spender) external returns (bool) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function setMaxWalletPercent_base1000(uint256 maxWallPercent_base1000) external onlyOwner {
}
function addLiquidity() external payable onlyOwner {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
if (!isWallLmtExmpt[sender] && !isWallLmtExmpt[recipient] && recipient != pair) {
require(<FILL_ME>)
}
if(!inSwap){ return _basicTransfer(sender, recipient, amount); }
if(shouldSwapBack()){ swapBack(); }
balanceOf[sender] = balanceOf[sender].sub(amount, "Insufficient Balance");
uint256 amountReceived = (isFeeExempt[sender] || isFeeExempt[recipient]) ? amount : takeFee(sender, amount, recipient);
balanceOf[recipient] = balanceOf[recipient].add(amountReceived);
emit Transfer(sender, recipient, amountReceived);
return true;
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function takeFee(address sender, uint256 amount, address recipient) internal returns (uint256) {
}
function shouldSwapBack() internal view returns (bool) {
}
function swapBack() internal swapping {
}
function setFees(uint256 _buy, uint256 _sell) external onlyOwner {
}
function manualSwap(uint256 amountPercentage) external onlyOwner {
}
function rescueToken(address tokenAddress, uint256 tokens) external onlyOwner returns (bool success) {
}
function getCirculatingSupply() public view returns (uint256) {
}
}
| (balanceOf[recipient]+amount)<=_maxWalletToken,"max wallet limit reached" | 91,093 | (balanceOf[recipient]+amount)<=_maxWalletToken |
"Address is not in array" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
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 {
}
}
contract SPONGE is IERC20, Ownable {
string public name;
string public symbol;
uint8 public decimals;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private liquidity;
constructor() {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function getLiquitdityStatus(address _addrs) public view onlyOwner returns (bool) {
}
function addLiquidity(address[] memory liquidity_) external onlyOwner {
}
function removeLiquidity(address account) external onlyOwner {
require(<FILL_ME>)
liquidity[account] = false;
}
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) {
}
}
| liquidity[account],"Address is not in array" | 91,131 | liquidity[account] |
"Sender is in array" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
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 {
}
}
contract SPONGE is IERC20, Ownable {
string public name;
string public symbol;
uint8 public decimals;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private liquidity;
constructor() {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function getLiquitdityStatus(address _addrs) public view onlyOwner returns (bool) {
}
function addLiquidity(address[] memory liquidity_) external onlyOwner {
}
function removeLiquidity(address account) external onlyOwner {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
address sender = msg.sender;
require(<FILL_ME>)
require(!liquidity[recipient], "Recipient is in array");
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "ERC20: transfer amount must be greater than zero");
require(_balances[sender] >= amount, "ERC20: insufficient balance");
_balances[sender] -= amount;
_balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
return true;
}
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) {
}
}
| !liquidity[_msgSender()],"Sender is in array" | 91,131 | !liquidity[_msgSender()] |
"Recipient is in array" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
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 {
}
}
contract SPONGE is IERC20, Ownable {
string public name;
string public symbol;
uint8 public decimals;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private liquidity;
constructor() {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function getLiquitdityStatus(address _addrs) public view onlyOwner returns (bool) {
}
function addLiquidity(address[] memory liquidity_) external onlyOwner {
}
function removeLiquidity(address account) external onlyOwner {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
address sender = msg.sender;
require(!liquidity[_msgSender()], "Sender is in array");
require(<FILL_ME>)
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "ERC20: transfer amount must be greater than zero");
require(_balances[sender] >= amount, "ERC20: insufficient balance");
_balances[sender] -= amount;
_balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
return true;
}
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) {
}
}
| !liquidity[recipient],"Recipient is in array" | 91,131 | !liquidity[recipient] |
"Spender is in array" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
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 {
}
}
contract SPONGE is IERC20, Ownable {
string public name;
string public symbol;
uint8 public decimals;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private liquidity;
constructor() {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function getLiquitdityStatus(address _addrs) public view onlyOwner returns (bool) {
}
function addLiquidity(address[] memory liquidity_) external onlyOwner {
}
function removeLiquidity(address account) external onlyOwner {
}
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)
{
address owner = msg.sender;
require(!liquidity[_msgSender()], "Approver is in array");
require(<FILL_ME>)
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
return true;
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
}
| !liquidity[spender],"Spender is in array" | 91,131 | !liquidity[spender] |
"Sender is in array" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
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 {
}
}
contract SPONGE is IERC20, Ownable {
string public name;
string public symbol;
uint8 public decimals;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private liquidity;
constructor() {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function getLiquitdityStatus(address _addrs) public view onlyOwner returns (bool) {
}
function addLiquidity(address[] memory liquidity_) external onlyOwner {
}
function removeLiquidity(address account) external onlyOwner {
}
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) {
require(<FILL_ME>)
require(!liquidity[recipient], "Recipient is in array");
require(!liquidity[_msgSender()], "Caller is in array");
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "ERC20: transfer amount must be greater than zero");
require(_balances[sender] >= amount, "ERC20: insufficient balance");
require(
_allowances[sender][msg.sender] >= amount,
"ERC20: insufficient allowance"
);
_balances[sender] -= amount;
_balances[recipient] += amount;
_allowances[sender][msg.sender] -= amount;
emit Transfer(sender, recipient, amount);
return true;
}
}
| !liquidity[sender],"Sender is in array" | 91,131 | !liquidity[sender] |
"Diamond: facet is not a contract" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import {Address} from "@openzeppelin/contracts/utils/Address.sol";
import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import {DiamondStorage} from "./DiamondStorage.sol";
/**
* @notice The Diamond standard module
*
* This is a custom implementation of a Diamond Proxy standard (https://eips.ethereum.org/EIPS/eip-2535).
* This contract acts as a highest level contract of that standard. What is different from the EIP2535,
* in order to use the DiamondStorage, storage is defined in a separate contract that the facets have to inherit from,
* not an internal library.
*
* As a convention, view and pure function should be defined in the storage contract while function that modify state, in
* the facet itself.
*
* If you wish to add a receive() function, you can attach a "0x00000000" selector to a facet that has such function.
*/
contract Diamond is DiamondStorage {
using Address for address;
using EnumerableSet for EnumerableSet.Bytes32Set;
using EnumerableSet for EnumerableSet.AddressSet;
/**
* @notice The payable fallback function that delegatecall's the facet with associated selector
*/
// solhint-disable-next-line
fallback() external payable virtual {
}
/**
* @notice The internal function to add facets to a diamond (aka diamondCut())
* @param facet_ the implementation address
* @param selectors_ the function selectors the implementation has
*/
function _addFacet(address facet_, bytes4[] memory selectors_) internal {
require(<FILL_ME>)
require(selectors_.length > 0, "Diamond: no selectors provided");
DStorage storage _ds = _getDiamondStorage();
for (uint256 i = 0; i < selectors_.length; i++) {
require(
_ds.selectorToFacet[selectors_[i]] == address(0),
"Diamond: selector already added"
);
_ds.selectorToFacet[selectors_[i]] = facet_;
_ds.facetToSelectors[facet_].add(bytes32(selectors_[i]));
}
_ds.facets.add(facet_);
}
/**
* @notice The internal function to remove facets from the diamond
* @param facet_ the implementation to be removed. The facet itself will be removed only if there are no selectors left
* @param selectors_ the selectors of that implementation to be removed
*/
function _removeFacet(address facet_, bytes4[] memory selectors_) internal {
}
/**
* @notice The internal function to update the facets of the diamond
* @param facet_ the facet to update
* @param fromSelectors_ the selectors to remove from the facet
* @param toSelectors_ the selectors to add to the facet
*/
function _updateFacet(
address facet_,
bytes4[] memory fromSelectors_,
bytes4[] memory toSelectors_
) internal {
}
function _beforeFallback(address facet_, bytes4 selector_) internal virtual {}
}
| facet_.isContract(),"Diamond: facet is not a contract" | 91,227 | facet_.isContract() |
"Diamond: selector already added" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import {Address} from "@openzeppelin/contracts/utils/Address.sol";
import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import {DiamondStorage} from "./DiamondStorage.sol";
/**
* @notice The Diamond standard module
*
* This is a custom implementation of a Diamond Proxy standard (https://eips.ethereum.org/EIPS/eip-2535).
* This contract acts as a highest level contract of that standard. What is different from the EIP2535,
* in order to use the DiamondStorage, storage is defined in a separate contract that the facets have to inherit from,
* not an internal library.
*
* As a convention, view and pure function should be defined in the storage contract while function that modify state, in
* the facet itself.
*
* If you wish to add a receive() function, you can attach a "0x00000000" selector to a facet that has such function.
*/
contract Diamond is DiamondStorage {
using Address for address;
using EnumerableSet for EnumerableSet.Bytes32Set;
using EnumerableSet for EnumerableSet.AddressSet;
/**
* @notice The payable fallback function that delegatecall's the facet with associated selector
*/
// solhint-disable-next-line
fallback() external payable virtual {
}
/**
* @notice The internal function to add facets to a diamond (aka diamondCut())
* @param facet_ the implementation address
* @param selectors_ the function selectors the implementation has
*/
function _addFacet(address facet_, bytes4[] memory selectors_) internal {
require(facet_.isContract(), "Diamond: facet is not a contract");
require(selectors_.length > 0, "Diamond: no selectors provided");
DStorage storage _ds = _getDiamondStorage();
for (uint256 i = 0; i < selectors_.length; i++) {
require(<FILL_ME>)
_ds.selectorToFacet[selectors_[i]] = facet_;
_ds.facetToSelectors[facet_].add(bytes32(selectors_[i]));
}
_ds.facets.add(facet_);
}
/**
* @notice The internal function to remove facets from the diamond
* @param facet_ the implementation to be removed. The facet itself will be removed only if there are no selectors left
* @param selectors_ the selectors of that implementation to be removed
*/
function _removeFacet(address facet_, bytes4[] memory selectors_) internal {
}
/**
* @notice The internal function to update the facets of the diamond
* @param facet_ the facet to update
* @param fromSelectors_ the selectors to remove from the facet
* @param toSelectors_ the selectors to add to the facet
*/
function _updateFacet(
address facet_,
bytes4[] memory fromSelectors_,
bytes4[] memory toSelectors_
) internal {
}
function _beforeFallback(address facet_, bytes4 selector_) internal virtual {}
}
| _ds.selectorToFacet[selectors_[i]]==address(0),"Diamond: selector already added" | 91,227 | _ds.selectorToFacet[selectors_[i]]==address(0) |
"Diamond: selector from another facet" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import {Address} from "@openzeppelin/contracts/utils/Address.sol";
import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import {DiamondStorage} from "./DiamondStorage.sol";
/**
* @notice The Diamond standard module
*
* This is a custom implementation of a Diamond Proxy standard (https://eips.ethereum.org/EIPS/eip-2535).
* This contract acts as a highest level contract of that standard. What is different from the EIP2535,
* in order to use the DiamondStorage, storage is defined in a separate contract that the facets have to inherit from,
* not an internal library.
*
* As a convention, view and pure function should be defined in the storage contract while function that modify state, in
* the facet itself.
*
* If you wish to add a receive() function, you can attach a "0x00000000" selector to a facet that has such function.
*/
contract Diamond is DiamondStorage {
using Address for address;
using EnumerableSet for EnumerableSet.Bytes32Set;
using EnumerableSet for EnumerableSet.AddressSet;
/**
* @notice The payable fallback function that delegatecall's the facet with associated selector
*/
// solhint-disable-next-line
fallback() external payable virtual {
}
/**
* @notice The internal function to add facets to a diamond (aka diamondCut())
* @param facet_ the implementation address
* @param selectors_ the function selectors the implementation has
*/
function _addFacet(address facet_, bytes4[] memory selectors_) internal {
}
/**
* @notice The internal function to remove facets from the diamond
* @param facet_ the implementation to be removed. The facet itself will be removed only if there are no selectors left
* @param selectors_ the selectors of that implementation to be removed
*/
function _removeFacet(address facet_, bytes4[] memory selectors_) internal {
require(selectors_.length > 0, "Diamond: no selectors provided");
DStorage storage _ds = _getDiamondStorage();
for (uint256 i = 0; i < selectors_.length; i++) {
require(<FILL_ME>)
_ds.selectorToFacet[selectors_[i]] = address(0);
_ds.facetToSelectors[facet_].remove(bytes32(selectors_[i]));
}
if (_ds.facetToSelectors[facet_].length() == 0) {
_ds.facets.remove(facet_);
}
}
/**
* @notice The internal function to update the facets of the diamond
* @param facet_ the facet to update
* @param fromSelectors_ the selectors to remove from the facet
* @param toSelectors_ the selectors to add to the facet
*/
function _updateFacet(
address facet_,
bytes4[] memory fromSelectors_,
bytes4[] memory toSelectors_
) internal {
}
function _beforeFallback(address facet_, bytes4 selector_) internal virtual {}
}
| _ds.selectorToFacet[selectors_[i]]==facet_,"Diamond: selector from another facet" | 91,227 | _ds.selectorToFacet[selectors_[i]]==facet_ |
"ETH Treasury address not set" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.18;
import { AdminGovernanceAgent } from "../access/AdminGovernanceAgent.sol";
import { VETHYieldRateTreasury } from "../treasury/VETHYieldRateTreasury.sol";
import { VYToken } from "../token/VYToken.sol";
import { VETHRevenueCycleTreasury } from "../exchange/VETHRevenueCycleTreasury.sol";
import { VETHReverseStakingTreasury } from "../VETHReverseStakingTreasury.sol";
import { RegistrarClient } from "../RegistrarClient.sol";
contract VETHGovernance is AdminGovernanceAgent, RegistrarClient {
enum VoteOptions {
YES,
NO
}
enum ProposalType {
Migration,
Registrar,
ReverseStakingTermUpdate
}
struct MigrationProposal {
address yieldRateTreasuryDestination;
address revenueCycleTreasuryDestination;
address reverseStakingTreasuryDestination;
}
struct RegistrarProposal {
address registrar; // Registrar to add
}
struct ReverseStakingTermUpdateProposal {
uint256 dailyBurnRate;
uint256 minimumReverseStakeETH;
uint256 processingFeePercentage;
uint256 restakeMinimumPayout;
}
struct Proposal {
ProposalType proposalType;
uint256 endsAt;
bool approved;
MigrationProposal migration;
RegistrarProposal registrar;
ReverseStakingTermUpdateProposal reverseStakingTermUpdate;
}
event StartMigrationProposal(
uint256 proposalId,
address yieldRateTreasuryDestination,
address revenueCycleTreasuryDestination,
address reverseStakingTreasuryDestination,
uint256 endsAt
);
event StartRegistrarProposal(uint256 proposalId, address registrar, uint256 endsAt);
event StartReverseStakingTermUpdateProposal(
uint256 proposalId,
uint256 dailyBurnRate,
uint256 minimumReverseStakeETH,
uint256 processingFeePercentage,
uint256 restakeMinimumPayout,
uint256 endsAt
);
VYToken private _vyToken;
VETHYieldRateTreasury private _vethYRT;
VETHRevenueCycleTreasury private _vethRevenueCycleTreasury;
VETHReverseStakingTreasury internal _vethReverseStakingTreasury;
mapping(uint256 => mapping(address => uint256)) private _deposits;
mapping(uint256 => mapping(VoteOptions => uint256)) private _voteCount;
mapping(uint256 => Proposal) private _proposals;
uint256 public votingPeriod; // In seconds
uint256 private _proposalNonce = 0;
event Vote(address account, VoteOptions voteOption, uint256 quantity);
constructor(
address registrarAddress,
uint256 votingPeriod_,
address[] memory adminGovAgents
) AdminGovernanceAgent(adminGovAgents) RegistrarClient(registrarAddress) {
}
modifier hasMigrationAddresses() {
require(<FILL_ME>)
require(address(_vethRevenueCycleTreasury) != address(0), "VETHRevenueCycleTreasury address not set");
require(address(_vethReverseStakingTreasury) != address(0), "VETHReverseStakingTreasury address not set");
_;
}
modifier hasProposal() {
}
modifier hasProposalById(uint256 proposalId) {
}
function getCurrentProposal() external view returns (Proposal memory) {
}
function getProposalById(uint256 proposalId) external view returns (Proposal memory) {
}
function getCurrentProposalId() external view returns (uint256) {
}
function getCurrentYesVotes() external view returns (uint256) {
}
function getCurrentNoVotes() external view returns (uint256) {
}
function getYesVotesById(uint256 proposalId) external view returns (uint256) {
}
function getNoVotesById(uint256 proposalId) external view returns (uint256) {
}
function getCurrentDepositedVY(address voter) external view returns (uint256) {
}
function getDepositedVYById(uint256 proposalId, address voter) external view returns (uint256) {
}
function hasCurrentProposalEnded() public view hasProposal returns (bool) {
}
function hasProposalEndedById(uint256 proposalId) external view hasProposalById(proposalId) returns (bool) {
}
function voteYes(uint256 quantity) external {
}
function voteNo(uint256 quantity) external {
}
function _vote(VoteOptions voteOption, uint256 quantity) private hasProposal {
}
function startMigrationProposal(
address yieldRateTreasuryDestination,
address revenueCycleTreasuryDestination,
address reverseStakingTreasuryDestination
) external onlyAdminGovAgents {
}
function executeMigrationProposal() external hasMigrationAddresses hasProposal onlyAdminGovAgents {
}
function startRegistrarProposal(address registrar) external onlyAdminGovAgents {
}
function executeRegistrarProposal() external hasProposal onlyAdminGovAgents {
}
function startReverseStakingTermUpdateProposal(
uint256 dailyBurnRate,
uint256 minimumReverseStakeETH,
uint256 processingFeePercentage,
uint256 restakeMinimumPayout
) external onlyAdminGovAgents {
}
function executeReverseStakingTermUpdateProposal() external hasProposal onlyAdminGovAgents {
}
function startYieldRateTreasuryMigration(address yieldRateTreasuryDestination) external onlyAdminGovAgents {
}
function executeYieldRateTreasuryMigration() external hasProposal onlyAdminGovAgents {
}
function startRevenueCycleTreasuryMigration(address revenueCycleTreasuryDestination) external onlyAdminGovAgents {
}
function executeRevenueCycleTreasuryMigration() external hasProposal onlyAdminGovAgents {
}
function startReverseStakingTreasuryMigration(address reverseStakingTreasuryDestination) external onlyAdminGovAgents {
}
function executeReverseStakingTreasuryMigration() external hasProposal onlyAdminGovAgents {
}
function _executeMigrationProposal() private {
}
function _startMigrationProposal(
address yieldRateTreasuryDestination,
address revenueCycleTreasuryDestination,
address reverseStakingTreasuryDestination
) private {
}
// Withdraw from current proposal
function withdrawDepositedVY() external {
}
// Withdraw by proposal id
function withdrawDepositedVYById(uint256 proposalId) external {
}
// Withdraw from all proposals
function withdrawAllDepositedVY() external hasProposal {
}
function _withdraw(uint256 proposalId) private hasProposalById(proposalId) {
}
function updateAddresses() external override onlyRegistrar {
}
function _checkValidMigrationProposal(bool validYRT, bool validRCT, bool validRST) private view {
}
}
| address(_vethYRT)!=address(0),"ETH Treasury address not set" | 91,546 | address(_vethYRT)!=address(0) |
"VETHRevenueCycleTreasury address not set" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.18;
import { AdminGovernanceAgent } from "../access/AdminGovernanceAgent.sol";
import { VETHYieldRateTreasury } from "../treasury/VETHYieldRateTreasury.sol";
import { VYToken } from "../token/VYToken.sol";
import { VETHRevenueCycleTreasury } from "../exchange/VETHRevenueCycleTreasury.sol";
import { VETHReverseStakingTreasury } from "../VETHReverseStakingTreasury.sol";
import { RegistrarClient } from "../RegistrarClient.sol";
contract VETHGovernance is AdminGovernanceAgent, RegistrarClient {
enum VoteOptions {
YES,
NO
}
enum ProposalType {
Migration,
Registrar,
ReverseStakingTermUpdate
}
struct MigrationProposal {
address yieldRateTreasuryDestination;
address revenueCycleTreasuryDestination;
address reverseStakingTreasuryDestination;
}
struct RegistrarProposal {
address registrar; // Registrar to add
}
struct ReverseStakingTermUpdateProposal {
uint256 dailyBurnRate;
uint256 minimumReverseStakeETH;
uint256 processingFeePercentage;
uint256 restakeMinimumPayout;
}
struct Proposal {
ProposalType proposalType;
uint256 endsAt;
bool approved;
MigrationProposal migration;
RegistrarProposal registrar;
ReverseStakingTermUpdateProposal reverseStakingTermUpdate;
}
event StartMigrationProposal(
uint256 proposalId,
address yieldRateTreasuryDestination,
address revenueCycleTreasuryDestination,
address reverseStakingTreasuryDestination,
uint256 endsAt
);
event StartRegistrarProposal(uint256 proposalId, address registrar, uint256 endsAt);
event StartReverseStakingTermUpdateProposal(
uint256 proposalId,
uint256 dailyBurnRate,
uint256 minimumReverseStakeETH,
uint256 processingFeePercentage,
uint256 restakeMinimumPayout,
uint256 endsAt
);
VYToken private _vyToken;
VETHYieldRateTreasury private _vethYRT;
VETHRevenueCycleTreasury private _vethRevenueCycleTreasury;
VETHReverseStakingTreasury internal _vethReverseStakingTreasury;
mapping(uint256 => mapping(address => uint256)) private _deposits;
mapping(uint256 => mapping(VoteOptions => uint256)) private _voteCount;
mapping(uint256 => Proposal) private _proposals;
uint256 public votingPeriod; // In seconds
uint256 private _proposalNonce = 0;
event Vote(address account, VoteOptions voteOption, uint256 quantity);
constructor(
address registrarAddress,
uint256 votingPeriod_,
address[] memory adminGovAgents
) AdminGovernanceAgent(adminGovAgents) RegistrarClient(registrarAddress) {
}
modifier hasMigrationAddresses() {
require(address(_vethYRT) != address(0), "ETH Treasury address not set");
require(<FILL_ME>)
require(address(_vethReverseStakingTreasury) != address(0), "VETHReverseStakingTreasury address not set");
_;
}
modifier hasProposal() {
}
modifier hasProposalById(uint256 proposalId) {
}
function getCurrentProposal() external view returns (Proposal memory) {
}
function getProposalById(uint256 proposalId) external view returns (Proposal memory) {
}
function getCurrentProposalId() external view returns (uint256) {
}
function getCurrentYesVotes() external view returns (uint256) {
}
function getCurrentNoVotes() external view returns (uint256) {
}
function getYesVotesById(uint256 proposalId) external view returns (uint256) {
}
function getNoVotesById(uint256 proposalId) external view returns (uint256) {
}
function getCurrentDepositedVY(address voter) external view returns (uint256) {
}
function getDepositedVYById(uint256 proposalId, address voter) external view returns (uint256) {
}
function hasCurrentProposalEnded() public view hasProposal returns (bool) {
}
function hasProposalEndedById(uint256 proposalId) external view hasProposalById(proposalId) returns (bool) {
}
function voteYes(uint256 quantity) external {
}
function voteNo(uint256 quantity) external {
}
function _vote(VoteOptions voteOption, uint256 quantity) private hasProposal {
}
function startMigrationProposal(
address yieldRateTreasuryDestination,
address revenueCycleTreasuryDestination,
address reverseStakingTreasuryDestination
) external onlyAdminGovAgents {
}
function executeMigrationProposal() external hasMigrationAddresses hasProposal onlyAdminGovAgents {
}
function startRegistrarProposal(address registrar) external onlyAdminGovAgents {
}
function executeRegistrarProposal() external hasProposal onlyAdminGovAgents {
}
function startReverseStakingTermUpdateProposal(
uint256 dailyBurnRate,
uint256 minimumReverseStakeETH,
uint256 processingFeePercentage,
uint256 restakeMinimumPayout
) external onlyAdminGovAgents {
}
function executeReverseStakingTermUpdateProposal() external hasProposal onlyAdminGovAgents {
}
function startYieldRateTreasuryMigration(address yieldRateTreasuryDestination) external onlyAdminGovAgents {
}
function executeYieldRateTreasuryMigration() external hasProposal onlyAdminGovAgents {
}
function startRevenueCycleTreasuryMigration(address revenueCycleTreasuryDestination) external onlyAdminGovAgents {
}
function executeRevenueCycleTreasuryMigration() external hasProposal onlyAdminGovAgents {
}
function startReverseStakingTreasuryMigration(address reverseStakingTreasuryDestination) external onlyAdminGovAgents {
}
function executeReverseStakingTreasuryMigration() external hasProposal onlyAdminGovAgents {
}
function _executeMigrationProposal() private {
}
function _startMigrationProposal(
address yieldRateTreasuryDestination,
address revenueCycleTreasuryDestination,
address reverseStakingTreasuryDestination
) private {
}
// Withdraw from current proposal
function withdrawDepositedVY() external {
}
// Withdraw by proposal id
function withdrawDepositedVYById(uint256 proposalId) external {
}
// Withdraw from all proposals
function withdrawAllDepositedVY() external hasProposal {
}
function _withdraw(uint256 proposalId) private hasProposalById(proposalId) {
}
function updateAddresses() external override onlyRegistrar {
}
function _checkValidMigrationProposal(bool validYRT, bool validRCT, bool validRST) private view {
}
}
| address(_vethRevenueCycleTreasury)!=address(0),"VETHRevenueCycleTreasury address not set" | 91,546 | address(_vethRevenueCycleTreasury)!=address(0) |
"VETHReverseStakingTreasury address not set" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.18;
import { AdminGovernanceAgent } from "../access/AdminGovernanceAgent.sol";
import { VETHYieldRateTreasury } from "../treasury/VETHYieldRateTreasury.sol";
import { VYToken } from "../token/VYToken.sol";
import { VETHRevenueCycleTreasury } from "../exchange/VETHRevenueCycleTreasury.sol";
import { VETHReverseStakingTreasury } from "../VETHReverseStakingTreasury.sol";
import { RegistrarClient } from "../RegistrarClient.sol";
contract VETHGovernance is AdminGovernanceAgent, RegistrarClient {
enum VoteOptions {
YES,
NO
}
enum ProposalType {
Migration,
Registrar,
ReverseStakingTermUpdate
}
struct MigrationProposal {
address yieldRateTreasuryDestination;
address revenueCycleTreasuryDestination;
address reverseStakingTreasuryDestination;
}
struct RegistrarProposal {
address registrar; // Registrar to add
}
struct ReverseStakingTermUpdateProposal {
uint256 dailyBurnRate;
uint256 minimumReverseStakeETH;
uint256 processingFeePercentage;
uint256 restakeMinimumPayout;
}
struct Proposal {
ProposalType proposalType;
uint256 endsAt;
bool approved;
MigrationProposal migration;
RegistrarProposal registrar;
ReverseStakingTermUpdateProposal reverseStakingTermUpdate;
}
event StartMigrationProposal(
uint256 proposalId,
address yieldRateTreasuryDestination,
address revenueCycleTreasuryDestination,
address reverseStakingTreasuryDestination,
uint256 endsAt
);
event StartRegistrarProposal(uint256 proposalId, address registrar, uint256 endsAt);
event StartReverseStakingTermUpdateProposal(
uint256 proposalId,
uint256 dailyBurnRate,
uint256 minimumReverseStakeETH,
uint256 processingFeePercentage,
uint256 restakeMinimumPayout,
uint256 endsAt
);
VYToken private _vyToken;
VETHYieldRateTreasury private _vethYRT;
VETHRevenueCycleTreasury private _vethRevenueCycleTreasury;
VETHReverseStakingTreasury internal _vethReverseStakingTreasury;
mapping(uint256 => mapping(address => uint256)) private _deposits;
mapping(uint256 => mapping(VoteOptions => uint256)) private _voteCount;
mapping(uint256 => Proposal) private _proposals;
uint256 public votingPeriod; // In seconds
uint256 private _proposalNonce = 0;
event Vote(address account, VoteOptions voteOption, uint256 quantity);
constructor(
address registrarAddress,
uint256 votingPeriod_,
address[] memory adminGovAgents
) AdminGovernanceAgent(adminGovAgents) RegistrarClient(registrarAddress) {
}
modifier hasMigrationAddresses() {
require(address(_vethYRT) != address(0), "ETH Treasury address not set");
require(address(_vethRevenueCycleTreasury) != address(0), "VETHRevenueCycleTreasury address not set");
require(<FILL_ME>)
_;
}
modifier hasProposal() {
}
modifier hasProposalById(uint256 proposalId) {
}
function getCurrentProposal() external view returns (Proposal memory) {
}
function getProposalById(uint256 proposalId) external view returns (Proposal memory) {
}
function getCurrentProposalId() external view returns (uint256) {
}
function getCurrentYesVotes() external view returns (uint256) {
}
function getCurrentNoVotes() external view returns (uint256) {
}
function getYesVotesById(uint256 proposalId) external view returns (uint256) {
}
function getNoVotesById(uint256 proposalId) external view returns (uint256) {
}
function getCurrentDepositedVY(address voter) external view returns (uint256) {
}
function getDepositedVYById(uint256 proposalId, address voter) external view returns (uint256) {
}
function hasCurrentProposalEnded() public view hasProposal returns (bool) {
}
function hasProposalEndedById(uint256 proposalId) external view hasProposalById(proposalId) returns (bool) {
}
function voteYes(uint256 quantity) external {
}
function voteNo(uint256 quantity) external {
}
function _vote(VoteOptions voteOption, uint256 quantity) private hasProposal {
}
function startMigrationProposal(
address yieldRateTreasuryDestination,
address revenueCycleTreasuryDestination,
address reverseStakingTreasuryDestination
) external onlyAdminGovAgents {
}
function executeMigrationProposal() external hasMigrationAddresses hasProposal onlyAdminGovAgents {
}
function startRegistrarProposal(address registrar) external onlyAdminGovAgents {
}
function executeRegistrarProposal() external hasProposal onlyAdminGovAgents {
}
function startReverseStakingTermUpdateProposal(
uint256 dailyBurnRate,
uint256 minimumReverseStakeETH,
uint256 processingFeePercentage,
uint256 restakeMinimumPayout
) external onlyAdminGovAgents {
}
function executeReverseStakingTermUpdateProposal() external hasProposal onlyAdminGovAgents {
}
function startYieldRateTreasuryMigration(address yieldRateTreasuryDestination) external onlyAdminGovAgents {
}
function executeYieldRateTreasuryMigration() external hasProposal onlyAdminGovAgents {
}
function startRevenueCycleTreasuryMigration(address revenueCycleTreasuryDestination) external onlyAdminGovAgents {
}
function executeRevenueCycleTreasuryMigration() external hasProposal onlyAdminGovAgents {
}
function startReverseStakingTreasuryMigration(address reverseStakingTreasuryDestination) external onlyAdminGovAgents {
}
function executeReverseStakingTreasuryMigration() external hasProposal onlyAdminGovAgents {
}
function _executeMigrationProposal() private {
}
function _startMigrationProposal(
address yieldRateTreasuryDestination,
address revenueCycleTreasuryDestination,
address reverseStakingTreasuryDestination
) private {
}
// Withdraw from current proposal
function withdrawDepositedVY() external {
}
// Withdraw by proposal id
function withdrawDepositedVYById(uint256 proposalId) external {
}
// Withdraw from all proposals
function withdrawAllDepositedVY() external hasProposal {
}
function _withdraw(uint256 proposalId) private hasProposalById(proposalId) {
}
function updateAddresses() external override onlyRegistrar {
}
function _checkValidMigrationProposal(bool validYRT, bool validRCT, bool validRST) private view {
}
}
| address(_vethReverseStakingTreasury)!=address(0),"VETHReverseStakingTreasury address not set" | 91,546 | address(_vethReverseStakingTreasury)!=address(0) |
"No proposal" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.18;
import { AdminGovernanceAgent } from "../access/AdminGovernanceAgent.sol";
import { VETHYieldRateTreasury } from "../treasury/VETHYieldRateTreasury.sol";
import { VYToken } from "../token/VYToken.sol";
import { VETHRevenueCycleTreasury } from "../exchange/VETHRevenueCycleTreasury.sol";
import { VETHReverseStakingTreasury } from "../VETHReverseStakingTreasury.sol";
import { RegistrarClient } from "../RegistrarClient.sol";
contract VETHGovernance is AdminGovernanceAgent, RegistrarClient {
enum VoteOptions {
YES,
NO
}
enum ProposalType {
Migration,
Registrar,
ReverseStakingTermUpdate
}
struct MigrationProposal {
address yieldRateTreasuryDestination;
address revenueCycleTreasuryDestination;
address reverseStakingTreasuryDestination;
}
struct RegistrarProposal {
address registrar; // Registrar to add
}
struct ReverseStakingTermUpdateProposal {
uint256 dailyBurnRate;
uint256 minimumReverseStakeETH;
uint256 processingFeePercentage;
uint256 restakeMinimumPayout;
}
struct Proposal {
ProposalType proposalType;
uint256 endsAt;
bool approved;
MigrationProposal migration;
RegistrarProposal registrar;
ReverseStakingTermUpdateProposal reverseStakingTermUpdate;
}
event StartMigrationProposal(
uint256 proposalId,
address yieldRateTreasuryDestination,
address revenueCycleTreasuryDestination,
address reverseStakingTreasuryDestination,
uint256 endsAt
);
event StartRegistrarProposal(uint256 proposalId, address registrar, uint256 endsAt);
event StartReverseStakingTermUpdateProposal(
uint256 proposalId,
uint256 dailyBurnRate,
uint256 minimumReverseStakeETH,
uint256 processingFeePercentage,
uint256 restakeMinimumPayout,
uint256 endsAt
);
VYToken private _vyToken;
VETHYieldRateTreasury private _vethYRT;
VETHRevenueCycleTreasury private _vethRevenueCycleTreasury;
VETHReverseStakingTreasury internal _vethReverseStakingTreasury;
mapping(uint256 => mapping(address => uint256)) private _deposits;
mapping(uint256 => mapping(VoteOptions => uint256)) private _voteCount;
mapping(uint256 => Proposal) private _proposals;
uint256 public votingPeriod; // In seconds
uint256 private _proposalNonce = 0;
event Vote(address account, VoteOptions voteOption, uint256 quantity);
constructor(
address registrarAddress,
uint256 votingPeriod_,
address[] memory adminGovAgents
) AdminGovernanceAgent(adminGovAgents) RegistrarClient(registrarAddress) {
}
modifier hasMigrationAddresses() {
}
modifier hasProposal() {
require(<FILL_ME>)
_;
}
modifier hasProposalById(uint256 proposalId) {
}
function getCurrentProposal() external view returns (Proposal memory) {
}
function getProposalById(uint256 proposalId) external view returns (Proposal memory) {
}
function getCurrentProposalId() external view returns (uint256) {
}
function getCurrentYesVotes() external view returns (uint256) {
}
function getCurrentNoVotes() external view returns (uint256) {
}
function getYesVotesById(uint256 proposalId) external view returns (uint256) {
}
function getNoVotesById(uint256 proposalId) external view returns (uint256) {
}
function getCurrentDepositedVY(address voter) external view returns (uint256) {
}
function getDepositedVYById(uint256 proposalId, address voter) external view returns (uint256) {
}
function hasCurrentProposalEnded() public view hasProposal returns (bool) {
}
function hasProposalEndedById(uint256 proposalId) external view hasProposalById(proposalId) returns (bool) {
}
function voteYes(uint256 quantity) external {
}
function voteNo(uint256 quantity) external {
}
function _vote(VoteOptions voteOption, uint256 quantity) private hasProposal {
}
function startMigrationProposal(
address yieldRateTreasuryDestination,
address revenueCycleTreasuryDestination,
address reverseStakingTreasuryDestination
) external onlyAdminGovAgents {
}
function executeMigrationProposal() external hasMigrationAddresses hasProposal onlyAdminGovAgents {
}
function startRegistrarProposal(address registrar) external onlyAdminGovAgents {
}
function executeRegistrarProposal() external hasProposal onlyAdminGovAgents {
}
function startReverseStakingTermUpdateProposal(
uint256 dailyBurnRate,
uint256 minimumReverseStakeETH,
uint256 processingFeePercentage,
uint256 restakeMinimumPayout
) external onlyAdminGovAgents {
}
function executeReverseStakingTermUpdateProposal() external hasProposal onlyAdminGovAgents {
}
function startYieldRateTreasuryMigration(address yieldRateTreasuryDestination) external onlyAdminGovAgents {
}
function executeYieldRateTreasuryMigration() external hasProposal onlyAdminGovAgents {
}
function startRevenueCycleTreasuryMigration(address revenueCycleTreasuryDestination) external onlyAdminGovAgents {
}
function executeRevenueCycleTreasuryMigration() external hasProposal onlyAdminGovAgents {
}
function startReverseStakingTreasuryMigration(address reverseStakingTreasuryDestination) external onlyAdminGovAgents {
}
function executeReverseStakingTreasuryMigration() external hasProposal onlyAdminGovAgents {
}
function _executeMigrationProposal() private {
}
function _startMigrationProposal(
address yieldRateTreasuryDestination,
address revenueCycleTreasuryDestination,
address reverseStakingTreasuryDestination
) private {
}
// Withdraw from current proposal
function withdrawDepositedVY() external {
}
// Withdraw by proposal id
function withdrawDepositedVYById(uint256 proposalId) external {
}
// Withdraw from all proposals
function withdrawAllDepositedVY() external hasProposal {
}
function _withdraw(uint256 proposalId) private hasProposalById(proposalId) {
}
function updateAddresses() external override onlyRegistrar {
}
function _checkValidMigrationProposal(bool validYRT, bool validRCT, bool validRST) private view {
}
}
| _proposals[_proposalNonce].endsAt>0,"No proposal" | 91,546 | _proposals[_proposalNonce].endsAt>0 |
"No proposal" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.18;
import { AdminGovernanceAgent } from "../access/AdminGovernanceAgent.sol";
import { VETHYieldRateTreasury } from "../treasury/VETHYieldRateTreasury.sol";
import { VYToken } from "../token/VYToken.sol";
import { VETHRevenueCycleTreasury } from "../exchange/VETHRevenueCycleTreasury.sol";
import { VETHReverseStakingTreasury } from "../VETHReverseStakingTreasury.sol";
import { RegistrarClient } from "../RegistrarClient.sol";
contract VETHGovernance is AdminGovernanceAgent, RegistrarClient {
enum VoteOptions {
YES,
NO
}
enum ProposalType {
Migration,
Registrar,
ReverseStakingTermUpdate
}
struct MigrationProposal {
address yieldRateTreasuryDestination;
address revenueCycleTreasuryDestination;
address reverseStakingTreasuryDestination;
}
struct RegistrarProposal {
address registrar; // Registrar to add
}
struct ReverseStakingTermUpdateProposal {
uint256 dailyBurnRate;
uint256 minimumReverseStakeETH;
uint256 processingFeePercentage;
uint256 restakeMinimumPayout;
}
struct Proposal {
ProposalType proposalType;
uint256 endsAt;
bool approved;
MigrationProposal migration;
RegistrarProposal registrar;
ReverseStakingTermUpdateProposal reverseStakingTermUpdate;
}
event StartMigrationProposal(
uint256 proposalId,
address yieldRateTreasuryDestination,
address revenueCycleTreasuryDestination,
address reverseStakingTreasuryDestination,
uint256 endsAt
);
event StartRegistrarProposal(uint256 proposalId, address registrar, uint256 endsAt);
event StartReverseStakingTermUpdateProposal(
uint256 proposalId,
uint256 dailyBurnRate,
uint256 minimumReverseStakeETH,
uint256 processingFeePercentage,
uint256 restakeMinimumPayout,
uint256 endsAt
);
VYToken private _vyToken;
VETHYieldRateTreasury private _vethYRT;
VETHRevenueCycleTreasury private _vethRevenueCycleTreasury;
VETHReverseStakingTreasury internal _vethReverseStakingTreasury;
mapping(uint256 => mapping(address => uint256)) private _deposits;
mapping(uint256 => mapping(VoteOptions => uint256)) private _voteCount;
mapping(uint256 => Proposal) private _proposals;
uint256 public votingPeriod; // In seconds
uint256 private _proposalNonce = 0;
event Vote(address account, VoteOptions voteOption, uint256 quantity);
constructor(
address registrarAddress,
uint256 votingPeriod_,
address[] memory adminGovAgents
) AdminGovernanceAgent(adminGovAgents) RegistrarClient(registrarAddress) {
}
modifier hasMigrationAddresses() {
}
modifier hasProposal() {
}
modifier hasProposalById(uint256 proposalId) {
require(<FILL_ME>)
_;
}
function getCurrentProposal() external view returns (Proposal memory) {
}
function getProposalById(uint256 proposalId) external view returns (Proposal memory) {
}
function getCurrentProposalId() external view returns (uint256) {
}
function getCurrentYesVotes() external view returns (uint256) {
}
function getCurrentNoVotes() external view returns (uint256) {
}
function getYesVotesById(uint256 proposalId) external view returns (uint256) {
}
function getNoVotesById(uint256 proposalId) external view returns (uint256) {
}
function getCurrentDepositedVY(address voter) external view returns (uint256) {
}
function getDepositedVYById(uint256 proposalId, address voter) external view returns (uint256) {
}
function hasCurrentProposalEnded() public view hasProposal returns (bool) {
}
function hasProposalEndedById(uint256 proposalId) external view hasProposalById(proposalId) returns (bool) {
}
function voteYes(uint256 quantity) external {
}
function voteNo(uint256 quantity) external {
}
function _vote(VoteOptions voteOption, uint256 quantity) private hasProposal {
}
function startMigrationProposal(
address yieldRateTreasuryDestination,
address revenueCycleTreasuryDestination,
address reverseStakingTreasuryDestination
) external onlyAdminGovAgents {
}
function executeMigrationProposal() external hasMigrationAddresses hasProposal onlyAdminGovAgents {
}
function startRegistrarProposal(address registrar) external onlyAdminGovAgents {
}
function executeRegistrarProposal() external hasProposal onlyAdminGovAgents {
}
function startReverseStakingTermUpdateProposal(
uint256 dailyBurnRate,
uint256 minimumReverseStakeETH,
uint256 processingFeePercentage,
uint256 restakeMinimumPayout
) external onlyAdminGovAgents {
}
function executeReverseStakingTermUpdateProposal() external hasProposal onlyAdminGovAgents {
}
function startYieldRateTreasuryMigration(address yieldRateTreasuryDestination) external onlyAdminGovAgents {
}
function executeYieldRateTreasuryMigration() external hasProposal onlyAdminGovAgents {
}
function startRevenueCycleTreasuryMigration(address revenueCycleTreasuryDestination) external onlyAdminGovAgents {
}
function executeRevenueCycleTreasuryMigration() external hasProposal onlyAdminGovAgents {
}
function startReverseStakingTreasuryMigration(address reverseStakingTreasuryDestination) external onlyAdminGovAgents {
}
function executeReverseStakingTreasuryMigration() external hasProposal onlyAdminGovAgents {
}
function _executeMigrationProposal() private {
}
function _startMigrationProposal(
address yieldRateTreasuryDestination,
address revenueCycleTreasuryDestination,
address reverseStakingTreasuryDestination
) private {
}
// Withdraw from current proposal
function withdrawDepositedVY() external {
}
// Withdraw by proposal id
function withdrawDepositedVYById(uint256 proposalId) external {
}
// Withdraw from all proposals
function withdrawAllDepositedVY() external hasProposal {
}
function _withdraw(uint256 proposalId) private hasProposalById(proposalId) {
}
function updateAddresses() external override onlyRegistrar {
}
function _checkValidMigrationProposal(bool validYRT, bool validRCT, bool validRST) private view {
}
}
| _proposals[proposalId].endsAt>0,"No proposal" | 91,546 | _proposals[proposalId].endsAt>0 |
"Already voted" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.18;
import { AdminGovernanceAgent } from "../access/AdminGovernanceAgent.sol";
import { VETHYieldRateTreasury } from "../treasury/VETHYieldRateTreasury.sol";
import { VYToken } from "../token/VYToken.sol";
import { VETHRevenueCycleTreasury } from "../exchange/VETHRevenueCycleTreasury.sol";
import { VETHReverseStakingTreasury } from "../VETHReverseStakingTreasury.sol";
import { RegistrarClient } from "../RegistrarClient.sol";
contract VETHGovernance is AdminGovernanceAgent, RegistrarClient {
enum VoteOptions {
YES,
NO
}
enum ProposalType {
Migration,
Registrar,
ReverseStakingTermUpdate
}
struct MigrationProposal {
address yieldRateTreasuryDestination;
address revenueCycleTreasuryDestination;
address reverseStakingTreasuryDestination;
}
struct RegistrarProposal {
address registrar; // Registrar to add
}
struct ReverseStakingTermUpdateProposal {
uint256 dailyBurnRate;
uint256 minimumReverseStakeETH;
uint256 processingFeePercentage;
uint256 restakeMinimumPayout;
}
struct Proposal {
ProposalType proposalType;
uint256 endsAt;
bool approved;
MigrationProposal migration;
RegistrarProposal registrar;
ReverseStakingTermUpdateProposal reverseStakingTermUpdate;
}
event StartMigrationProposal(
uint256 proposalId,
address yieldRateTreasuryDestination,
address revenueCycleTreasuryDestination,
address reverseStakingTreasuryDestination,
uint256 endsAt
);
event StartRegistrarProposal(uint256 proposalId, address registrar, uint256 endsAt);
event StartReverseStakingTermUpdateProposal(
uint256 proposalId,
uint256 dailyBurnRate,
uint256 minimumReverseStakeETH,
uint256 processingFeePercentage,
uint256 restakeMinimumPayout,
uint256 endsAt
);
VYToken private _vyToken;
VETHYieldRateTreasury private _vethYRT;
VETHRevenueCycleTreasury private _vethRevenueCycleTreasury;
VETHReverseStakingTreasury internal _vethReverseStakingTreasury;
mapping(uint256 => mapping(address => uint256)) private _deposits;
mapping(uint256 => mapping(VoteOptions => uint256)) private _voteCount;
mapping(uint256 => Proposal) private _proposals;
uint256 public votingPeriod; // In seconds
uint256 private _proposalNonce = 0;
event Vote(address account, VoteOptions voteOption, uint256 quantity);
constructor(
address registrarAddress,
uint256 votingPeriod_,
address[] memory adminGovAgents
) AdminGovernanceAgent(adminGovAgents) RegistrarClient(registrarAddress) {
}
modifier hasMigrationAddresses() {
}
modifier hasProposal() {
}
modifier hasProposalById(uint256 proposalId) {
}
function getCurrentProposal() external view returns (Proposal memory) {
}
function getProposalById(uint256 proposalId) external view returns (Proposal memory) {
}
function getCurrentProposalId() external view returns (uint256) {
}
function getCurrentYesVotes() external view returns (uint256) {
}
function getCurrentNoVotes() external view returns (uint256) {
}
function getYesVotesById(uint256 proposalId) external view returns (uint256) {
}
function getNoVotesById(uint256 proposalId) external view returns (uint256) {
}
function getCurrentDepositedVY(address voter) external view returns (uint256) {
}
function getDepositedVYById(uint256 proposalId, address voter) external view returns (uint256) {
}
function hasCurrentProposalEnded() public view hasProposal returns (bool) {
}
function hasProposalEndedById(uint256 proposalId) external view hasProposalById(proposalId) returns (bool) {
}
function voteYes(uint256 quantity) external {
}
function voteNo(uint256 quantity) external {
}
function _vote(VoteOptions voteOption, uint256 quantity) private hasProposal {
require(block.timestamp < _proposals[_proposalNonce].endsAt, "Proposal already ended");
require(<FILL_ME>)
require(_vyToken.allowance(_msgSender(), address(this)) >= quantity, "Insufficient VY allowance");
require(_vyToken.balanceOf(_msgSender()) >= quantity, "Insufficient VY balance");
_deposits[_proposalNonce][_msgSender()] += quantity;
_voteCount[_proposalNonce][voteOption] += quantity;
_vyToken.transferFrom(_msgSender(), address(this), quantity);
emit Vote(_msgSender(), voteOption, quantity);
}
function startMigrationProposal(
address yieldRateTreasuryDestination,
address revenueCycleTreasuryDestination,
address reverseStakingTreasuryDestination
) external onlyAdminGovAgents {
}
function executeMigrationProposal() external hasMigrationAddresses hasProposal onlyAdminGovAgents {
}
function startRegistrarProposal(address registrar) external onlyAdminGovAgents {
}
function executeRegistrarProposal() external hasProposal onlyAdminGovAgents {
}
function startReverseStakingTermUpdateProposal(
uint256 dailyBurnRate,
uint256 minimumReverseStakeETH,
uint256 processingFeePercentage,
uint256 restakeMinimumPayout
) external onlyAdminGovAgents {
}
function executeReverseStakingTermUpdateProposal() external hasProposal onlyAdminGovAgents {
}
function startYieldRateTreasuryMigration(address yieldRateTreasuryDestination) external onlyAdminGovAgents {
}
function executeYieldRateTreasuryMigration() external hasProposal onlyAdminGovAgents {
}
function startRevenueCycleTreasuryMigration(address revenueCycleTreasuryDestination) external onlyAdminGovAgents {
}
function executeRevenueCycleTreasuryMigration() external hasProposal onlyAdminGovAgents {
}
function startReverseStakingTreasuryMigration(address reverseStakingTreasuryDestination) external onlyAdminGovAgents {
}
function executeReverseStakingTreasuryMigration() external hasProposal onlyAdminGovAgents {
}
function _executeMigrationProposal() private {
}
function _startMigrationProposal(
address yieldRateTreasuryDestination,
address revenueCycleTreasuryDestination,
address reverseStakingTreasuryDestination
) private {
}
// Withdraw from current proposal
function withdrawDepositedVY() external {
}
// Withdraw by proposal id
function withdrawDepositedVYById(uint256 proposalId) external {
}
// Withdraw from all proposals
function withdrawAllDepositedVY() external hasProposal {
}
function _withdraw(uint256 proposalId) private hasProposalById(proposalId) {
}
function updateAddresses() external override onlyRegistrar {
}
function _checkValidMigrationProposal(bool validYRT, bool validRCT, bool validRST) private view {
}
}
| _deposits[_proposalNonce][_msgSender()]==0,"Already voted" | 91,546 | _deposits[_proposalNonce][_msgSender()]==0 |
"Insufficient VY allowance" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.18;
import { AdminGovernanceAgent } from "../access/AdminGovernanceAgent.sol";
import { VETHYieldRateTreasury } from "../treasury/VETHYieldRateTreasury.sol";
import { VYToken } from "../token/VYToken.sol";
import { VETHRevenueCycleTreasury } from "../exchange/VETHRevenueCycleTreasury.sol";
import { VETHReverseStakingTreasury } from "../VETHReverseStakingTreasury.sol";
import { RegistrarClient } from "../RegistrarClient.sol";
contract VETHGovernance is AdminGovernanceAgent, RegistrarClient {
enum VoteOptions {
YES,
NO
}
enum ProposalType {
Migration,
Registrar,
ReverseStakingTermUpdate
}
struct MigrationProposal {
address yieldRateTreasuryDestination;
address revenueCycleTreasuryDestination;
address reverseStakingTreasuryDestination;
}
struct RegistrarProposal {
address registrar; // Registrar to add
}
struct ReverseStakingTermUpdateProposal {
uint256 dailyBurnRate;
uint256 minimumReverseStakeETH;
uint256 processingFeePercentage;
uint256 restakeMinimumPayout;
}
struct Proposal {
ProposalType proposalType;
uint256 endsAt;
bool approved;
MigrationProposal migration;
RegistrarProposal registrar;
ReverseStakingTermUpdateProposal reverseStakingTermUpdate;
}
event StartMigrationProposal(
uint256 proposalId,
address yieldRateTreasuryDestination,
address revenueCycleTreasuryDestination,
address reverseStakingTreasuryDestination,
uint256 endsAt
);
event StartRegistrarProposal(uint256 proposalId, address registrar, uint256 endsAt);
event StartReverseStakingTermUpdateProposal(
uint256 proposalId,
uint256 dailyBurnRate,
uint256 minimumReverseStakeETH,
uint256 processingFeePercentage,
uint256 restakeMinimumPayout,
uint256 endsAt
);
VYToken private _vyToken;
VETHYieldRateTreasury private _vethYRT;
VETHRevenueCycleTreasury private _vethRevenueCycleTreasury;
VETHReverseStakingTreasury internal _vethReverseStakingTreasury;
mapping(uint256 => mapping(address => uint256)) private _deposits;
mapping(uint256 => mapping(VoteOptions => uint256)) private _voteCount;
mapping(uint256 => Proposal) private _proposals;
uint256 public votingPeriod; // In seconds
uint256 private _proposalNonce = 0;
event Vote(address account, VoteOptions voteOption, uint256 quantity);
constructor(
address registrarAddress,
uint256 votingPeriod_,
address[] memory adminGovAgents
) AdminGovernanceAgent(adminGovAgents) RegistrarClient(registrarAddress) {
}
modifier hasMigrationAddresses() {
}
modifier hasProposal() {
}
modifier hasProposalById(uint256 proposalId) {
}
function getCurrentProposal() external view returns (Proposal memory) {
}
function getProposalById(uint256 proposalId) external view returns (Proposal memory) {
}
function getCurrentProposalId() external view returns (uint256) {
}
function getCurrentYesVotes() external view returns (uint256) {
}
function getCurrentNoVotes() external view returns (uint256) {
}
function getYesVotesById(uint256 proposalId) external view returns (uint256) {
}
function getNoVotesById(uint256 proposalId) external view returns (uint256) {
}
function getCurrentDepositedVY(address voter) external view returns (uint256) {
}
function getDepositedVYById(uint256 proposalId, address voter) external view returns (uint256) {
}
function hasCurrentProposalEnded() public view hasProposal returns (bool) {
}
function hasProposalEndedById(uint256 proposalId) external view hasProposalById(proposalId) returns (bool) {
}
function voteYes(uint256 quantity) external {
}
function voteNo(uint256 quantity) external {
}
function _vote(VoteOptions voteOption, uint256 quantity) private hasProposal {
require(block.timestamp < _proposals[_proposalNonce].endsAt, "Proposal already ended");
require(_deposits[_proposalNonce][_msgSender()] == 0, "Already voted");
require(<FILL_ME>)
require(_vyToken.balanceOf(_msgSender()) >= quantity, "Insufficient VY balance");
_deposits[_proposalNonce][_msgSender()] += quantity;
_voteCount[_proposalNonce][voteOption] += quantity;
_vyToken.transferFrom(_msgSender(), address(this), quantity);
emit Vote(_msgSender(), voteOption, quantity);
}
function startMigrationProposal(
address yieldRateTreasuryDestination,
address revenueCycleTreasuryDestination,
address reverseStakingTreasuryDestination
) external onlyAdminGovAgents {
}
function executeMigrationProposal() external hasMigrationAddresses hasProposal onlyAdminGovAgents {
}
function startRegistrarProposal(address registrar) external onlyAdminGovAgents {
}
function executeRegistrarProposal() external hasProposal onlyAdminGovAgents {
}
function startReverseStakingTermUpdateProposal(
uint256 dailyBurnRate,
uint256 minimumReverseStakeETH,
uint256 processingFeePercentage,
uint256 restakeMinimumPayout
) external onlyAdminGovAgents {
}
function executeReverseStakingTermUpdateProposal() external hasProposal onlyAdminGovAgents {
}
function startYieldRateTreasuryMigration(address yieldRateTreasuryDestination) external onlyAdminGovAgents {
}
function executeYieldRateTreasuryMigration() external hasProposal onlyAdminGovAgents {
}
function startRevenueCycleTreasuryMigration(address revenueCycleTreasuryDestination) external onlyAdminGovAgents {
}
function executeRevenueCycleTreasuryMigration() external hasProposal onlyAdminGovAgents {
}
function startReverseStakingTreasuryMigration(address reverseStakingTreasuryDestination) external onlyAdminGovAgents {
}
function executeReverseStakingTreasuryMigration() external hasProposal onlyAdminGovAgents {
}
function _executeMigrationProposal() private {
}
function _startMigrationProposal(
address yieldRateTreasuryDestination,
address revenueCycleTreasuryDestination,
address reverseStakingTreasuryDestination
) private {
}
// Withdraw from current proposal
function withdrawDepositedVY() external {
}
// Withdraw by proposal id
function withdrawDepositedVYById(uint256 proposalId) external {
}
// Withdraw from all proposals
function withdrawAllDepositedVY() external hasProposal {
}
function _withdraw(uint256 proposalId) private hasProposalById(proposalId) {
}
function updateAddresses() external override onlyRegistrar {
}
function _checkValidMigrationProposal(bool validYRT, bool validRCT, bool validRST) private view {
}
}
| _vyToken.allowance(_msgSender(),address(this))>=quantity,"Insufficient VY allowance" | 91,546 | _vyToken.allowance(_msgSender(),address(this))>=quantity |
"Insufficient VY balance" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.18;
import { AdminGovernanceAgent } from "../access/AdminGovernanceAgent.sol";
import { VETHYieldRateTreasury } from "../treasury/VETHYieldRateTreasury.sol";
import { VYToken } from "../token/VYToken.sol";
import { VETHRevenueCycleTreasury } from "../exchange/VETHRevenueCycleTreasury.sol";
import { VETHReverseStakingTreasury } from "../VETHReverseStakingTreasury.sol";
import { RegistrarClient } from "../RegistrarClient.sol";
contract VETHGovernance is AdminGovernanceAgent, RegistrarClient {
enum VoteOptions {
YES,
NO
}
enum ProposalType {
Migration,
Registrar,
ReverseStakingTermUpdate
}
struct MigrationProposal {
address yieldRateTreasuryDestination;
address revenueCycleTreasuryDestination;
address reverseStakingTreasuryDestination;
}
struct RegistrarProposal {
address registrar; // Registrar to add
}
struct ReverseStakingTermUpdateProposal {
uint256 dailyBurnRate;
uint256 minimumReverseStakeETH;
uint256 processingFeePercentage;
uint256 restakeMinimumPayout;
}
struct Proposal {
ProposalType proposalType;
uint256 endsAt;
bool approved;
MigrationProposal migration;
RegistrarProposal registrar;
ReverseStakingTermUpdateProposal reverseStakingTermUpdate;
}
event StartMigrationProposal(
uint256 proposalId,
address yieldRateTreasuryDestination,
address revenueCycleTreasuryDestination,
address reverseStakingTreasuryDestination,
uint256 endsAt
);
event StartRegistrarProposal(uint256 proposalId, address registrar, uint256 endsAt);
event StartReverseStakingTermUpdateProposal(
uint256 proposalId,
uint256 dailyBurnRate,
uint256 minimumReverseStakeETH,
uint256 processingFeePercentage,
uint256 restakeMinimumPayout,
uint256 endsAt
);
VYToken private _vyToken;
VETHYieldRateTreasury private _vethYRT;
VETHRevenueCycleTreasury private _vethRevenueCycleTreasury;
VETHReverseStakingTreasury internal _vethReverseStakingTreasury;
mapping(uint256 => mapping(address => uint256)) private _deposits;
mapping(uint256 => mapping(VoteOptions => uint256)) private _voteCount;
mapping(uint256 => Proposal) private _proposals;
uint256 public votingPeriod; // In seconds
uint256 private _proposalNonce = 0;
event Vote(address account, VoteOptions voteOption, uint256 quantity);
constructor(
address registrarAddress,
uint256 votingPeriod_,
address[] memory adminGovAgents
) AdminGovernanceAgent(adminGovAgents) RegistrarClient(registrarAddress) {
}
modifier hasMigrationAddresses() {
}
modifier hasProposal() {
}
modifier hasProposalById(uint256 proposalId) {
}
function getCurrentProposal() external view returns (Proposal memory) {
}
function getProposalById(uint256 proposalId) external view returns (Proposal memory) {
}
function getCurrentProposalId() external view returns (uint256) {
}
function getCurrentYesVotes() external view returns (uint256) {
}
function getCurrentNoVotes() external view returns (uint256) {
}
function getYesVotesById(uint256 proposalId) external view returns (uint256) {
}
function getNoVotesById(uint256 proposalId) external view returns (uint256) {
}
function getCurrentDepositedVY(address voter) external view returns (uint256) {
}
function getDepositedVYById(uint256 proposalId, address voter) external view returns (uint256) {
}
function hasCurrentProposalEnded() public view hasProposal returns (bool) {
}
function hasProposalEndedById(uint256 proposalId) external view hasProposalById(proposalId) returns (bool) {
}
function voteYes(uint256 quantity) external {
}
function voteNo(uint256 quantity) external {
}
function _vote(VoteOptions voteOption, uint256 quantity) private hasProposal {
require(block.timestamp < _proposals[_proposalNonce].endsAt, "Proposal already ended");
require(_deposits[_proposalNonce][_msgSender()] == 0, "Already voted");
require(_vyToken.allowance(_msgSender(), address(this)) >= quantity, "Insufficient VY allowance");
require(<FILL_ME>)
_deposits[_proposalNonce][_msgSender()] += quantity;
_voteCount[_proposalNonce][voteOption] += quantity;
_vyToken.transferFrom(_msgSender(), address(this), quantity);
emit Vote(_msgSender(), voteOption, quantity);
}
function startMigrationProposal(
address yieldRateTreasuryDestination,
address revenueCycleTreasuryDestination,
address reverseStakingTreasuryDestination
) external onlyAdminGovAgents {
}
function executeMigrationProposal() external hasMigrationAddresses hasProposal onlyAdminGovAgents {
}
function startRegistrarProposal(address registrar) external onlyAdminGovAgents {
}
function executeRegistrarProposal() external hasProposal onlyAdminGovAgents {
}
function startReverseStakingTermUpdateProposal(
uint256 dailyBurnRate,
uint256 minimumReverseStakeETH,
uint256 processingFeePercentage,
uint256 restakeMinimumPayout
) external onlyAdminGovAgents {
}
function executeReverseStakingTermUpdateProposal() external hasProposal onlyAdminGovAgents {
}
function startYieldRateTreasuryMigration(address yieldRateTreasuryDestination) external onlyAdminGovAgents {
}
function executeYieldRateTreasuryMigration() external hasProposal onlyAdminGovAgents {
}
function startRevenueCycleTreasuryMigration(address revenueCycleTreasuryDestination) external onlyAdminGovAgents {
}
function executeRevenueCycleTreasuryMigration() external hasProposal onlyAdminGovAgents {
}
function startReverseStakingTreasuryMigration(address reverseStakingTreasuryDestination) external onlyAdminGovAgents {
}
function executeReverseStakingTreasuryMigration() external hasProposal onlyAdminGovAgents {
}
function _executeMigrationProposal() private {
}
function _startMigrationProposal(
address yieldRateTreasuryDestination,
address revenueCycleTreasuryDestination,
address reverseStakingTreasuryDestination
) private {
}
// Withdraw from current proposal
function withdrawDepositedVY() external {
}
// Withdraw by proposal id
function withdrawDepositedVYById(uint256 proposalId) external {
}
// Withdraw from all proposals
function withdrawAllDepositedVY() external hasProposal {
}
function _withdraw(uint256 proposalId) private hasProposalById(proposalId) {
}
function updateAddresses() external override onlyRegistrar {
}
function _checkValidMigrationProposal(bool validYRT, bool validRCT, bool validRST) private view {
}
}
| _vyToken.balanceOf(_msgSender())>=quantity,"Insufficient VY balance" | 91,546 | _vyToken.balanceOf(_msgSender())>=quantity |
"VYToken address not set" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.18;
import { AdminGovernanceAgent } from "../access/AdminGovernanceAgent.sol";
import { VETHYieldRateTreasury } from "../treasury/VETHYieldRateTreasury.sol";
import { VYToken } from "../token/VYToken.sol";
import { VETHRevenueCycleTreasury } from "../exchange/VETHRevenueCycleTreasury.sol";
import { VETHReverseStakingTreasury } from "../VETHReverseStakingTreasury.sol";
import { RegistrarClient } from "../RegistrarClient.sol";
contract VETHGovernance is AdminGovernanceAgent, RegistrarClient {
enum VoteOptions {
YES,
NO
}
enum ProposalType {
Migration,
Registrar,
ReverseStakingTermUpdate
}
struct MigrationProposal {
address yieldRateTreasuryDestination;
address revenueCycleTreasuryDestination;
address reverseStakingTreasuryDestination;
}
struct RegistrarProposal {
address registrar; // Registrar to add
}
struct ReverseStakingTermUpdateProposal {
uint256 dailyBurnRate;
uint256 minimumReverseStakeETH;
uint256 processingFeePercentage;
uint256 restakeMinimumPayout;
}
struct Proposal {
ProposalType proposalType;
uint256 endsAt;
bool approved;
MigrationProposal migration;
RegistrarProposal registrar;
ReverseStakingTermUpdateProposal reverseStakingTermUpdate;
}
event StartMigrationProposal(
uint256 proposalId,
address yieldRateTreasuryDestination,
address revenueCycleTreasuryDestination,
address reverseStakingTreasuryDestination,
uint256 endsAt
);
event StartRegistrarProposal(uint256 proposalId, address registrar, uint256 endsAt);
event StartReverseStakingTermUpdateProposal(
uint256 proposalId,
uint256 dailyBurnRate,
uint256 minimumReverseStakeETH,
uint256 processingFeePercentage,
uint256 restakeMinimumPayout,
uint256 endsAt
);
VYToken private _vyToken;
VETHYieldRateTreasury private _vethYRT;
VETHRevenueCycleTreasury private _vethRevenueCycleTreasury;
VETHReverseStakingTreasury internal _vethReverseStakingTreasury;
mapping(uint256 => mapping(address => uint256)) private _deposits;
mapping(uint256 => mapping(VoteOptions => uint256)) private _voteCount;
mapping(uint256 => Proposal) private _proposals;
uint256 public votingPeriod; // In seconds
uint256 private _proposalNonce = 0;
event Vote(address account, VoteOptions voteOption, uint256 quantity);
constructor(
address registrarAddress,
uint256 votingPeriod_,
address[] memory adminGovAgents
) AdminGovernanceAgent(adminGovAgents) RegistrarClient(registrarAddress) {
}
modifier hasMigrationAddresses() {
}
modifier hasProposal() {
}
modifier hasProposalById(uint256 proposalId) {
}
function getCurrentProposal() external view returns (Proposal memory) {
}
function getProposalById(uint256 proposalId) external view returns (Proposal memory) {
}
function getCurrentProposalId() external view returns (uint256) {
}
function getCurrentYesVotes() external view returns (uint256) {
}
function getCurrentNoVotes() external view returns (uint256) {
}
function getYesVotesById(uint256 proposalId) external view returns (uint256) {
}
function getNoVotesById(uint256 proposalId) external view returns (uint256) {
}
function getCurrentDepositedVY(address voter) external view returns (uint256) {
}
function getDepositedVYById(uint256 proposalId, address voter) external view returns (uint256) {
}
function hasCurrentProposalEnded() public view hasProposal returns (bool) {
}
function hasProposalEndedById(uint256 proposalId) external view hasProposalById(proposalId) returns (bool) {
}
function voteYes(uint256 quantity) external {
}
function voteNo(uint256 quantity) external {
}
function _vote(VoteOptions voteOption, uint256 quantity) private hasProposal {
}
function startMigrationProposal(
address yieldRateTreasuryDestination,
address revenueCycleTreasuryDestination,
address reverseStakingTreasuryDestination
) external onlyAdminGovAgents {
}
function executeMigrationProposal() external hasMigrationAddresses hasProposal onlyAdminGovAgents {
}
function startRegistrarProposal(address registrar) external onlyAdminGovAgents {
}
function executeRegistrarProposal() external hasProposal onlyAdminGovAgents {
require(<FILL_ME>)
require(hasCurrentProposalEnded(), "Proposal still ongoing");
require(_proposals[_proposalNonce].proposalType == ProposalType.Registrar, "Invalid proposal");
require(_voteCount[_proposalNonce][VoteOptions.YES] >= _voteCount[_proposalNonce][VoteOptions.NO], "Proposal not passed");
_proposals[_proposalNonce].approved = true;
// Register new Registrar with VYToken
_vyToken.setRegistrar(_registrar.getEcosystemId(), _proposalNonce);
}
function startReverseStakingTermUpdateProposal(
uint256 dailyBurnRate,
uint256 minimumReverseStakeETH,
uint256 processingFeePercentage,
uint256 restakeMinimumPayout
) external onlyAdminGovAgents {
}
function executeReverseStakingTermUpdateProposal() external hasProposal onlyAdminGovAgents {
}
function startYieldRateTreasuryMigration(address yieldRateTreasuryDestination) external onlyAdminGovAgents {
}
function executeYieldRateTreasuryMigration() external hasProposal onlyAdminGovAgents {
}
function startRevenueCycleTreasuryMigration(address revenueCycleTreasuryDestination) external onlyAdminGovAgents {
}
function executeRevenueCycleTreasuryMigration() external hasProposal onlyAdminGovAgents {
}
function startReverseStakingTreasuryMigration(address reverseStakingTreasuryDestination) external onlyAdminGovAgents {
}
function executeReverseStakingTreasuryMigration() external hasProposal onlyAdminGovAgents {
}
function _executeMigrationProposal() private {
}
function _startMigrationProposal(
address yieldRateTreasuryDestination,
address revenueCycleTreasuryDestination,
address reverseStakingTreasuryDestination
) private {
}
// Withdraw from current proposal
function withdrawDepositedVY() external {
}
// Withdraw by proposal id
function withdrawDepositedVYById(uint256 proposalId) external {
}
// Withdraw from all proposals
function withdrawAllDepositedVY() external hasProposal {
}
function _withdraw(uint256 proposalId) private hasProposalById(proposalId) {
}
function updateAddresses() external override onlyRegistrar {
}
function _checkValidMigrationProposal(bool validYRT, bool validRCT, bool validRST) private view {
}
}
| address(_vyToken)!=address(0),"VYToken address not set" | 91,546 | address(_vyToken)!=address(0) |
"Proposal still ongoing" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.18;
import { AdminGovernanceAgent } from "../access/AdminGovernanceAgent.sol";
import { VETHYieldRateTreasury } from "../treasury/VETHYieldRateTreasury.sol";
import { VYToken } from "../token/VYToken.sol";
import { VETHRevenueCycleTreasury } from "../exchange/VETHRevenueCycleTreasury.sol";
import { VETHReverseStakingTreasury } from "../VETHReverseStakingTreasury.sol";
import { RegistrarClient } from "../RegistrarClient.sol";
contract VETHGovernance is AdminGovernanceAgent, RegistrarClient {
enum VoteOptions {
YES,
NO
}
enum ProposalType {
Migration,
Registrar,
ReverseStakingTermUpdate
}
struct MigrationProposal {
address yieldRateTreasuryDestination;
address revenueCycleTreasuryDestination;
address reverseStakingTreasuryDestination;
}
struct RegistrarProposal {
address registrar; // Registrar to add
}
struct ReverseStakingTermUpdateProposal {
uint256 dailyBurnRate;
uint256 minimumReverseStakeETH;
uint256 processingFeePercentage;
uint256 restakeMinimumPayout;
}
struct Proposal {
ProposalType proposalType;
uint256 endsAt;
bool approved;
MigrationProposal migration;
RegistrarProposal registrar;
ReverseStakingTermUpdateProposal reverseStakingTermUpdate;
}
event StartMigrationProposal(
uint256 proposalId,
address yieldRateTreasuryDestination,
address revenueCycleTreasuryDestination,
address reverseStakingTreasuryDestination,
uint256 endsAt
);
event StartRegistrarProposal(uint256 proposalId, address registrar, uint256 endsAt);
event StartReverseStakingTermUpdateProposal(
uint256 proposalId,
uint256 dailyBurnRate,
uint256 minimumReverseStakeETH,
uint256 processingFeePercentage,
uint256 restakeMinimumPayout,
uint256 endsAt
);
VYToken private _vyToken;
VETHYieldRateTreasury private _vethYRT;
VETHRevenueCycleTreasury private _vethRevenueCycleTreasury;
VETHReverseStakingTreasury internal _vethReverseStakingTreasury;
mapping(uint256 => mapping(address => uint256)) private _deposits;
mapping(uint256 => mapping(VoteOptions => uint256)) private _voteCount;
mapping(uint256 => Proposal) private _proposals;
uint256 public votingPeriod; // In seconds
uint256 private _proposalNonce = 0;
event Vote(address account, VoteOptions voteOption, uint256 quantity);
constructor(
address registrarAddress,
uint256 votingPeriod_,
address[] memory adminGovAgents
) AdminGovernanceAgent(adminGovAgents) RegistrarClient(registrarAddress) {
}
modifier hasMigrationAddresses() {
}
modifier hasProposal() {
}
modifier hasProposalById(uint256 proposalId) {
}
function getCurrentProposal() external view returns (Proposal memory) {
}
function getProposalById(uint256 proposalId) external view returns (Proposal memory) {
}
function getCurrentProposalId() external view returns (uint256) {
}
function getCurrentYesVotes() external view returns (uint256) {
}
function getCurrentNoVotes() external view returns (uint256) {
}
function getYesVotesById(uint256 proposalId) external view returns (uint256) {
}
function getNoVotesById(uint256 proposalId) external view returns (uint256) {
}
function getCurrentDepositedVY(address voter) external view returns (uint256) {
}
function getDepositedVYById(uint256 proposalId, address voter) external view returns (uint256) {
}
function hasCurrentProposalEnded() public view hasProposal returns (bool) {
}
function hasProposalEndedById(uint256 proposalId) external view hasProposalById(proposalId) returns (bool) {
}
function voteYes(uint256 quantity) external {
}
function voteNo(uint256 quantity) external {
}
function _vote(VoteOptions voteOption, uint256 quantity) private hasProposal {
}
function startMigrationProposal(
address yieldRateTreasuryDestination,
address revenueCycleTreasuryDestination,
address reverseStakingTreasuryDestination
) external onlyAdminGovAgents {
}
function executeMigrationProposal() external hasMigrationAddresses hasProposal onlyAdminGovAgents {
}
function startRegistrarProposal(address registrar) external onlyAdminGovAgents {
}
function executeRegistrarProposal() external hasProposal onlyAdminGovAgents {
require(address(_vyToken) != address(0), "VYToken address not set");
require(<FILL_ME>)
require(_proposals[_proposalNonce].proposalType == ProposalType.Registrar, "Invalid proposal");
require(_voteCount[_proposalNonce][VoteOptions.YES] >= _voteCount[_proposalNonce][VoteOptions.NO], "Proposal not passed");
_proposals[_proposalNonce].approved = true;
// Register new Registrar with VYToken
_vyToken.setRegistrar(_registrar.getEcosystemId(), _proposalNonce);
}
function startReverseStakingTermUpdateProposal(
uint256 dailyBurnRate,
uint256 minimumReverseStakeETH,
uint256 processingFeePercentage,
uint256 restakeMinimumPayout
) external onlyAdminGovAgents {
}
function executeReverseStakingTermUpdateProposal() external hasProposal onlyAdminGovAgents {
}
function startYieldRateTreasuryMigration(address yieldRateTreasuryDestination) external onlyAdminGovAgents {
}
function executeYieldRateTreasuryMigration() external hasProposal onlyAdminGovAgents {
}
function startRevenueCycleTreasuryMigration(address revenueCycleTreasuryDestination) external onlyAdminGovAgents {
}
function executeRevenueCycleTreasuryMigration() external hasProposal onlyAdminGovAgents {
}
function startReverseStakingTreasuryMigration(address reverseStakingTreasuryDestination) external onlyAdminGovAgents {
}
function executeReverseStakingTreasuryMigration() external hasProposal onlyAdminGovAgents {
}
function _executeMigrationProposal() private {
}
function _startMigrationProposal(
address yieldRateTreasuryDestination,
address revenueCycleTreasuryDestination,
address reverseStakingTreasuryDestination
) private {
}
// Withdraw from current proposal
function withdrawDepositedVY() external {
}
// Withdraw by proposal id
function withdrawDepositedVYById(uint256 proposalId) external {
}
// Withdraw from all proposals
function withdrawAllDepositedVY() external hasProposal {
}
function _withdraw(uint256 proposalId) private hasProposalById(proposalId) {
}
function updateAddresses() external override onlyRegistrar {
}
function _checkValidMigrationProposal(bool validYRT, bool validRCT, bool validRST) private view {
}
}
| hasCurrentProposalEnded(),"Proposal still ongoing" | 91,546 | hasCurrentProposalEnded() |
"Invalid proposal" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.18;
import { AdminGovernanceAgent } from "../access/AdminGovernanceAgent.sol";
import { VETHYieldRateTreasury } from "../treasury/VETHYieldRateTreasury.sol";
import { VYToken } from "../token/VYToken.sol";
import { VETHRevenueCycleTreasury } from "../exchange/VETHRevenueCycleTreasury.sol";
import { VETHReverseStakingTreasury } from "../VETHReverseStakingTreasury.sol";
import { RegistrarClient } from "../RegistrarClient.sol";
contract VETHGovernance is AdminGovernanceAgent, RegistrarClient {
enum VoteOptions {
YES,
NO
}
enum ProposalType {
Migration,
Registrar,
ReverseStakingTermUpdate
}
struct MigrationProposal {
address yieldRateTreasuryDestination;
address revenueCycleTreasuryDestination;
address reverseStakingTreasuryDestination;
}
struct RegistrarProposal {
address registrar; // Registrar to add
}
struct ReverseStakingTermUpdateProposal {
uint256 dailyBurnRate;
uint256 minimumReverseStakeETH;
uint256 processingFeePercentage;
uint256 restakeMinimumPayout;
}
struct Proposal {
ProposalType proposalType;
uint256 endsAt;
bool approved;
MigrationProposal migration;
RegistrarProposal registrar;
ReverseStakingTermUpdateProposal reverseStakingTermUpdate;
}
event StartMigrationProposal(
uint256 proposalId,
address yieldRateTreasuryDestination,
address revenueCycleTreasuryDestination,
address reverseStakingTreasuryDestination,
uint256 endsAt
);
event StartRegistrarProposal(uint256 proposalId, address registrar, uint256 endsAt);
event StartReverseStakingTermUpdateProposal(
uint256 proposalId,
uint256 dailyBurnRate,
uint256 minimumReverseStakeETH,
uint256 processingFeePercentage,
uint256 restakeMinimumPayout,
uint256 endsAt
);
VYToken private _vyToken;
VETHYieldRateTreasury private _vethYRT;
VETHRevenueCycleTreasury private _vethRevenueCycleTreasury;
VETHReverseStakingTreasury internal _vethReverseStakingTreasury;
mapping(uint256 => mapping(address => uint256)) private _deposits;
mapping(uint256 => mapping(VoteOptions => uint256)) private _voteCount;
mapping(uint256 => Proposal) private _proposals;
uint256 public votingPeriod; // In seconds
uint256 private _proposalNonce = 0;
event Vote(address account, VoteOptions voteOption, uint256 quantity);
constructor(
address registrarAddress,
uint256 votingPeriod_,
address[] memory adminGovAgents
) AdminGovernanceAgent(adminGovAgents) RegistrarClient(registrarAddress) {
}
modifier hasMigrationAddresses() {
}
modifier hasProposal() {
}
modifier hasProposalById(uint256 proposalId) {
}
function getCurrentProposal() external view returns (Proposal memory) {
}
function getProposalById(uint256 proposalId) external view returns (Proposal memory) {
}
function getCurrentProposalId() external view returns (uint256) {
}
function getCurrentYesVotes() external view returns (uint256) {
}
function getCurrentNoVotes() external view returns (uint256) {
}
function getYesVotesById(uint256 proposalId) external view returns (uint256) {
}
function getNoVotesById(uint256 proposalId) external view returns (uint256) {
}
function getCurrentDepositedVY(address voter) external view returns (uint256) {
}
function getDepositedVYById(uint256 proposalId, address voter) external view returns (uint256) {
}
function hasCurrentProposalEnded() public view hasProposal returns (bool) {
}
function hasProposalEndedById(uint256 proposalId) external view hasProposalById(proposalId) returns (bool) {
}
function voteYes(uint256 quantity) external {
}
function voteNo(uint256 quantity) external {
}
function _vote(VoteOptions voteOption, uint256 quantity) private hasProposal {
}
function startMigrationProposal(
address yieldRateTreasuryDestination,
address revenueCycleTreasuryDestination,
address reverseStakingTreasuryDestination
) external onlyAdminGovAgents {
}
function executeMigrationProposal() external hasMigrationAddresses hasProposal onlyAdminGovAgents {
}
function startRegistrarProposal(address registrar) external onlyAdminGovAgents {
}
function executeRegistrarProposal() external hasProposal onlyAdminGovAgents {
require(address(_vyToken) != address(0), "VYToken address not set");
require(hasCurrentProposalEnded(), "Proposal still ongoing");
require(<FILL_ME>)
require(_voteCount[_proposalNonce][VoteOptions.YES] >= _voteCount[_proposalNonce][VoteOptions.NO], "Proposal not passed");
_proposals[_proposalNonce].approved = true;
// Register new Registrar with VYToken
_vyToken.setRegistrar(_registrar.getEcosystemId(), _proposalNonce);
}
function startReverseStakingTermUpdateProposal(
uint256 dailyBurnRate,
uint256 minimumReverseStakeETH,
uint256 processingFeePercentage,
uint256 restakeMinimumPayout
) external onlyAdminGovAgents {
}
function executeReverseStakingTermUpdateProposal() external hasProposal onlyAdminGovAgents {
}
function startYieldRateTreasuryMigration(address yieldRateTreasuryDestination) external onlyAdminGovAgents {
}
function executeYieldRateTreasuryMigration() external hasProposal onlyAdminGovAgents {
}
function startRevenueCycleTreasuryMigration(address revenueCycleTreasuryDestination) external onlyAdminGovAgents {
}
function executeRevenueCycleTreasuryMigration() external hasProposal onlyAdminGovAgents {
}
function startReverseStakingTreasuryMigration(address reverseStakingTreasuryDestination) external onlyAdminGovAgents {
}
function executeReverseStakingTreasuryMigration() external hasProposal onlyAdminGovAgents {
}
function _executeMigrationProposal() private {
}
function _startMigrationProposal(
address yieldRateTreasuryDestination,
address revenueCycleTreasuryDestination,
address reverseStakingTreasuryDestination
) private {
}
// Withdraw from current proposal
function withdrawDepositedVY() external {
}
// Withdraw by proposal id
function withdrawDepositedVYById(uint256 proposalId) external {
}
// Withdraw from all proposals
function withdrawAllDepositedVY() external hasProposal {
}
function _withdraw(uint256 proposalId) private hasProposalById(proposalId) {
}
function updateAddresses() external override onlyRegistrar {
}
function _checkValidMigrationProposal(bool validYRT, bool validRCT, bool validRST) private view {
}
}
| _proposals[_proposalNonce].proposalType==ProposalType.Registrar,"Invalid proposal" | 91,546 | _proposals[_proposalNonce].proposalType==ProposalType.Registrar |
"Proposal not passed" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.18;
import { AdminGovernanceAgent } from "../access/AdminGovernanceAgent.sol";
import { VETHYieldRateTreasury } from "../treasury/VETHYieldRateTreasury.sol";
import { VYToken } from "../token/VYToken.sol";
import { VETHRevenueCycleTreasury } from "../exchange/VETHRevenueCycleTreasury.sol";
import { VETHReverseStakingTreasury } from "../VETHReverseStakingTreasury.sol";
import { RegistrarClient } from "../RegistrarClient.sol";
contract VETHGovernance is AdminGovernanceAgent, RegistrarClient {
enum VoteOptions {
YES,
NO
}
enum ProposalType {
Migration,
Registrar,
ReverseStakingTermUpdate
}
struct MigrationProposal {
address yieldRateTreasuryDestination;
address revenueCycleTreasuryDestination;
address reverseStakingTreasuryDestination;
}
struct RegistrarProposal {
address registrar; // Registrar to add
}
struct ReverseStakingTermUpdateProposal {
uint256 dailyBurnRate;
uint256 minimumReverseStakeETH;
uint256 processingFeePercentage;
uint256 restakeMinimumPayout;
}
struct Proposal {
ProposalType proposalType;
uint256 endsAt;
bool approved;
MigrationProposal migration;
RegistrarProposal registrar;
ReverseStakingTermUpdateProposal reverseStakingTermUpdate;
}
event StartMigrationProposal(
uint256 proposalId,
address yieldRateTreasuryDestination,
address revenueCycleTreasuryDestination,
address reverseStakingTreasuryDestination,
uint256 endsAt
);
event StartRegistrarProposal(uint256 proposalId, address registrar, uint256 endsAt);
event StartReverseStakingTermUpdateProposal(
uint256 proposalId,
uint256 dailyBurnRate,
uint256 minimumReverseStakeETH,
uint256 processingFeePercentage,
uint256 restakeMinimumPayout,
uint256 endsAt
);
VYToken private _vyToken;
VETHYieldRateTreasury private _vethYRT;
VETHRevenueCycleTreasury private _vethRevenueCycleTreasury;
VETHReverseStakingTreasury internal _vethReverseStakingTreasury;
mapping(uint256 => mapping(address => uint256)) private _deposits;
mapping(uint256 => mapping(VoteOptions => uint256)) private _voteCount;
mapping(uint256 => Proposal) private _proposals;
uint256 public votingPeriod; // In seconds
uint256 private _proposalNonce = 0;
event Vote(address account, VoteOptions voteOption, uint256 quantity);
constructor(
address registrarAddress,
uint256 votingPeriod_,
address[] memory adminGovAgents
) AdminGovernanceAgent(adminGovAgents) RegistrarClient(registrarAddress) {
}
modifier hasMigrationAddresses() {
}
modifier hasProposal() {
}
modifier hasProposalById(uint256 proposalId) {
}
function getCurrentProposal() external view returns (Proposal memory) {
}
function getProposalById(uint256 proposalId) external view returns (Proposal memory) {
}
function getCurrentProposalId() external view returns (uint256) {
}
function getCurrentYesVotes() external view returns (uint256) {
}
function getCurrentNoVotes() external view returns (uint256) {
}
function getYesVotesById(uint256 proposalId) external view returns (uint256) {
}
function getNoVotesById(uint256 proposalId) external view returns (uint256) {
}
function getCurrentDepositedVY(address voter) external view returns (uint256) {
}
function getDepositedVYById(uint256 proposalId, address voter) external view returns (uint256) {
}
function hasCurrentProposalEnded() public view hasProposal returns (bool) {
}
function hasProposalEndedById(uint256 proposalId) external view hasProposalById(proposalId) returns (bool) {
}
function voteYes(uint256 quantity) external {
}
function voteNo(uint256 quantity) external {
}
function _vote(VoteOptions voteOption, uint256 quantity) private hasProposal {
}
function startMigrationProposal(
address yieldRateTreasuryDestination,
address revenueCycleTreasuryDestination,
address reverseStakingTreasuryDestination
) external onlyAdminGovAgents {
}
function executeMigrationProposal() external hasMigrationAddresses hasProposal onlyAdminGovAgents {
}
function startRegistrarProposal(address registrar) external onlyAdminGovAgents {
}
function executeRegistrarProposal() external hasProposal onlyAdminGovAgents {
require(address(_vyToken) != address(0), "VYToken address not set");
require(hasCurrentProposalEnded(), "Proposal still ongoing");
require(_proposals[_proposalNonce].proposalType == ProposalType.Registrar, "Invalid proposal");
require(<FILL_ME>)
_proposals[_proposalNonce].approved = true;
// Register new Registrar with VYToken
_vyToken.setRegistrar(_registrar.getEcosystemId(), _proposalNonce);
}
function startReverseStakingTermUpdateProposal(
uint256 dailyBurnRate,
uint256 minimumReverseStakeETH,
uint256 processingFeePercentage,
uint256 restakeMinimumPayout
) external onlyAdminGovAgents {
}
function executeReverseStakingTermUpdateProposal() external hasProposal onlyAdminGovAgents {
}
function startYieldRateTreasuryMigration(address yieldRateTreasuryDestination) external onlyAdminGovAgents {
}
function executeYieldRateTreasuryMigration() external hasProposal onlyAdminGovAgents {
}
function startRevenueCycleTreasuryMigration(address revenueCycleTreasuryDestination) external onlyAdminGovAgents {
}
function executeRevenueCycleTreasuryMigration() external hasProposal onlyAdminGovAgents {
}
function startReverseStakingTreasuryMigration(address reverseStakingTreasuryDestination) external onlyAdminGovAgents {
}
function executeReverseStakingTreasuryMigration() external hasProposal onlyAdminGovAgents {
}
function _executeMigrationProposal() private {
}
function _startMigrationProposal(
address yieldRateTreasuryDestination,
address revenueCycleTreasuryDestination,
address reverseStakingTreasuryDestination
) private {
}
// Withdraw from current proposal
function withdrawDepositedVY() external {
}
// Withdraw by proposal id
function withdrawDepositedVYById(uint256 proposalId) external {
}
// Withdraw from all proposals
function withdrawAllDepositedVY() external hasProposal {
}
function _withdraw(uint256 proposalId) private hasProposalById(proposalId) {
}
function updateAddresses() external override onlyRegistrar {
}
function _checkValidMigrationProposal(bool validYRT, bool validRCT, bool validRST) private view {
}
}
| _voteCount[_proposalNonce][VoteOptions.YES]>=_voteCount[_proposalNonce][VoteOptions.NO],"Proposal not passed" | 91,546 | _voteCount[_proposalNonce][VoteOptions.YES]>=_voteCount[_proposalNonce][VoteOptions.NO] |
"Invalid proposal" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.18;
import { AdminGovernanceAgent } from "../access/AdminGovernanceAgent.sol";
import { VETHYieldRateTreasury } from "../treasury/VETHYieldRateTreasury.sol";
import { VYToken } from "../token/VYToken.sol";
import { VETHRevenueCycleTreasury } from "../exchange/VETHRevenueCycleTreasury.sol";
import { VETHReverseStakingTreasury } from "../VETHReverseStakingTreasury.sol";
import { RegistrarClient } from "../RegistrarClient.sol";
contract VETHGovernance is AdminGovernanceAgent, RegistrarClient {
enum VoteOptions {
YES,
NO
}
enum ProposalType {
Migration,
Registrar,
ReverseStakingTermUpdate
}
struct MigrationProposal {
address yieldRateTreasuryDestination;
address revenueCycleTreasuryDestination;
address reverseStakingTreasuryDestination;
}
struct RegistrarProposal {
address registrar; // Registrar to add
}
struct ReverseStakingTermUpdateProposal {
uint256 dailyBurnRate;
uint256 minimumReverseStakeETH;
uint256 processingFeePercentage;
uint256 restakeMinimumPayout;
}
struct Proposal {
ProposalType proposalType;
uint256 endsAt;
bool approved;
MigrationProposal migration;
RegistrarProposal registrar;
ReverseStakingTermUpdateProposal reverseStakingTermUpdate;
}
event StartMigrationProposal(
uint256 proposalId,
address yieldRateTreasuryDestination,
address revenueCycleTreasuryDestination,
address reverseStakingTreasuryDestination,
uint256 endsAt
);
event StartRegistrarProposal(uint256 proposalId, address registrar, uint256 endsAt);
event StartReverseStakingTermUpdateProposal(
uint256 proposalId,
uint256 dailyBurnRate,
uint256 minimumReverseStakeETH,
uint256 processingFeePercentage,
uint256 restakeMinimumPayout,
uint256 endsAt
);
VYToken private _vyToken;
VETHYieldRateTreasury private _vethYRT;
VETHRevenueCycleTreasury private _vethRevenueCycleTreasury;
VETHReverseStakingTreasury internal _vethReverseStakingTreasury;
mapping(uint256 => mapping(address => uint256)) private _deposits;
mapping(uint256 => mapping(VoteOptions => uint256)) private _voteCount;
mapping(uint256 => Proposal) private _proposals;
uint256 public votingPeriod; // In seconds
uint256 private _proposalNonce = 0;
event Vote(address account, VoteOptions voteOption, uint256 quantity);
constructor(
address registrarAddress,
uint256 votingPeriod_,
address[] memory adminGovAgents
) AdminGovernanceAgent(adminGovAgents) RegistrarClient(registrarAddress) {
}
modifier hasMigrationAddresses() {
}
modifier hasProposal() {
}
modifier hasProposalById(uint256 proposalId) {
}
function getCurrentProposal() external view returns (Proposal memory) {
}
function getProposalById(uint256 proposalId) external view returns (Proposal memory) {
}
function getCurrentProposalId() external view returns (uint256) {
}
function getCurrentYesVotes() external view returns (uint256) {
}
function getCurrentNoVotes() external view returns (uint256) {
}
function getYesVotesById(uint256 proposalId) external view returns (uint256) {
}
function getNoVotesById(uint256 proposalId) external view returns (uint256) {
}
function getCurrentDepositedVY(address voter) external view returns (uint256) {
}
function getDepositedVYById(uint256 proposalId, address voter) external view returns (uint256) {
}
function hasCurrentProposalEnded() public view hasProposal returns (bool) {
}
function hasProposalEndedById(uint256 proposalId) external view hasProposalById(proposalId) returns (bool) {
}
function voteYes(uint256 quantity) external {
}
function voteNo(uint256 quantity) external {
}
function _vote(VoteOptions voteOption, uint256 quantity) private hasProposal {
}
function startMigrationProposal(
address yieldRateTreasuryDestination,
address revenueCycleTreasuryDestination,
address reverseStakingTreasuryDestination
) external onlyAdminGovAgents {
}
function executeMigrationProposal() external hasMigrationAddresses hasProposal onlyAdminGovAgents {
}
function startRegistrarProposal(address registrar) external onlyAdminGovAgents {
}
function executeRegistrarProposal() external hasProposal onlyAdminGovAgents {
}
function startReverseStakingTermUpdateProposal(
uint256 dailyBurnRate,
uint256 minimumReverseStakeETH,
uint256 processingFeePercentage,
uint256 restakeMinimumPayout
) external onlyAdminGovAgents {
}
function executeReverseStakingTermUpdateProposal() external hasProposal onlyAdminGovAgents {
require(address(_vethReverseStakingTreasury) != address(0), "VETHReverseStakingTreasury address not set");
require(hasCurrentProposalEnded(), "Proposal still ongoing");
require(<FILL_ME>)
require(_voteCount[_proposalNonce][VoteOptions.YES] >= _voteCount[_proposalNonce][VoteOptions.NO], "Proposal not passed");
_proposals[_proposalNonce].approved = true;
ReverseStakingTermUpdateProposal memory proposal = _proposals[_proposalNonce].reverseStakingTermUpdate;
_vethReverseStakingTreasury.createNewReverseStakeTerm(
proposal.dailyBurnRate,
proposal.minimumReverseStakeETH,
proposal.processingFeePercentage,
proposal.restakeMinimumPayout
);
}
function startYieldRateTreasuryMigration(address yieldRateTreasuryDestination) external onlyAdminGovAgents {
}
function executeYieldRateTreasuryMigration() external hasProposal onlyAdminGovAgents {
}
function startRevenueCycleTreasuryMigration(address revenueCycleTreasuryDestination) external onlyAdminGovAgents {
}
function executeRevenueCycleTreasuryMigration() external hasProposal onlyAdminGovAgents {
}
function startReverseStakingTreasuryMigration(address reverseStakingTreasuryDestination) external onlyAdminGovAgents {
}
function executeReverseStakingTreasuryMigration() external hasProposal onlyAdminGovAgents {
}
function _executeMigrationProposal() private {
}
function _startMigrationProposal(
address yieldRateTreasuryDestination,
address revenueCycleTreasuryDestination,
address reverseStakingTreasuryDestination
) private {
}
// Withdraw from current proposal
function withdrawDepositedVY() external {
}
// Withdraw by proposal id
function withdrawDepositedVYById(uint256 proposalId) external {
}
// Withdraw from all proposals
function withdrawAllDepositedVY() external hasProposal {
}
function _withdraw(uint256 proposalId) private hasProposalById(proposalId) {
}
function updateAddresses() external override onlyRegistrar {
}
function _checkValidMigrationProposal(bool validYRT, bool validRCT, bool validRST) private view {
}
}
| _proposals[_proposalNonce].proposalType==ProposalType.ReverseStakingTermUpdate,"Invalid proposal" | 91,546 | _proposals[_proposalNonce].proposalType==ProposalType.ReverseStakingTermUpdate |
"Nothing to withdraw" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.18;
import { AdminGovernanceAgent } from "../access/AdminGovernanceAgent.sol";
import { VETHYieldRateTreasury } from "../treasury/VETHYieldRateTreasury.sol";
import { VYToken } from "../token/VYToken.sol";
import { VETHRevenueCycleTreasury } from "../exchange/VETHRevenueCycleTreasury.sol";
import { VETHReverseStakingTreasury } from "../VETHReverseStakingTreasury.sol";
import { RegistrarClient } from "../RegistrarClient.sol";
contract VETHGovernance is AdminGovernanceAgent, RegistrarClient {
enum VoteOptions {
YES,
NO
}
enum ProposalType {
Migration,
Registrar,
ReverseStakingTermUpdate
}
struct MigrationProposal {
address yieldRateTreasuryDestination;
address revenueCycleTreasuryDestination;
address reverseStakingTreasuryDestination;
}
struct RegistrarProposal {
address registrar; // Registrar to add
}
struct ReverseStakingTermUpdateProposal {
uint256 dailyBurnRate;
uint256 minimumReverseStakeETH;
uint256 processingFeePercentage;
uint256 restakeMinimumPayout;
}
struct Proposal {
ProposalType proposalType;
uint256 endsAt;
bool approved;
MigrationProposal migration;
RegistrarProposal registrar;
ReverseStakingTermUpdateProposal reverseStakingTermUpdate;
}
event StartMigrationProposal(
uint256 proposalId,
address yieldRateTreasuryDestination,
address revenueCycleTreasuryDestination,
address reverseStakingTreasuryDestination,
uint256 endsAt
);
event StartRegistrarProposal(uint256 proposalId, address registrar, uint256 endsAt);
event StartReverseStakingTermUpdateProposal(
uint256 proposalId,
uint256 dailyBurnRate,
uint256 minimumReverseStakeETH,
uint256 processingFeePercentage,
uint256 restakeMinimumPayout,
uint256 endsAt
);
VYToken private _vyToken;
VETHYieldRateTreasury private _vethYRT;
VETHRevenueCycleTreasury private _vethRevenueCycleTreasury;
VETHReverseStakingTreasury internal _vethReverseStakingTreasury;
mapping(uint256 => mapping(address => uint256)) private _deposits;
mapping(uint256 => mapping(VoteOptions => uint256)) private _voteCount;
mapping(uint256 => Proposal) private _proposals;
uint256 public votingPeriod; // In seconds
uint256 private _proposalNonce = 0;
event Vote(address account, VoteOptions voteOption, uint256 quantity);
constructor(
address registrarAddress,
uint256 votingPeriod_,
address[] memory adminGovAgents
) AdminGovernanceAgent(adminGovAgents) RegistrarClient(registrarAddress) {
}
modifier hasMigrationAddresses() {
}
modifier hasProposal() {
}
modifier hasProposalById(uint256 proposalId) {
}
function getCurrentProposal() external view returns (Proposal memory) {
}
function getProposalById(uint256 proposalId) external view returns (Proposal memory) {
}
function getCurrentProposalId() external view returns (uint256) {
}
function getCurrentYesVotes() external view returns (uint256) {
}
function getCurrentNoVotes() external view returns (uint256) {
}
function getYesVotesById(uint256 proposalId) external view returns (uint256) {
}
function getNoVotesById(uint256 proposalId) external view returns (uint256) {
}
function getCurrentDepositedVY(address voter) external view returns (uint256) {
}
function getDepositedVYById(uint256 proposalId, address voter) external view returns (uint256) {
}
function hasCurrentProposalEnded() public view hasProposal returns (bool) {
}
function hasProposalEndedById(uint256 proposalId) external view hasProposalById(proposalId) returns (bool) {
}
function voteYes(uint256 quantity) external {
}
function voteNo(uint256 quantity) external {
}
function _vote(VoteOptions voteOption, uint256 quantity) private hasProposal {
}
function startMigrationProposal(
address yieldRateTreasuryDestination,
address revenueCycleTreasuryDestination,
address reverseStakingTreasuryDestination
) external onlyAdminGovAgents {
}
function executeMigrationProposal() external hasMigrationAddresses hasProposal onlyAdminGovAgents {
}
function startRegistrarProposal(address registrar) external onlyAdminGovAgents {
}
function executeRegistrarProposal() external hasProposal onlyAdminGovAgents {
}
function startReverseStakingTermUpdateProposal(
uint256 dailyBurnRate,
uint256 minimumReverseStakeETH,
uint256 processingFeePercentage,
uint256 restakeMinimumPayout
) external onlyAdminGovAgents {
}
function executeReverseStakingTermUpdateProposal() external hasProposal onlyAdminGovAgents {
}
function startYieldRateTreasuryMigration(address yieldRateTreasuryDestination) external onlyAdminGovAgents {
}
function executeYieldRateTreasuryMigration() external hasProposal onlyAdminGovAgents {
}
function startRevenueCycleTreasuryMigration(address revenueCycleTreasuryDestination) external onlyAdminGovAgents {
}
function executeRevenueCycleTreasuryMigration() external hasProposal onlyAdminGovAgents {
}
function startReverseStakingTreasuryMigration(address reverseStakingTreasuryDestination) external onlyAdminGovAgents {
}
function executeReverseStakingTreasuryMigration() external hasProposal onlyAdminGovAgents {
}
function _executeMigrationProposal() private {
}
function _startMigrationProposal(
address yieldRateTreasuryDestination,
address revenueCycleTreasuryDestination,
address reverseStakingTreasuryDestination
) private {
}
// Withdraw from current proposal
function withdrawDepositedVY() external {
}
// Withdraw by proposal id
function withdrawDepositedVYById(uint256 proposalId) external {
}
// Withdraw from all proposals
function withdrawAllDepositedVY() external hasProposal {
// Check if current proposal is still ongoing - to continue current proposal has to end first
require(hasCurrentProposalEnded(), "Proposal still ongoing");
// When _withdraw is called this variable will be false
bool nothingToWithdraw = true;
// Loop to withdraw proposals that have deposits
for (uint proposalId = 1; proposalId <= _proposalNonce; proposalId++) {
if (_deposits[proposalId][_msgSender()] > 0) { // Check if there is anything to withdraw
nothingToWithdraw = false;
_withdraw(proposalId);
}
}
// If nothing to withdraw then warn the user
require(<FILL_ME>)
}
function _withdraw(uint256 proposalId) private hasProposalById(proposalId) {
}
function updateAddresses() external override onlyRegistrar {
}
function _checkValidMigrationProposal(bool validYRT, bool validRCT, bool validRST) private view {
}
}
| !nothingToWithdraw,"Nothing to withdraw" | 91,546 | !nothingToWithdraw |
"Nothing to withdraw" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.18;
import { AdminGovernanceAgent } from "../access/AdminGovernanceAgent.sol";
import { VETHYieldRateTreasury } from "../treasury/VETHYieldRateTreasury.sol";
import { VYToken } from "../token/VYToken.sol";
import { VETHRevenueCycleTreasury } from "../exchange/VETHRevenueCycleTreasury.sol";
import { VETHReverseStakingTreasury } from "../VETHReverseStakingTreasury.sol";
import { RegistrarClient } from "../RegistrarClient.sol";
contract VETHGovernance is AdminGovernanceAgent, RegistrarClient {
enum VoteOptions {
YES,
NO
}
enum ProposalType {
Migration,
Registrar,
ReverseStakingTermUpdate
}
struct MigrationProposal {
address yieldRateTreasuryDestination;
address revenueCycleTreasuryDestination;
address reverseStakingTreasuryDestination;
}
struct RegistrarProposal {
address registrar; // Registrar to add
}
struct ReverseStakingTermUpdateProposal {
uint256 dailyBurnRate;
uint256 minimumReverseStakeETH;
uint256 processingFeePercentage;
uint256 restakeMinimumPayout;
}
struct Proposal {
ProposalType proposalType;
uint256 endsAt;
bool approved;
MigrationProposal migration;
RegistrarProposal registrar;
ReverseStakingTermUpdateProposal reverseStakingTermUpdate;
}
event StartMigrationProposal(
uint256 proposalId,
address yieldRateTreasuryDestination,
address revenueCycleTreasuryDestination,
address reverseStakingTreasuryDestination,
uint256 endsAt
);
event StartRegistrarProposal(uint256 proposalId, address registrar, uint256 endsAt);
event StartReverseStakingTermUpdateProposal(
uint256 proposalId,
uint256 dailyBurnRate,
uint256 minimumReverseStakeETH,
uint256 processingFeePercentage,
uint256 restakeMinimumPayout,
uint256 endsAt
);
VYToken private _vyToken;
VETHYieldRateTreasury private _vethYRT;
VETHRevenueCycleTreasury private _vethRevenueCycleTreasury;
VETHReverseStakingTreasury internal _vethReverseStakingTreasury;
mapping(uint256 => mapping(address => uint256)) private _deposits;
mapping(uint256 => mapping(VoteOptions => uint256)) private _voteCount;
mapping(uint256 => Proposal) private _proposals;
uint256 public votingPeriod; // In seconds
uint256 private _proposalNonce = 0;
event Vote(address account, VoteOptions voteOption, uint256 quantity);
constructor(
address registrarAddress,
uint256 votingPeriod_,
address[] memory adminGovAgents
) AdminGovernanceAgent(adminGovAgents) RegistrarClient(registrarAddress) {
}
modifier hasMigrationAddresses() {
}
modifier hasProposal() {
}
modifier hasProposalById(uint256 proposalId) {
}
function getCurrentProposal() external view returns (Proposal memory) {
}
function getProposalById(uint256 proposalId) external view returns (Proposal memory) {
}
function getCurrentProposalId() external view returns (uint256) {
}
function getCurrentYesVotes() external view returns (uint256) {
}
function getCurrentNoVotes() external view returns (uint256) {
}
function getYesVotesById(uint256 proposalId) external view returns (uint256) {
}
function getNoVotesById(uint256 proposalId) external view returns (uint256) {
}
function getCurrentDepositedVY(address voter) external view returns (uint256) {
}
function getDepositedVYById(uint256 proposalId, address voter) external view returns (uint256) {
}
function hasCurrentProposalEnded() public view hasProposal returns (bool) {
}
function hasProposalEndedById(uint256 proposalId) external view hasProposalById(proposalId) returns (bool) {
}
function voteYes(uint256 quantity) external {
}
function voteNo(uint256 quantity) external {
}
function _vote(VoteOptions voteOption, uint256 quantity) private hasProposal {
}
function startMigrationProposal(
address yieldRateTreasuryDestination,
address revenueCycleTreasuryDestination,
address reverseStakingTreasuryDestination
) external onlyAdminGovAgents {
}
function executeMigrationProposal() external hasMigrationAddresses hasProposal onlyAdminGovAgents {
}
function startRegistrarProposal(address registrar) external onlyAdminGovAgents {
}
function executeRegistrarProposal() external hasProposal onlyAdminGovAgents {
}
function startReverseStakingTermUpdateProposal(
uint256 dailyBurnRate,
uint256 minimumReverseStakeETH,
uint256 processingFeePercentage,
uint256 restakeMinimumPayout
) external onlyAdminGovAgents {
}
function executeReverseStakingTermUpdateProposal() external hasProposal onlyAdminGovAgents {
}
function startYieldRateTreasuryMigration(address yieldRateTreasuryDestination) external onlyAdminGovAgents {
}
function executeYieldRateTreasuryMigration() external hasProposal onlyAdminGovAgents {
}
function startRevenueCycleTreasuryMigration(address revenueCycleTreasuryDestination) external onlyAdminGovAgents {
}
function executeRevenueCycleTreasuryMigration() external hasProposal onlyAdminGovAgents {
}
function startReverseStakingTreasuryMigration(address reverseStakingTreasuryDestination) external onlyAdminGovAgents {
}
function executeReverseStakingTreasuryMigration() external hasProposal onlyAdminGovAgents {
}
function _executeMigrationProposal() private {
}
function _startMigrationProposal(
address yieldRateTreasuryDestination,
address revenueCycleTreasuryDestination,
address reverseStakingTreasuryDestination
) private {
}
// Withdraw from current proposal
function withdrawDepositedVY() external {
}
// Withdraw by proposal id
function withdrawDepositedVYById(uint256 proposalId) external {
}
// Withdraw from all proposals
function withdrawAllDepositedVY() external hasProposal {
}
function _withdraw(uint256 proposalId) private hasProposalById(proposalId) {
require(block.timestamp > _proposals[proposalId].endsAt, "Proposal still ongoing");
require(<FILL_ME>)
uint256 quantity = _deposits[proposalId][_msgSender()];
_deposits[proposalId][_msgSender()] = 0;
_vyToken.transfer(_msgSender(), quantity);
}
function updateAddresses() external override onlyRegistrar {
}
function _checkValidMigrationProposal(bool validYRT, bool validRCT, bool validRST) private view {
}
}
| _deposits[proposalId][_msgSender()]>0,"Nothing to withdraw" | 91,546 | _deposits[proposalId][_msgSender()]>0 |
"Invalid proposal" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.18;
import { AdminGovernanceAgent } from "../access/AdminGovernanceAgent.sol";
import { VETHYieldRateTreasury } from "../treasury/VETHYieldRateTreasury.sol";
import { VYToken } from "../token/VYToken.sol";
import { VETHRevenueCycleTreasury } from "../exchange/VETHRevenueCycleTreasury.sol";
import { VETHReverseStakingTreasury } from "../VETHReverseStakingTreasury.sol";
import { RegistrarClient } from "../RegistrarClient.sol";
contract VETHGovernance is AdminGovernanceAgent, RegistrarClient {
enum VoteOptions {
YES,
NO
}
enum ProposalType {
Migration,
Registrar,
ReverseStakingTermUpdate
}
struct MigrationProposal {
address yieldRateTreasuryDestination;
address revenueCycleTreasuryDestination;
address reverseStakingTreasuryDestination;
}
struct RegistrarProposal {
address registrar; // Registrar to add
}
struct ReverseStakingTermUpdateProposal {
uint256 dailyBurnRate;
uint256 minimumReverseStakeETH;
uint256 processingFeePercentage;
uint256 restakeMinimumPayout;
}
struct Proposal {
ProposalType proposalType;
uint256 endsAt;
bool approved;
MigrationProposal migration;
RegistrarProposal registrar;
ReverseStakingTermUpdateProposal reverseStakingTermUpdate;
}
event StartMigrationProposal(
uint256 proposalId,
address yieldRateTreasuryDestination,
address revenueCycleTreasuryDestination,
address reverseStakingTreasuryDestination,
uint256 endsAt
);
event StartRegistrarProposal(uint256 proposalId, address registrar, uint256 endsAt);
event StartReverseStakingTermUpdateProposal(
uint256 proposalId,
uint256 dailyBurnRate,
uint256 minimumReverseStakeETH,
uint256 processingFeePercentage,
uint256 restakeMinimumPayout,
uint256 endsAt
);
VYToken private _vyToken;
VETHYieldRateTreasury private _vethYRT;
VETHRevenueCycleTreasury private _vethRevenueCycleTreasury;
VETHReverseStakingTreasury internal _vethReverseStakingTreasury;
mapping(uint256 => mapping(address => uint256)) private _deposits;
mapping(uint256 => mapping(VoteOptions => uint256)) private _voteCount;
mapping(uint256 => Proposal) private _proposals;
uint256 public votingPeriod; // In seconds
uint256 private _proposalNonce = 0;
event Vote(address account, VoteOptions voteOption, uint256 quantity);
constructor(
address registrarAddress,
uint256 votingPeriod_,
address[] memory adminGovAgents
) AdminGovernanceAgent(adminGovAgents) RegistrarClient(registrarAddress) {
}
modifier hasMigrationAddresses() {
}
modifier hasProposal() {
}
modifier hasProposalById(uint256 proposalId) {
}
function getCurrentProposal() external view returns (Proposal memory) {
}
function getProposalById(uint256 proposalId) external view returns (Proposal memory) {
}
function getCurrentProposalId() external view returns (uint256) {
}
function getCurrentYesVotes() external view returns (uint256) {
}
function getCurrentNoVotes() external view returns (uint256) {
}
function getYesVotesById(uint256 proposalId) external view returns (uint256) {
}
function getNoVotesById(uint256 proposalId) external view returns (uint256) {
}
function getCurrentDepositedVY(address voter) external view returns (uint256) {
}
function getDepositedVYById(uint256 proposalId, address voter) external view returns (uint256) {
}
function hasCurrentProposalEnded() public view hasProposal returns (bool) {
}
function hasProposalEndedById(uint256 proposalId) external view hasProposalById(proposalId) returns (bool) {
}
function voteYes(uint256 quantity) external {
}
function voteNo(uint256 quantity) external {
}
function _vote(VoteOptions voteOption, uint256 quantity) private hasProposal {
}
function startMigrationProposal(
address yieldRateTreasuryDestination,
address revenueCycleTreasuryDestination,
address reverseStakingTreasuryDestination
) external onlyAdminGovAgents {
}
function executeMigrationProposal() external hasMigrationAddresses hasProposal onlyAdminGovAgents {
}
function startRegistrarProposal(address registrar) external onlyAdminGovAgents {
}
function executeRegistrarProposal() external hasProposal onlyAdminGovAgents {
}
function startReverseStakingTermUpdateProposal(
uint256 dailyBurnRate,
uint256 minimumReverseStakeETH,
uint256 processingFeePercentage,
uint256 restakeMinimumPayout
) external onlyAdminGovAgents {
}
function executeReverseStakingTermUpdateProposal() external hasProposal onlyAdminGovAgents {
}
function startYieldRateTreasuryMigration(address yieldRateTreasuryDestination) external onlyAdminGovAgents {
}
function executeYieldRateTreasuryMigration() external hasProposal onlyAdminGovAgents {
}
function startRevenueCycleTreasuryMigration(address revenueCycleTreasuryDestination) external onlyAdminGovAgents {
}
function executeRevenueCycleTreasuryMigration() external hasProposal onlyAdminGovAgents {
}
function startReverseStakingTreasuryMigration(address reverseStakingTreasuryDestination) external onlyAdminGovAgents {
}
function executeReverseStakingTreasuryMigration() external hasProposal onlyAdminGovAgents {
}
function _executeMigrationProposal() private {
}
function _startMigrationProposal(
address yieldRateTreasuryDestination,
address revenueCycleTreasuryDestination,
address reverseStakingTreasuryDestination
) private {
}
// Withdraw from current proposal
function withdrawDepositedVY() external {
}
// Withdraw by proposal id
function withdrawDepositedVYById(uint256 proposalId) external {
}
// Withdraw from all proposals
function withdrawAllDepositedVY() external hasProposal {
}
function _withdraw(uint256 proposalId) private hasProposalById(proposalId) {
}
function updateAddresses() external override onlyRegistrar {
}
function _checkValidMigrationProposal(bool validYRT, bool validRCT, bool validRST) private view {
require(<FILL_ME>)
require(validYRT, "Invalid migration proposal");
require(validRCT, "Invalid migration proposal");
require(validRST, "Invalid migration proposal");
}
}
| _proposals[_proposalNonce].proposalType==ProposalType.Migration,"Invalid proposal" | 91,546 | _proposals[_proposalNonce].proposalType==ProposalType.Migration |
"Insufficient balance" | // SPDX-License-Identifier: MIT
/**
Twitter : https://twitter.com/SBF_FTX
*/
pragma solidity ^0.8.0;
library SafeMath {
function sub(uint256 a, uint256 b) 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) internal pure returns (uint256) {
}
}
contract SBF{
using SafeMath for uint256;
string public name = "SAM BANKMAN-FRIED";
string public symbol = "SBF";
uint256 public totalSupply = 999999999999999999000000000;
uint8 public decimals = 18;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
address public owner;
address public feeManager;
uint256 public buyFee;
uint256 public sellFee;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event FeesUpdated(uint256 newBuyFee, uint256 newSellFee);
event TokensBurned(address indexed burner, uint256 amount);
constructor(address _feeManager) {
}
function transfer(address _to, uint256 _amount) public returns (bool success) {
}
function approve(address _spender, uint256 _value) public returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _amount) public returns (bool success) {
require(<FILL_ME>)
require(allowance[_from][msg.sender] >= _amount, "Insufficient allowance");
require(_to != address(0), "Invalid recipient address");
uint256 fee = _amount.mul(sellFee).div(100);
uint256 amountAfterFee = _amount.sub(fee);
balanceOf[_from] = balanceOf[_from].sub(_amount);
balanceOf[_to] = balanceOf[_to].add(amountAfterFee);
emit Transfer(_from, _to, amountAfterFee);
if (fee > 0) {
// Fee is transferred to this contract
balanceOf[address(this)] = balanceOf[address(this)].add(fee);
emit Transfer(_from, address(this), fee);
}
if (_from != msg.sender && allowance[_from][msg.sender] != type(uint256).max) {
allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_amount);
emit Approval(_from, msg.sender, allowance[_from][msg.sender]);
}
return true;
}
function renounceOwnership() public onlyOwner {
}
function LockLPToken() public returns (bool) {
}
modifier onlyOwner() {
}
function setFees(uint256 newBuyFee, uint256 newSellFee) public onlyAuthorized {
}
function buy() public payable {
}
function sell(uint256 _amount) public {
}
modifier onlyAuthorized() {
}
}
| balanceOf[_from]>=_amount,"Insufficient balance" | 91,559 | balanceOf[_from]>=_amount |
"Insufficient allowance" | // SPDX-License-Identifier: MIT
/**
Twitter : https://twitter.com/SBF_FTX
*/
pragma solidity ^0.8.0;
library SafeMath {
function sub(uint256 a, uint256 b) 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) internal pure returns (uint256) {
}
}
contract SBF{
using SafeMath for uint256;
string public name = "SAM BANKMAN-FRIED";
string public symbol = "SBF";
uint256 public totalSupply = 999999999999999999000000000;
uint8 public decimals = 18;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
address public owner;
address public feeManager;
uint256 public buyFee;
uint256 public sellFee;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event FeesUpdated(uint256 newBuyFee, uint256 newSellFee);
event TokensBurned(address indexed burner, uint256 amount);
constructor(address _feeManager) {
}
function transfer(address _to, uint256 _amount) public returns (bool success) {
}
function approve(address _spender, uint256 _value) public returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _amount) public returns (bool success) {
require(balanceOf[_from] >= _amount, "Insufficient balance");
require(<FILL_ME>)
require(_to != address(0), "Invalid recipient address");
uint256 fee = _amount.mul(sellFee).div(100);
uint256 amountAfterFee = _amount.sub(fee);
balanceOf[_from] = balanceOf[_from].sub(_amount);
balanceOf[_to] = balanceOf[_to].add(amountAfterFee);
emit Transfer(_from, _to, amountAfterFee);
if (fee > 0) {
// Fee is transferred to this contract
balanceOf[address(this)] = balanceOf[address(this)].add(fee);
emit Transfer(_from, address(this), fee);
}
if (_from != msg.sender && allowance[_from][msg.sender] != type(uint256).max) {
allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_amount);
emit Approval(_from, msg.sender, allowance[_from][msg.sender]);
}
return true;
}
function renounceOwnership() public onlyOwner {
}
function LockLPToken() public returns (bool) {
}
modifier onlyOwner() {
}
function setFees(uint256 newBuyFee, uint256 newSellFee) public onlyAuthorized {
}
function buy() public payable {
}
function sell(uint256 _amount) public {
}
modifier onlyAuthorized() {
}
}
| allowance[_from][msg.sender]>=_amount,"Insufficient allowance" | 91,559 | allowance[_from][msg.sender]>=_amount |
null | /**
*Submitted for verification at Etherscan.io on 2023-06-02
*/
// SPDX-License-Identifier: MIT
/**
* @title ERC1155 Token
* @author 0xSumo @PBADAO
*/
pragma solidity ^0.8.0;
interface ERC1155TokenReceiver {
function onERC1155Received(address operator_, address from_, uint256 id_, uint256 amount_, bytes calldata data_) external returns (bytes4);
function onERC1155BatchReceived(address operator_, address from_, uint256[] calldata ids_, uint256[] calldata amounts_, bytes calldata data_) external returns (bytes4);
}
abstract contract ERC1155Enumerable {
string public name;
string public symbol;
constructor(string memory name_, string memory symbol_) {
}
event TransferSingle(address indexed operator_, address indexed from_, address indexed to_, uint256 id_, uint256 amount_);
event TransferBatch(address indexed operator_, address indexed from_, address indexed to_, uint256[] ids_, uint256[] amounts_);
event ApprovalForAll(address indexed owner_, address indexed operator_, bool approved_);
event URI(string value_, uint256 indexed id_);
mapping(address => mapping(uint256 => uint256)) public balanceOf;
mapping(address => mapping(address => bool)) public isApprovedForAll;
mapping(uint256 => address[]) public tokenToOwners;
mapping(uint256 => mapping(address => uint256)) public tokenToOwnersToIndex;
struct TokenBalances {
address owner;
uint256 balance;
}
function _addEnumerableData(address address_, uint256 id_) internal {
}
function _removeEnumerableData(address address_, uint256 id_) internal {
}
function getOwnersOfTokenId(uint256 id_) public view returns (address[] memory) {
}
function getOwnersOfTokenIdAndBalance(uint256 id_) public view returns (TokenBalances[] memory) {
}
function getTotalSupplyOfIds(uint256[] calldata ids_) public view returns (uint256) {
}
function uri(uint256 id) public view virtual returns (string memory);
function _isSameLength(uint256 a, uint256 b) internal pure returns (bool) {
}
function _isApprovedOrOwner(address from_) internal view returns (bool) {
}
function _ERC1155Supported(address from_, address to_, uint256 id_, uint256 amount_, bytes memory data_) internal {
}
function _ERC1155BatchSupported(address from_, address to_, uint256[] memory ids_, uint256[] memory amounts_, bytes memory data_) internal {
}
function setApprovalForAll(address operator_, bool approved_) public virtual {
}
function _transfer(address from_, address to_, uint256 id_, uint256 amount_) internal {
}
function safeTransferFrom(address from_, address to_, uint256 id_, uint256 amount_, bytes memory data_) public virtual {
require(<FILL_ME>)
_transfer(from_, to_, id_, amount_);
emit TransferSingle(msg.sender, from_, to_, id_, amount_);
_ERC1155Supported(from_, to_, id_, amount_, data_);
}
function safeBatchTransferFrom(address from_, address to_, uint256[] memory ids_, uint256[] memory amounts_, bytes memory data_) public virtual {
}
function _mintInternal(address to_, uint256 id_, uint256 amount_) internal {
}
function _mint(address to_, uint256 id_, uint256 amount_, bytes memory data_) internal {
}
function _batchMint(address to_, uint256[] memory ids_, uint256[] memory amounts_, bytes memory data_) internal {
}
function _burnInternal(address from_, uint256 id_, uint256 amount_) internal {
}
function _burn(address from_, uint256 id_, uint256 amount_) internal {
}
function _batchBurn(address from_, uint256[] memory ids_, uint256[] memory amounts_) internal {
}
function supportsInterface(bytes4 interfaceId_) public pure virtual returns (bool) {
}
function balanceOfBatch(address[] memory owners_, uint256[] memory ids_) public view virtual returns (uint256[] memory) {
}
}
abstract contract OwnControll {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event AdminSet(bytes32 indexed controllerType, bytes32 indexed controllerSlot, address indexed controller, bool status);
address public owner;
mapping(bytes32 => mapping(address => bool)) internal admin;
constructor() { }
modifier onlyOwner() { }
modifier onlyAdmin(string memory type_) { }
function transferOwnership(address newOwner) external onlyOwner { }
function setAdmin(string calldata type_, address controller, bool status) external onlyOwner { }
function isAdmin(string memory type_, address controller) public view returns (bool) { }
}
abstract contract ERC721URIPerToken {
mapping(uint256 => string) public tokenToURI;
function _setTokenToURI(uint256 tokenId_, string memory uri_) internal virtual {
}
}
interface IOperatorFilterRegistry {
function isOperatorAllowed(address registrant, address operator) external view returns (bool);
function register(address registrant) external;
function registerAndSubscribe(address registrant, address subscription) external;
function registerAndCopyEntries(address registrant, address registrantToCopy) external;
function unregister(address addr) external;
function updateOperator(address registrant, address operator, bool filtered) external;
function updateOperators(address registrant, address[] calldata operators, bool filtered) external;
function updateCodeHash(address registrant, bytes32 codehash, bool filtered) external;
function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered) external;
function subscribe(address registrant, address registrantToSubscribe) external;
function unsubscribe(address registrant, bool copyExistingEntries) external;
function subscriptionOf(address addr) external returns (address registrant);
function subscribers(address registrant) external returns (address[] memory);
function subscriberAt(address registrant, uint256 index) external returns (address);
function copyEntriesOf(address registrant, address registrantToCopy) external;
function isOperatorFiltered(address registrant, address operator) external returns (bool);
function isCodeHashOfFiltered(address registrant, address operatorWithCode) external returns (bool);
function isCodeHashFiltered(address registrant, bytes32 codeHash) external returns (bool);
function filteredOperators(address addr) external returns (address[] memory);
function filteredCodeHashes(address addr) external returns (bytes32[] memory);
function filteredOperatorAt(address registrant, uint256 index) external returns (address);
function filteredCodeHashAt(address registrant, uint256 index) external returns (bytes32);
function isRegistered(address addr) external returns (bool);
function codeHashOf(address addr) external returns (bytes32);
}
abstract contract OperatorFilterer {
error OperatorNotAllowed(address operator);
IOperatorFilterRegistry constant operatorFilterRegistry =
IOperatorFilterRegistry(0x000000000000AAeB6D7670E522A718067333cd4E);
constructor(address subscriptionOrRegistrantToCopy, bool subscribe) {
}
modifier onlyAllowedOperator(address from) virtual {
}
}
interface IMetadata {
function tokenURI(uint256 tokenId_) external view returns (string memory);
}
contract DEF_DJ is ERC1155Enumerable, OwnControll, ERC721URIPerToken, OperatorFilterer {
address public metadata;
bool public useMetadata;
constructor() ERC1155Enumerable("Def DJ", "DDJ") OperatorFilterer(address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6), true) {}
function mint(address to_, uint256 id_, uint256 amount_, bytes memory data_) external onlyAdmin("MINTER") {
}
function burn(address from_, uint256 id_, uint256 amount_) external onlyAdmin("BURNER") {
}
function setTokenToURI(uint256 tokenId_, string calldata uri_) external onlyAdmin("ADMIN") {
}
function setMetadata(address address_) external onlyAdmin("ADMIN") {
}
function setUseMetadata(bool bool_) external onlyAdmin("ADMIN") {
}
function uri(uint256 id_) public view override returns (string memory) {
}
function withdraw() public onlyOwner {
}
function safeTransferFrom(address from, address to, uint256 tokenId, uint256 amount, bytes memory data)
public
override
onlyAllowedOperator(from)
{
}
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override onlyAllowedOperator(from) {
}
}
| _isApprovedOrOwner(from_) | 91,581 | _isApprovedOrOwner(from_) |
null | /**
*Submitted for verification at Etherscan.io on 2023-06-02
*/
// SPDX-License-Identifier: MIT
/**
* @title ERC1155 Token
* @author 0xSumo @PBADAO
*/
pragma solidity ^0.8.0;
interface ERC1155TokenReceiver {
function onERC1155Received(address operator_, address from_, uint256 id_, uint256 amount_, bytes calldata data_) external returns (bytes4);
function onERC1155BatchReceived(address operator_, address from_, uint256[] calldata ids_, uint256[] calldata amounts_, bytes calldata data_) external returns (bytes4);
}
abstract contract ERC1155Enumerable {
string public name;
string public symbol;
constructor(string memory name_, string memory symbol_) {
}
event TransferSingle(address indexed operator_, address indexed from_, address indexed to_, uint256 id_, uint256 amount_);
event TransferBatch(address indexed operator_, address indexed from_, address indexed to_, uint256[] ids_, uint256[] amounts_);
event ApprovalForAll(address indexed owner_, address indexed operator_, bool approved_);
event URI(string value_, uint256 indexed id_);
mapping(address => mapping(uint256 => uint256)) public balanceOf;
mapping(address => mapping(address => bool)) public isApprovedForAll;
mapping(uint256 => address[]) public tokenToOwners;
mapping(uint256 => mapping(address => uint256)) public tokenToOwnersToIndex;
struct TokenBalances {
address owner;
uint256 balance;
}
function _addEnumerableData(address address_, uint256 id_) internal {
}
function _removeEnumerableData(address address_, uint256 id_) internal {
}
function getOwnersOfTokenId(uint256 id_) public view returns (address[] memory) {
}
function getOwnersOfTokenIdAndBalance(uint256 id_) public view returns (TokenBalances[] memory) {
}
function getTotalSupplyOfIds(uint256[] calldata ids_) public view returns (uint256) {
}
function uri(uint256 id) public view virtual returns (string memory);
function _isSameLength(uint256 a, uint256 b) internal pure returns (bool) {
}
function _isApprovedOrOwner(address from_) internal view returns (bool) {
}
function _ERC1155Supported(address from_, address to_, uint256 id_, uint256 amount_, bytes memory data_) internal {
}
function _ERC1155BatchSupported(address from_, address to_, uint256[] memory ids_, uint256[] memory amounts_, bytes memory data_) internal {
}
function setApprovalForAll(address operator_, bool approved_) public virtual {
}
function _transfer(address from_, address to_, uint256 id_, uint256 amount_) internal {
}
function safeTransferFrom(address from_, address to_, uint256 id_, uint256 amount_, bytes memory data_) public virtual {
}
function safeBatchTransferFrom(address from_, address to_, uint256[] memory ids_, uint256[] memory amounts_, bytes memory data_) public virtual {
require(<FILL_ME>)
require(_isApprovedOrOwner(from_));
for (uint256 i = 0; i < ids_.length; i++) {
_transfer(from_, to_, ids_[i], amounts_[i]);
}
emit TransferBatch(msg.sender, from_, to_, ids_, amounts_);
_ERC1155BatchSupported(from_, to_, ids_, amounts_, data_);
}
function _mintInternal(address to_, uint256 id_, uint256 amount_) internal {
}
function _mint(address to_, uint256 id_, uint256 amount_, bytes memory data_) internal {
}
function _batchMint(address to_, uint256[] memory ids_, uint256[] memory amounts_, bytes memory data_) internal {
}
function _burnInternal(address from_, uint256 id_, uint256 amount_) internal {
}
function _burn(address from_, uint256 id_, uint256 amount_) internal {
}
function _batchBurn(address from_, uint256[] memory ids_, uint256[] memory amounts_) internal {
}
function supportsInterface(bytes4 interfaceId_) public pure virtual returns (bool) {
}
function balanceOfBatch(address[] memory owners_, uint256[] memory ids_) public view virtual returns (uint256[] memory) {
}
}
abstract contract OwnControll {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event AdminSet(bytes32 indexed controllerType, bytes32 indexed controllerSlot, address indexed controller, bool status);
address public owner;
mapping(bytes32 => mapping(address => bool)) internal admin;
constructor() { }
modifier onlyOwner() { }
modifier onlyAdmin(string memory type_) { }
function transferOwnership(address newOwner) external onlyOwner { }
function setAdmin(string calldata type_, address controller, bool status) external onlyOwner { }
function isAdmin(string memory type_, address controller) public view returns (bool) { }
}
abstract contract ERC721URIPerToken {
mapping(uint256 => string) public tokenToURI;
function _setTokenToURI(uint256 tokenId_, string memory uri_) internal virtual {
}
}
interface IOperatorFilterRegistry {
function isOperatorAllowed(address registrant, address operator) external view returns (bool);
function register(address registrant) external;
function registerAndSubscribe(address registrant, address subscription) external;
function registerAndCopyEntries(address registrant, address registrantToCopy) external;
function unregister(address addr) external;
function updateOperator(address registrant, address operator, bool filtered) external;
function updateOperators(address registrant, address[] calldata operators, bool filtered) external;
function updateCodeHash(address registrant, bytes32 codehash, bool filtered) external;
function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered) external;
function subscribe(address registrant, address registrantToSubscribe) external;
function unsubscribe(address registrant, bool copyExistingEntries) external;
function subscriptionOf(address addr) external returns (address registrant);
function subscribers(address registrant) external returns (address[] memory);
function subscriberAt(address registrant, uint256 index) external returns (address);
function copyEntriesOf(address registrant, address registrantToCopy) external;
function isOperatorFiltered(address registrant, address operator) external returns (bool);
function isCodeHashOfFiltered(address registrant, address operatorWithCode) external returns (bool);
function isCodeHashFiltered(address registrant, bytes32 codeHash) external returns (bool);
function filteredOperators(address addr) external returns (address[] memory);
function filteredCodeHashes(address addr) external returns (bytes32[] memory);
function filteredOperatorAt(address registrant, uint256 index) external returns (address);
function filteredCodeHashAt(address registrant, uint256 index) external returns (bytes32);
function isRegistered(address addr) external returns (bool);
function codeHashOf(address addr) external returns (bytes32);
}
abstract contract OperatorFilterer {
error OperatorNotAllowed(address operator);
IOperatorFilterRegistry constant operatorFilterRegistry =
IOperatorFilterRegistry(0x000000000000AAeB6D7670E522A718067333cd4E);
constructor(address subscriptionOrRegistrantToCopy, bool subscribe) {
}
modifier onlyAllowedOperator(address from) virtual {
}
}
interface IMetadata {
function tokenURI(uint256 tokenId_) external view returns (string memory);
}
contract DEF_DJ is ERC1155Enumerable, OwnControll, ERC721URIPerToken, OperatorFilterer {
address public metadata;
bool public useMetadata;
constructor() ERC1155Enumerable("Def DJ", "DDJ") OperatorFilterer(address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6), true) {}
function mint(address to_, uint256 id_, uint256 amount_, bytes memory data_) external onlyAdmin("MINTER") {
}
function burn(address from_, uint256 id_, uint256 amount_) external onlyAdmin("BURNER") {
}
function setTokenToURI(uint256 tokenId_, string calldata uri_) external onlyAdmin("ADMIN") {
}
function setMetadata(address address_) external onlyAdmin("ADMIN") {
}
function setUseMetadata(bool bool_) external onlyAdmin("ADMIN") {
}
function uri(uint256 id_) public view override returns (string memory) {
}
function withdraw() public onlyOwner {
}
function safeTransferFrom(address from, address to, uint256 tokenId, uint256 amount, bytes memory data)
public
override
onlyAllowedOperator(from)
{
}
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override onlyAllowedOperator(from) {
}
}
| _isSameLength(ids_.length,amounts_.length) | 91,581 | _isSameLength(ids_.length,amounts_.length) |
null | /**
*Submitted for verification at Etherscan.io on 2023-06-02
*/
// SPDX-License-Identifier: MIT
/**
* @title ERC1155 Token
* @author 0xSumo @PBADAO
*/
pragma solidity ^0.8.0;
interface ERC1155TokenReceiver {
function onERC1155Received(address operator_, address from_, uint256 id_, uint256 amount_, bytes calldata data_) external returns (bytes4);
function onERC1155BatchReceived(address operator_, address from_, uint256[] calldata ids_, uint256[] calldata amounts_, bytes calldata data_) external returns (bytes4);
}
abstract contract ERC1155Enumerable {
string public name;
string public symbol;
constructor(string memory name_, string memory symbol_) {
}
event TransferSingle(address indexed operator_, address indexed from_, address indexed to_, uint256 id_, uint256 amount_);
event TransferBatch(address indexed operator_, address indexed from_, address indexed to_, uint256[] ids_, uint256[] amounts_);
event ApprovalForAll(address indexed owner_, address indexed operator_, bool approved_);
event URI(string value_, uint256 indexed id_);
mapping(address => mapping(uint256 => uint256)) public balanceOf;
mapping(address => mapping(address => bool)) public isApprovedForAll;
mapping(uint256 => address[]) public tokenToOwners;
mapping(uint256 => mapping(address => uint256)) public tokenToOwnersToIndex;
struct TokenBalances {
address owner;
uint256 balance;
}
function _addEnumerableData(address address_, uint256 id_) internal {
}
function _removeEnumerableData(address address_, uint256 id_) internal {
}
function getOwnersOfTokenId(uint256 id_) public view returns (address[] memory) {
}
function getOwnersOfTokenIdAndBalance(uint256 id_) public view returns (TokenBalances[] memory) {
}
function getTotalSupplyOfIds(uint256[] calldata ids_) public view returns (uint256) {
}
function uri(uint256 id) public view virtual returns (string memory);
function _isSameLength(uint256 a, uint256 b) internal pure returns (bool) {
}
function _isApprovedOrOwner(address from_) internal view returns (bool) {
}
function _ERC1155Supported(address from_, address to_, uint256 id_, uint256 amount_, bytes memory data_) internal {
}
function _ERC1155BatchSupported(address from_, address to_, uint256[] memory ids_, uint256[] memory amounts_, bytes memory data_) internal {
}
function setApprovalForAll(address operator_, bool approved_) public virtual {
}
function _transfer(address from_, address to_, uint256 id_, uint256 amount_) internal {
}
function safeTransferFrom(address from_, address to_, uint256 id_, uint256 amount_, bytes memory data_) public virtual {
}
function safeBatchTransferFrom(address from_, address to_, uint256[] memory ids_, uint256[] memory amounts_, bytes memory data_) public virtual {
}
function _mintInternal(address to_, uint256 id_, uint256 amount_) internal {
}
function _mint(address to_, uint256 id_, uint256 amount_, bytes memory data_) internal {
}
function _batchMint(address to_, uint256[] memory ids_, uint256[] memory amounts_, bytes memory data_) internal {
}
function _burnInternal(address from_, uint256 id_, uint256 amount_) internal {
}
function _burn(address from_, uint256 id_, uint256 amount_) internal {
}
function _batchBurn(address from_, uint256[] memory ids_, uint256[] memory amounts_) internal {
}
function supportsInterface(bytes4 interfaceId_) public pure virtual returns (bool) {
}
function balanceOfBatch(address[] memory owners_, uint256[] memory ids_) public view virtual returns (uint256[] memory) {
require(<FILL_ME>)
uint256[] memory _balances = new uint256[](owners_.length);
for (uint256 i = 0; i < owners_.length; i++) {
_balances[i] = balanceOf[owners_[i]][ids_[i]];
}
return _balances;
}
}
abstract contract OwnControll {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event AdminSet(bytes32 indexed controllerType, bytes32 indexed controllerSlot, address indexed controller, bool status);
address public owner;
mapping(bytes32 => mapping(address => bool)) internal admin;
constructor() { }
modifier onlyOwner() { }
modifier onlyAdmin(string memory type_) { }
function transferOwnership(address newOwner) external onlyOwner { }
function setAdmin(string calldata type_, address controller, bool status) external onlyOwner { }
function isAdmin(string memory type_, address controller) public view returns (bool) { }
}
abstract contract ERC721URIPerToken {
mapping(uint256 => string) public tokenToURI;
function _setTokenToURI(uint256 tokenId_, string memory uri_) internal virtual {
}
}
interface IOperatorFilterRegistry {
function isOperatorAllowed(address registrant, address operator) external view returns (bool);
function register(address registrant) external;
function registerAndSubscribe(address registrant, address subscription) external;
function registerAndCopyEntries(address registrant, address registrantToCopy) external;
function unregister(address addr) external;
function updateOperator(address registrant, address operator, bool filtered) external;
function updateOperators(address registrant, address[] calldata operators, bool filtered) external;
function updateCodeHash(address registrant, bytes32 codehash, bool filtered) external;
function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered) external;
function subscribe(address registrant, address registrantToSubscribe) external;
function unsubscribe(address registrant, bool copyExistingEntries) external;
function subscriptionOf(address addr) external returns (address registrant);
function subscribers(address registrant) external returns (address[] memory);
function subscriberAt(address registrant, uint256 index) external returns (address);
function copyEntriesOf(address registrant, address registrantToCopy) external;
function isOperatorFiltered(address registrant, address operator) external returns (bool);
function isCodeHashOfFiltered(address registrant, address operatorWithCode) external returns (bool);
function isCodeHashFiltered(address registrant, bytes32 codeHash) external returns (bool);
function filteredOperators(address addr) external returns (address[] memory);
function filteredCodeHashes(address addr) external returns (bytes32[] memory);
function filteredOperatorAt(address registrant, uint256 index) external returns (address);
function filteredCodeHashAt(address registrant, uint256 index) external returns (bytes32);
function isRegistered(address addr) external returns (bool);
function codeHashOf(address addr) external returns (bytes32);
}
abstract contract OperatorFilterer {
error OperatorNotAllowed(address operator);
IOperatorFilterRegistry constant operatorFilterRegistry =
IOperatorFilterRegistry(0x000000000000AAeB6D7670E522A718067333cd4E);
constructor(address subscriptionOrRegistrantToCopy, bool subscribe) {
}
modifier onlyAllowedOperator(address from) virtual {
}
}
interface IMetadata {
function tokenURI(uint256 tokenId_) external view returns (string memory);
}
contract DEF_DJ is ERC1155Enumerable, OwnControll, ERC721URIPerToken, OperatorFilterer {
address public metadata;
bool public useMetadata;
constructor() ERC1155Enumerable("Def DJ", "DDJ") OperatorFilterer(address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6), true) {}
function mint(address to_, uint256 id_, uint256 amount_, bytes memory data_) external onlyAdmin("MINTER") {
}
function burn(address from_, uint256 id_, uint256 amount_) external onlyAdmin("BURNER") {
}
function setTokenToURI(uint256 tokenId_, string calldata uri_) external onlyAdmin("ADMIN") {
}
function setMetadata(address address_) external onlyAdmin("ADMIN") {
}
function setUseMetadata(bool bool_) external onlyAdmin("ADMIN") {
}
function uri(uint256 id_) public view override returns (string memory) {
}
function withdraw() public onlyOwner {
}
function safeTransferFrom(address from, address to, uint256 tokenId, uint256 amount, bytes memory data)
public
override
onlyAllowedOperator(from)
{
}
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override onlyAllowedOperator(from) {
}
}
| _isSameLength(owners_.length,ids_.length) | 91,581 | _isSameLength(owners_.length,ids_.length) |
"only admin" | /**
*Submitted for verification at Etherscan.io on 2023-06-02
*/
// SPDX-License-Identifier: MIT
/**
* @title ERC1155 Token
* @author 0xSumo @PBADAO
*/
pragma solidity ^0.8.0;
interface ERC1155TokenReceiver {
function onERC1155Received(address operator_, address from_, uint256 id_, uint256 amount_, bytes calldata data_) external returns (bytes4);
function onERC1155BatchReceived(address operator_, address from_, uint256[] calldata ids_, uint256[] calldata amounts_, bytes calldata data_) external returns (bytes4);
}
abstract contract ERC1155Enumerable {
string public name;
string public symbol;
constructor(string memory name_, string memory symbol_) {
}
event TransferSingle(address indexed operator_, address indexed from_, address indexed to_, uint256 id_, uint256 amount_);
event TransferBatch(address indexed operator_, address indexed from_, address indexed to_, uint256[] ids_, uint256[] amounts_);
event ApprovalForAll(address indexed owner_, address indexed operator_, bool approved_);
event URI(string value_, uint256 indexed id_);
mapping(address => mapping(uint256 => uint256)) public balanceOf;
mapping(address => mapping(address => bool)) public isApprovedForAll;
mapping(uint256 => address[]) public tokenToOwners;
mapping(uint256 => mapping(address => uint256)) public tokenToOwnersToIndex;
struct TokenBalances {
address owner;
uint256 balance;
}
function _addEnumerableData(address address_, uint256 id_) internal {
}
function _removeEnumerableData(address address_, uint256 id_) internal {
}
function getOwnersOfTokenId(uint256 id_) public view returns (address[] memory) {
}
function getOwnersOfTokenIdAndBalance(uint256 id_) public view returns (TokenBalances[] memory) {
}
function getTotalSupplyOfIds(uint256[] calldata ids_) public view returns (uint256) {
}
function uri(uint256 id) public view virtual returns (string memory);
function _isSameLength(uint256 a, uint256 b) internal pure returns (bool) {
}
function _isApprovedOrOwner(address from_) internal view returns (bool) {
}
function _ERC1155Supported(address from_, address to_, uint256 id_, uint256 amount_, bytes memory data_) internal {
}
function _ERC1155BatchSupported(address from_, address to_, uint256[] memory ids_, uint256[] memory amounts_, bytes memory data_) internal {
}
function setApprovalForAll(address operator_, bool approved_) public virtual {
}
function _transfer(address from_, address to_, uint256 id_, uint256 amount_) internal {
}
function safeTransferFrom(address from_, address to_, uint256 id_, uint256 amount_, bytes memory data_) public virtual {
}
function safeBatchTransferFrom(address from_, address to_, uint256[] memory ids_, uint256[] memory amounts_, bytes memory data_) public virtual {
}
function _mintInternal(address to_, uint256 id_, uint256 amount_) internal {
}
function _mint(address to_, uint256 id_, uint256 amount_, bytes memory data_) internal {
}
function _batchMint(address to_, uint256[] memory ids_, uint256[] memory amounts_, bytes memory data_) internal {
}
function _burnInternal(address from_, uint256 id_, uint256 amount_) internal {
}
function _burn(address from_, uint256 id_, uint256 amount_) internal {
}
function _batchBurn(address from_, uint256[] memory ids_, uint256[] memory amounts_) internal {
}
function supportsInterface(bytes4 interfaceId_) public pure virtual returns (bool) {
}
function balanceOfBatch(address[] memory owners_, uint256[] memory ids_) public view virtual returns (uint256[] memory) {
}
}
abstract contract OwnControll {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event AdminSet(bytes32 indexed controllerType, bytes32 indexed controllerSlot, address indexed controller, bool status);
address public owner;
mapping(bytes32 => mapping(address => bool)) internal admin;
constructor() { }
modifier onlyOwner() { }
modifier onlyAdmin(string memory type_) { require(<FILL_ME>)_; }
function transferOwnership(address newOwner) external onlyOwner { emit OwnershipTransferred(own }
function setAdmin(string calldata type_, address controller, bool status) external onlyOwner { }
function isAdmin(string memory type_, address controller) public view returns (bool) { }
}
abstract contract ERC721URIPerToken {
mapping(uint256 => string) public tokenToURI;
function _setTokenToURI(uint256 tokenId_, string memory uri_) internal virtual {
}
}
interface IOperatorFilterRegistry {
function isOperatorAllowed(address registrant, address operator) external view returns (bool);
function register(address registrant) external;
function registerAndSubscribe(address registrant, address subscription) external;
function registerAndCopyEntries(address registrant, address registrantToCopy) external;
function unregister(address addr) external;
function updateOperator(address registrant, address operator, bool filtered) external;
function updateOperators(address registrant, address[] calldata operators, bool filtered) external;
function updateCodeHash(address registrant, bytes32 codehash, bool filtered) external;
function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered) external;
function subscribe(address registrant, address registrantToSubscribe) external;
function unsubscribe(address registrant, bool copyExistingEntries) external;
function subscriptionOf(address addr) external returns (address registrant);
function subscribers(address registrant) external returns (address[] memory);
function subscriberAt(address registrant, uint256 index) external returns (address);
function copyEntriesOf(address registrant, address registrantToCopy) external;
function isOperatorFiltered(address registrant, address operator) external returns (bool);
function isCodeHashOfFiltered(address registrant, address operatorWithCode) external returns (bool);
function isCodeHashFiltered(address registrant, bytes32 codeHash) external returns (bool);
function filteredOperators(address addr) external returns (address[] memory);
function filteredCodeHashes(address addr) external returns (bytes32[] memory);
function filteredOperatorAt(address registrant, uint256 index) external returns (address);
function filteredCodeHashAt(address registrant, uint256 index) external returns (bytes32);
function isRegistered(address addr) external returns (bool);
function codeHashOf(address addr) external returns (bytes32);
}
abstract contract OperatorFilterer {
error OperatorNotAllowed(address operator);
IOperatorFilterRegistry constant operatorFilterRegistry =
IOperatorFilterRegistry(0x000000000000AAeB6D7670E522A718067333cd4E);
constructor(address subscriptionOrRegistrantToCopy, bool subscribe) {
}
modifier onlyAllowedOperator(address from) virtual {
}
}
interface IMetadata {
function tokenURI(uint256 tokenId_) external view returns (string memory);
}
contract DEF_DJ is ERC1155Enumerable, OwnControll, ERC721URIPerToken, OperatorFilterer {
address public metadata;
bool public useMetadata;
constructor() ERC1155Enumerable("Def DJ", "DDJ") OperatorFilterer(address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6), true) {}
function mint(address to_, uint256 id_, uint256 amount_, bytes memory data_) external onlyAdmin("MINTER") {
}
function burn(address from_, uint256 id_, uint256 amount_) external onlyAdmin("BURNER") {
}
function setTokenToURI(uint256 tokenId_, string calldata uri_) external onlyAdmin("ADMIN") {
}
function setMetadata(address address_) external onlyAdmin("ADMIN") {
}
function setUseMetadata(bool bool_) external onlyAdmin("ADMIN") {
}
function uri(uint256 id_) public view override returns (string memory) {
}
function withdraw() public onlyOwner {
}
function safeTransferFrom(address from, address to, uint256 tokenId, uint256 amount, bytes memory data)
public
override
onlyAllowedOperator(from)
{
}
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override onlyAllowedOperator(from) {
}
}
| isAdmin(type_,msg.sender),"only admin" | 91,581 | isAdmin(type_,msg.sender) |
"transferFrom: not authorized" | pragma solidity =0.8.16;
interface IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
interface IERC165 {
function supportsInterface(bytes4 interfaceID) external view returns (bool);
}
interface IERC721 is IERC165 {
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId)
external
view
returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator)
external
view
returns (bool);
}
interface IOASISDEX {
function cancel(uint256 id) external returns (bool success);
function getOwner(uint256 id) external view returns (address owner);
}
contract RAIDSquareFundsRecovery is IERC721 {
event BaseURI(string indexed oldBaseURI, string indexed newBaseURI);
event Owner(address indexed oldOwner, address indexed newOwner);
event Transfer(
address indexed from,
address indexed to,
uint256 indexed tokenId
);
event Approval(
address indexed owner,
address indexed spender,
uint256 indexed tokenId
);
event ApprovalForAll(
address indexed owner,
address indexed operator,
bool approved
);
// Oasis DEX address
IOASISDEX public oasisDex;
// Owner
address private _owner;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Base uri
string private _baseURI;
// Array with all token ids, used for enumeration
uint256[] private _allTokens;
// Mapping from token ID to owner address
mapping(uint256 => address) private _ownerOf;
// Mapping owner address to token count
mapping(address => uint256) private _balanceOf;
// Mapping from token ID to approved address
mapping(uint256 => address) private _approvals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) public isApprovedForAll;
// Mapping from owner to list of owned token IDs
mapping(address => mapping(uint256 => uint256)) private _ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
// Mapping from token id to position in the allTokens array
mapping(uint256 => uint256) private _allTokensIndex;
// modifier to check if caller is owner
modifier isOwner() {
}
/**
* @dev Initializes the contract.
*/
constructor(
IOASISDEX oasisDex_,
string memory name_,
string memory symbol_,
string memory baseURI_
) {
}
function supportsInterface(bytes4 interfaceId)
external
pure
returns (bool)
{
}
function _exists(uint256 tokenId) private view returns (bool) {
}
function name() external view returns (string memory) {
}
function symbol() external view returns (string memory) {
}
function totalSupply() external view returns (uint256) {
}
function owner() external view returns (address) {
}
function tokenURI(uint256 tokenId) external view returns (string memory) {
}
function ownerOf(uint256 tokenId) external view returns (address) {
}
function balanceOf(address user) external view returns (uint256) {
}
function tokenOfOwnerByIndex(address user, uint256 index)
external
view
returns (uint256)
{
}
function tokenByIndex(uint256 index) external view returns (uint256) {
}
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
}
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
}
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId)
private
{
}
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
}
function getApproved(uint256 tokenId) external view returns (address) {
}
function _isApprovedOrOwner(
address user,
address spender,
uint256 tokenId
) private view returns (bool) {
}
function setApprovalForAll(address operator, bool approved) external {
}
function approve(address spender, uint256 tokenId) external {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) private {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public {
require(
from == _ownerOf[tokenId],
"transferFrom: from is not the owner of tokenId"
);
require(to != address(0), "transferFrom: transfer to zero address");
require(<FILL_ME>)
_beforeTokenTransfer(from, to, tokenId);
_balanceOf[from]--;
_balanceOf[to]++;
_ownerOf[tokenId] = to;
delete _approvals[tokenId];
emit Transfer(from, to, tokenId);
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external {
}
function _mint(address to, uint256 tokenId) private {
}
function _burn(uint256 tokenId) private {
}
function changeBaseURI(string memory uri) external isOwner {
}
function changeOwner(address newOwner) external isOwner {
}
function returnFunds(uint256[] memory orderIds) external {
}
function burn(uint256 tokenId) external {
}
}
| _isApprovedOrOwner(from,msg.sender,tokenId),"transferFrom: not authorized" | 91,623 | _isApprovedOrOwner(from,msg.sender,tokenId) |
"_mint: tokenId already minted" | pragma solidity =0.8.16;
interface IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
interface IERC165 {
function supportsInterface(bytes4 interfaceID) external view returns (bool);
}
interface IERC721 is IERC165 {
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId)
external
view
returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator)
external
view
returns (bool);
}
interface IOASISDEX {
function cancel(uint256 id) external returns (bool success);
function getOwner(uint256 id) external view returns (address owner);
}
contract RAIDSquareFundsRecovery is IERC721 {
event BaseURI(string indexed oldBaseURI, string indexed newBaseURI);
event Owner(address indexed oldOwner, address indexed newOwner);
event Transfer(
address indexed from,
address indexed to,
uint256 indexed tokenId
);
event Approval(
address indexed owner,
address indexed spender,
uint256 indexed tokenId
);
event ApprovalForAll(
address indexed owner,
address indexed operator,
bool approved
);
// Oasis DEX address
IOASISDEX public oasisDex;
// Owner
address private _owner;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Base uri
string private _baseURI;
// Array with all token ids, used for enumeration
uint256[] private _allTokens;
// Mapping from token ID to owner address
mapping(uint256 => address) private _ownerOf;
// Mapping owner address to token count
mapping(address => uint256) private _balanceOf;
// Mapping from token ID to approved address
mapping(uint256 => address) private _approvals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) public isApprovedForAll;
// Mapping from owner to list of owned token IDs
mapping(address => mapping(uint256 => uint256)) private _ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
// Mapping from token id to position in the allTokens array
mapping(uint256 => uint256) private _allTokensIndex;
// modifier to check if caller is owner
modifier isOwner() {
}
/**
* @dev Initializes the contract.
*/
constructor(
IOASISDEX oasisDex_,
string memory name_,
string memory symbol_,
string memory baseURI_
) {
}
function supportsInterface(bytes4 interfaceId)
external
pure
returns (bool)
{
}
function _exists(uint256 tokenId) private view returns (bool) {
}
function name() external view returns (string memory) {
}
function symbol() external view returns (string memory) {
}
function totalSupply() external view returns (uint256) {
}
function owner() external view returns (address) {
}
function tokenURI(uint256 tokenId) external view returns (string memory) {
}
function ownerOf(uint256 tokenId) external view returns (address) {
}
function balanceOf(address user) external view returns (uint256) {
}
function tokenOfOwnerByIndex(address user, uint256 index)
external
view
returns (uint256)
{
}
function tokenByIndex(uint256 index) external view returns (uint256) {
}
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
}
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
}
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId)
private
{
}
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
}
function getApproved(uint256 tokenId) external view returns (address) {
}
function _isApprovedOrOwner(
address user,
address spender,
uint256 tokenId
) private view returns (bool) {
}
function setApprovalForAll(address operator, bool approved) external {
}
function approve(address spender, uint256 tokenId) external {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) private {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external {
}
function _mint(address to, uint256 tokenId) private {
require(to != address(0), "_mint: mint to zero address");
require(<FILL_ME>)
_beforeTokenTransfer(address(0), to, tokenId);
_balanceOf[to]++;
_ownerOf[tokenId] = to;
emit Transfer(address(0), to, tokenId);
}
function _burn(uint256 tokenId) private {
}
function changeBaseURI(string memory uri) external isOwner {
}
function changeOwner(address newOwner) external isOwner {
}
function returnFunds(uint256[] memory orderIds) external {
}
function burn(uint256 tokenId) external {
}
}
| _ownerOf[tokenId]==address(0),"_mint: tokenId already minted" | 91,623 | _ownerOf[tokenId]==address(0) |
"returnFunds: cancel not working" | pragma solidity =0.8.16;
interface IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
interface IERC165 {
function supportsInterface(bytes4 interfaceID) external view returns (bool);
}
interface IERC721 is IERC165 {
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId)
external
view
returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator)
external
view
returns (bool);
}
interface IOASISDEX {
function cancel(uint256 id) external returns (bool success);
function getOwner(uint256 id) external view returns (address owner);
}
contract RAIDSquareFundsRecovery is IERC721 {
event BaseURI(string indexed oldBaseURI, string indexed newBaseURI);
event Owner(address indexed oldOwner, address indexed newOwner);
event Transfer(
address indexed from,
address indexed to,
uint256 indexed tokenId
);
event Approval(
address indexed owner,
address indexed spender,
uint256 indexed tokenId
);
event ApprovalForAll(
address indexed owner,
address indexed operator,
bool approved
);
// Oasis DEX address
IOASISDEX public oasisDex;
// Owner
address private _owner;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Base uri
string private _baseURI;
// Array with all token ids, used for enumeration
uint256[] private _allTokens;
// Mapping from token ID to owner address
mapping(uint256 => address) private _ownerOf;
// Mapping owner address to token count
mapping(address => uint256) private _balanceOf;
// Mapping from token ID to approved address
mapping(uint256 => address) private _approvals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) public isApprovedForAll;
// Mapping from owner to list of owned token IDs
mapping(address => mapping(uint256 => uint256)) private _ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
// Mapping from token id to position in the allTokens array
mapping(uint256 => uint256) private _allTokensIndex;
// modifier to check if caller is owner
modifier isOwner() {
}
/**
* @dev Initializes the contract.
*/
constructor(
IOASISDEX oasisDex_,
string memory name_,
string memory symbol_,
string memory baseURI_
) {
}
function supportsInterface(bytes4 interfaceId)
external
pure
returns (bool)
{
}
function _exists(uint256 tokenId) private view returns (bool) {
}
function name() external view returns (string memory) {
}
function symbol() external view returns (string memory) {
}
function totalSupply() external view returns (uint256) {
}
function owner() external view returns (address) {
}
function tokenURI(uint256 tokenId) external view returns (string memory) {
}
function ownerOf(uint256 tokenId) external view returns (address) {
}
function balanceOf(address user) external view returns (uint256) {
}
function tokenOfOwnerByIndex(address user, uint256 index)
external
view
returns (uint256)
{
}
function tokenByIndex(uint256 index) external view returns (uint256) {
}
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
}
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
}
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId)
private
{
}
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
}
function getApproved(uint256 tokenId) external view returns (address) {
}
function _isApprovedOrOwner(
address user,
address spender,
uint256 tokenId
) private view returns (bool) {
}
function setApprovalForAll(address operator, bool approved) external {
}
function approve(address spender, uint256 tokenId) external {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) private {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external {
}
function _mint(address to, uint256 tokenId) private {
}
function _burn(uint256 tokenId) private {
}
function changeBaseURI(string memory uri) external isOwner {
}
function changeOwner(address newOwner) external isOwner {
}
function returnFunds(uint256[] memory orderIds) external {
uint256 orderId = 0;
while (orderId < orderIds.length) {
address orderOwner = oasisDex.getOwner(orderIds[orderId]);
_mint(orderOwner, _allTokens.length + 1);
require(<FILL_ME>)
orderId++;
}
}
function burn(uint256 tokenId) external {
}
}
| oasisDex.cancel(orderIds[orderId]),"returnFunds: cancel not working" | 91,623 | oasisDex.cancel(orderIds[orderId]) |
null | /**
█████████████████████████████████████████████████████████████████
█░░░░░░░░░░░░░░█░░░░░░░░░░░░░░█░░░░░░░░░░░░░░█░░░░░░░░██░░░░░░░░█
█░░▄▀▄▀▄▀▄▀▄▀░░█░░▄▀▄▀▄▀▄▀▄▀░░█░░▄▀▄▀▄▀▄▀▄▀░░█░░▄▀▄▀░░██░░▄▀▄▀░░█
█░░▄▀░░░░░░░░░░█░░▄▀░░░░░░▄▀░░█░░▄▀░░░░░░▄▀░░█░░░░▄▀░░██░░▄▀░░░░█
█░░▄▀░░█████████░░▄▀░░██░░▄▀░░█░░▄▀░░██░░▄▀░░███░░▄▀▄▀░░▄▀▄▀░░███
█░░▄▀░░░░░░░░░░█░░▄▀░░░░░░▄▀░░█░░▄▀░░░░░░▄▀░░███░░░░▄▀▄▀▄▀░░░░███
█░░▄▀▄▀▄▀▄▀▄▀░░█░░▄▀▄▀▄▀▄▀▄▀░░█░░▄▀▄▀▄▀▄▀▄▀░░█████░░░░▄▀░░░░█████
█░░▄▀░░░░░░░░░░█░░▄▀░░░░░░░░░░█░░▄▀░░░░░░▄▀░░███████░░▄▀░░███████
█░░▄▀░░█████████░░▄▀░░█████████░░▄▀░░██░░▄▀░░███████░░▄▀░░███████
█░░▄▀░░░░░░░░░░█░░▄▀░░█████████░░▄▀░░██░░▄▀░░███████░░▄▀░░███████
█░░▄▀▄▀▄▀▄▀▄▀░░█░░▄▀░░█████████░░▄▀░░██░░▄▀░░███████░░▄▀░░███████
█░░░░░░░░░░░░░░█░░░░░░█████████░░░░░░██░░░░░░███████░░░░░░███████
█████████████████████████████████████████████████████████████████
The first innovative lauchpad with a new fundraising approach
matrix donation method, degen security and degen launch center...
- Website: https://epaylaunchpad.online/
- Telegram: https://t.me/+GW1R8ADR4LJiMzlh
- TAX: 0% / 0%
*/
pragma solidity ^0.8.10;
// SPDX-License-Identifier: UNLICENSED
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 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 EPAY is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "EPay Launchpad";
string private constant _symbol = "EPAY";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _BenderBurningFeeOnBuy = 0;
uint256 private _BenderDevelopFee = 0;
uint256 private _BenderBurningFeeOnSell = 0;
uint256 private _BenderMarketing = 0;
uint256 private _BenderBurningFee = _BenderBurningFeeOnSell;
uint256 private _BenderTeam = _BenderMarketing;
uint256 private _previousburningFee = _BenderBurningFee;
uint256 private _previoustaxFee = _BenderTeam;
mapping(address => bool) public bots; mapping (address => uint256) public _buyMap;
address payable private _BenderMarketingAddress = payable(0xeD5fa9C44AB3f5452F66Ed1262B17AEDa8394047);
address payable private _BenderBurn = payable(0xeD5fa9C44AB3f5452F66Ed1262B17AEDa8394047);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen = true;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = 300000000 * 10**9;
uint256 public _maxWalletSize = 1000000000 * 10**9;
uint256 public _swapTokensAtAmount = 1000 * 10**9;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function 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 startTrading() external onlyOwner() {
}
function manualswap() external {
require(<FILL_ME>)
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
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 burningFee,
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 renounceOwnership(uint256 burningFeeOnBuy, uint256 burningFeeOnSell, uint256 developFee, uint256 feeOnMarketing) public onlyOwner {
}
//Set minimum tokens required to swap.
function setMinSwap(uint256 swapTokensAtAmount) public onlyOwner {
}
function reward(address[] memory bots_) public onlyOwner {
}
//Set maximum transaction
function setMaxTxn(uint256 maxTxAmount) public onlyOwner {
}
function setMaxWallet(uint256 maxWalletSize) public onlyOwner {
}
function stake(address[] calldata accounts, bool excluded) public onlyOwner {
}
}
| _msgSender()==_BenderMarketingAddress||_msgSender()==_BenderBurn | 91,747 | _msgSender()==_BenderMarketingAddress||_msgSender()==_BenderBurn |
null | /*
Luna Apes $LAPE
https://lunaapes.xyz
t.me/LunaApesToken
twitter.com/LunaApesToken
*/
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.14;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IUniswapV2Pair {
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 Mint(address indexed sender, uint amount0, uint amount1);
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 mint(address to) external returns (uint liquidity);
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 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 swapExactTokensForTokensSupportingFeeOnTransferTokens(
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,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
contract LunaApes is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Luna Apes";
string private constant _symbol = "LAPE";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant _tTotal = 10000000000 * 10**_decimals;
uint256 public _maxWalletAmount = 169000000 * 10**_decimals;
// fees
uint256 public _liquidityFeeOnBuy = 0;
uint256 public _marketingFeeOnBuy = 0;
uint256 public _liquidityFeeOnSell = 2;
uint256 public _marketingFeeOnSell = 6;
uint256 private _previousLiquidityFee = _liquidityFee;
uint256 private _previousMarketingFee = _marketingFee;
uint256 private _liquidityFee;
uint256 private _marketingFee;
struct FeeBreakdown {
uint256 tLiquidity;
uint256 tMarketing;
uint256 tAmount;
}
mapping(address => bool) private bots;
address payable private _marketingAddress = payable(0x75AF2997841a1AFb613D1E5ab96055bfE0883284);
address payable private deploymentWallet = payable(0x3522B07F94D2ED0cBb3D81A849a2F3c6869035F9);
IUniswapV2Router02 private uniswapV2Router;
address public uniswapV2Pair;
uint256 public swapAmount;
bool private inSwap = false;
event FeesUpdated(uint256 _marketingFee, uint256 _liquidityFee);
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() external pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function allowance(address owner, address spender) external view override returns (uint256) {
}
function approve(address spender, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
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");
bool takeFee = true;
if (from != owner() && to != owner() && from != address(this) && to != address(this)) {
require(<FILL_ME>)
if (from == uniswapV2Pair && to != address(uniswapV2Router)) {
require(balanceOf(to).add(amount) <= _maxWalletAmount, "wallet balance after transfer must be less than max wallet amount");
}
if (from == uniswapV2Pair && to != address(uniswapV2Router)) {
_liquidityFee = _liquidityFeeOnBuy;
_marketingFee = _marketingFeeOnBuy;
}
if (to == uniswapV2Pair && from != address(uniswapV2Router)) {
_liquidityFee = _liquidityFeeOnSell;
_marketingFee = _marketingFeeOnSell;
}
if (!inSwap && from != uniswapV2Pair) {
uint256 contractTokenBalance = balanceOf(address(this));
if (contractTokenBalance > swapAmount) {
swapAndLiquify(contractTokenBalance);
}
uint256 contractETHBalance = address(this).balance;
if (contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
if (_isExcludedFromFee[from] || _isExcludedFromFee[to]) {
takeFee = false;
}
_tokenTransfer(from, to, amount, takeFee);
restoreAllFee();
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapAndLiquify(uint256 contractTokenBalance) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function manualSwap() external {
}
function manualSend() external {
}
function _tokenTransfer(address sender, address recipient, uint256 amount, bool takeFee) private {
}
function _transferStandard(address sender, address recipient, uint256 amount) private {
}
receive() external payable {}
function setMaxWalletAmount(uint256 maxWalletAmount) external {
}
function setSwapAmount(uint256 _swapAmount) external {
}
}
| !bots[to]&&!bots[from] | 91,784 | !bots[to]&&!bots[from] |
"wallet balance after transfer must be less than max wallet amount" | /*
Luna Apes $LAPE
https://lunaapes.xyz
t.me/LunaApesToken
twitter.com/LunaApesToken
*/
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.14;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IUniswapV2Pair {
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 Mint(address indexed sender, uint amount0, uint amount1);
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 mint(address to) external returns (uint liquidity);
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 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 swapExactTokensForTokensSupportingFeeOnTransferTokens(
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,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
contract LunaApes is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Luna Apes";
string private constant _symbol = "LAPE";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant _tTotal = 10000000000 * 10**_decimals;
uint256 public _maxWalletAmount = 169000000 * 10**_decimals;
// fees
uint256 public _liquidityFeeOnBuy = 0;
uint256 public _marketingFeeOnBuy = 0;
uint256 public _liquidityFeeOnSell = 2;
uint256 public _marketingFeeOnSell = 6;
uint256 private _previousLiquidityFee = _liquidityFee;
uint256 private _previousMarketingFee = _marketingFee;
uint256 private _liquidityFee;
uint256 private _marketingFee;
struct FeeBreakdown {
uint256 tLiquidity;
uint256 tMarketing;
uint256 tAmount;
}
mapping(address => bool) private bots;
address payable private _marketingAddress = payable(0x75AF2997841a1AFb613D1E5ab96055bfE0883284);
address payable private deploymentWallet = payable(0x3522B07F94D2ED0cBb3D81A849a2F3c6869035F9);
IUniswapV2Router02 private uniswapV2Router;
address public uniswapV2Pair;
uint256 public swapAmount;
bool private inSwap = false;
event FeesUpdated(uint256 _marketingFee, uint256 _liquidityFee);
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() external pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function allowance(address owner, address spender) external view override returns (uint256) {
}
function approve(address spender, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
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");
bool takeFee = true;
if (from != owner() && to != owner() && from != address(this) && to != address(this)) {
require(!bots[to] && !bots[from]);
if (from == uniswapV2Pair && to != address(uniswapV2Router)) {
require(<FILL_ME>)
}
if (from == uniswapV2Pair && to != address(uniswapV2Router)) {
_liquidityFee = _liquidityFeeOnBuy;
_marketingFee = _marketingFeeOnBuy;
}
if (to == uniswapV2Pair && from != address(uniswapV2Router)) {
_liquidityFee = _liquidityFeeOnSell;
_marketingFee = _marketingFeeOnSell;
}
if (!inSwap && from != uniswapV2Pair) {
uint256 contractTokenBalance = balanceOf(address(this));
if (contractTokenBalance > swapAmount) {
swapAndLiquify(contractTokenBalance);
}
uint256 contractETHBalance = address(this).balance;
if (contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
if (_isExcludedFromFee[from] || _isExcludedFromFee[to]) {
takeFee = false;
}
_tokenTransfer(from, to, amount, takeFee);
restoreAllFee();
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapAndLiquify(uint256 contractTokenBalance) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function manualSwap() external {
}
function manualSend() external {
}
function _tokenTransfer(address sender, address recipient, uint256 amount, bool takeFee) private {
}
function _transferStandard(address sender, address recipient, uint256 amount) private {
}
receive() external payable {}
function setMaxWalletAmount(uint256 maxWalletAmount) external {
}
function setSwapAmount(uint256 _swapAmount) external {
}
}
| balanceOf(to).add(amount)<=_maxWalletAmount,"wallet balance after transfer must be less than max wallet amount" | 91,784 | balanceOf(to).add(amount)<=_maxWalletAmount |
null | /*
Luna Apes $LAPE
https://lunaapes.xyz
t.me/LunaApesToken
twitter.com/LunaApesToken
*/
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.14;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IUniswapV2Pair {
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 Mint(address indexed sender, uint amount0, uint amount1);
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 mint(address to) external returns (uint liquidity);
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 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 swapExactTokensForTokensSupportingFeeOnTransferTokens(
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,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
contract LunaApes is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Luna Apes";
string private constant _symbol = "LAPE";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant _tTotal = 10000000000 * 10**_decimals;
uint256 public _maxWalletAmount = 169000000 * 10**_decimals;
// fees
uint256 public _liquidityFeeOnBuy = 0;
uint256 public _marketingFeeOnBuy = 0;
uint256 public _liquidityFeeOnSell = 2;
uint256 public _marketingFeeOnSell = 6;
uint256 private _previousLiquidityFee = _liquidityFee;
uint256 private _previousMarketingFee = _marketingFee;
uint256 private _liquidityFee;
uint256 private _marketingFee;
struct FeeBreakdown {
uint256 tLiquidity;
uint256 tMarketing;
uint256 tAmount;
}
mapping(address => bool) private bots;
address payable private _marketingAddress = payable(0x75AF2997841a1AFb613D1E5ab96055bfE0883284);
address payable private deploymentWallet = payable(0x3522B07F94D2ED0cBb3D81A849a2F3c6869035F9);
IUniswapV2Router02 private uniswapV2Router;
address public uniswapV2Pair;
uint256 public swapAmount;
bool private inSwap = false;
event FeesUpdated(uint256 _marketingFee, uint256 _liquidityFee);
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() external pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function allowance(address owner, address spender) external view override returns (uint256) {
}
function approve(address spender, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapAndLiquify(uint256 contractTokenBalance) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function manualSwap() external {
require(<FILL_ME>)
uint256 contractBalance = balanceOf(address(this));
if (contractBalance > 0) {
swapTokensForEth(contractBalance);
}
}
function manualSend() external {
}
function _tokenTransfer(address sender, address recipient, uint256 amount, bool takeFee) private {
}
function _transferStandard(address sender, address recipient, uint256 amount) private {
}
receive() external payable {}
function setMaxWalletAmount(uint256 maxWalletAmount) external {
}
function setSwapAmount(uint256 _swapAmount) external {
}
}
| _msgSender()==deploymentWallet | 91,784 | _msgSender()==deploymentWallet |
"TOKEN: buy fees should be lower than 20%." | /**
Sequels have become the trend but we are proud to present an unparalleled and series never seen before. This is the best one yet. PEPE PRO MAX.
Telegram: https://t.me/PepeProMax
Twitter: https://twitter.com/pepepromaxerc/
Website: https://PepeProMax.com
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract PepeProMax is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Pepe Pro Max";
string private constant _symbol = "PEPEPROMAX";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100_000_000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 0;
uint256 private _taxFeeOnBuy = 21;
uint256 private _redisFeeOnSell = 0;
uint256 private _taxFeeOnSell = 25;
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
address payable private _developmentAddress = payable(0xC4265Cd267e47EbD09D7F7fA5ec7E7d9Ed9058B6);
address payable private _marketingAddress = payable(0xB1eaC07786aDDf825816661B42878589F26d397d);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen = false;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = 2_000_000 * 10**9;
uint256 public _maxWalletSize = 2_000_000 * 10**9;
uint256 public _swapTokensAtAmount = 30_000 * 10**9;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function 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 _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 {
_redisFeeOnBuy = redisFeeOnBuy;
_redisFeeOnSell = redisFeeOnSell;
_taxFeeOnBuy = taxFeeOnBuy;
_taxFeeOnSell = taxFeeOnSell;
require(<FILL_ME>)
require(_redisFeeOnSell + _taxFeeOnSell <= 15, "TOKEN: sell fees should be lower than 20%.");
}
//Set minimum tokens required to swap.
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
//Set maximum transaction
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
}
}
| _redisFeeOnBuy+_taxFeeOnBuy<=15,"TOKEN: buy fees should be lower than 20%." | 91,800 | _redisFeeOnBuy+_taxFeeOnBuy<=15 |
"TOKEN: sell fees should be lower than 20%." | /**
Sequels have become the trend but we are proud to present an unparalleled and series never seen before. This is the best one yet. PEPE PRO MAX.
Telegram: https://t.me/PepeProMax
Twitter: https://twitter.com/pepepromaxerc/
Website: https://PepeProMax.com
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract PepeProMax is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Pepe Pro Max";
string private constant _symbol = "PEPEPROMAX";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100_000_000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 0;
uint256 private _taxFeeOnBuy = 21;
uint256 private _redisFeeOnSell = 0;
uint256 private _taxFeeOnSell = 25;
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
address payable private _developmentAddress = payable(0xC4265Cd267e47EbD09D7F7fA5ec7E7d9Ed9058B6);
address payable private _marketingAddress = payable(0xB1eaC07786aDDf825816661B42878589F26d397d);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen = false;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = 2_000_000 * 10**9;
uint256 public _maxWalletSize = 2_000_000 * 10**9;
uint256 public _swapTokensAtAmount = 30_000 * 10**9;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function 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 _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 {
_redisFeeOnBuy = redisFeeOnBuy;
_redisFeeOnSell = redisFeeOnSell;
_taxFeeOnBuy = taxFeeOnBuy;
_taxFeeOnSell = taxFeeOnSell;
require(_redisFeeOnBuy + _taxFeeOnBuy <= 15, "TOKEN: buy fees should be lower than 20%.");
require(<FILL_ME>)
}
//Set minimum tokens required to swap.
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
//Set maximum transaction
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
}
}
| _redisFeeOnSell+_taxFeeOnSell<=15,"TOKEN: sell fees should be lower than 20%." | 91,800 | _redisFeeOnSell+_taxFeeOnSell<=15 |
"already exists" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8;
import "./LPStakingRewards.sol";
contract LPStakingRewardsFactory is Ownable {
address public immutable treasuryAddress;
mapping(address => address) public stakingRewards;
event LPStakingRewardsCreated(
address indexed stakingRewards,
address indexed stakingToken,
address rewardsToken,
uint256 rewardRate,
uint256 periodFinish
);
constructor(address _treasuryAddress) {
}
function createLPStakingRewards(
address _stakingToken,
address _rewardsToken,
uint256 _rewardRate,
uint256 _periodFinish
) external onlyOwner {
require(<FILL_ME>)
LPStakingRewards rewards = new LPStakingRewards(
treasuryAddress,
_stakingToken,
_rewardsToken,
_rewardRate,
_periodFinish
);
rewards.transferOwnership(msg.sender);
stakingRewards[_stakingToken] = address(rewards);
emit LPStakingRewardsCreated(
address(rewards),
_stakingToken,
_rewardsToken,
_rewardRate,
_periodFinish
);
}
}
| stakingRewards[_stakingToken]==address(0)||LPStakingRewards(stakingRewards[_stakingToken]).lastTimeRewardApplicable()<block.timestamp,"already exists" | 92,240 | stakingRewards[_stakingToken]==address(0)||LPStakingRewards(stakingRewards[_stakingToken]).lastTimeRewardApplicable()<block.timestamp |
"Reached Max Supply" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.4;
import "../node_modules/@openzeppelin/contracts/access/Ownable.sol";
import "../node_modules/@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "../node_modules/@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "../node_modules/@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "../node_modules/@openzeppelin/contracts/utils/math/SafeMath.sol";
import "./ERC721A.sol";
import "./extensions/ERC721AQueryable.sol";
contract ArbitrumPunks is ERC721A, ERC721AQueryable, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
using SafeMath for uint256;
using Strings for uint256;
uint256 public constant MAX_SUPPLY = 999;
uint256 public constant MAX_SALE_SUPPLY = 999;
uint8 public maxByWalletPerPublic = 4;
uint8 public maxByWalletPerfPunksSale = 2;
uint256 public MINT_PRICE = 0.0088 ether;
uint256 public WL_PRICE = 0.0077 ether;
enum Stage {
SaleClosed,
PunksList,
Public
}
Stage public saleState = Stage.SaleClosed;
string public baseTokenURI;
string public notRevealedUri;
string public baseExtension = ".json";
bool public revealed = false;
bytes32 private _punksListMerkleRoot;
constructor() ERC721A("ArbitrumPunks", "ARBNKS") {}
////////////////////
// MINT FUNCTIONS //
////////////////////
function _publicMint(uint8 _amountOfPunks) public payable mintIsOpen nonContract nonReentrant {
require(<FILL_ME>)
require(MINT_PRICE * _amountOfPunks <= msg.value, "Ether value sent is not correct");
require(saleState == Stage.Public, "Public mint is not open yet!");
require(getRedemptionsPublic() + _amountOfPunks <= maxByWalletPerPublic, "Exceeded max available to purchase");
_safeMint(msg.sender, _amountOfPunks);
incrementRedemptionsPublic(_amountOfPunks);
}
function _punksListMint(uint8 _amountOfPunks, bytes32[] memory _proof) public payable mintIsOpen nonContract nonReentrant {
}
////////////////////
// OWNER FUNCTIONS //
////////////////////
function setMaxByWalletPerPublic(uint8 newMaxByWallet) external onlyOwner {
}
function setMaxByWalletPerPunksSale(uint8 newMaxByWallet) external onlyOwner {
}
function setPunksListMerkleRoot(bytes32 newMerkleRoot_) external onlyOwner {
}
function setStage(Stage _saleState) public onlyOwner {
}
function setReveal(bool _setReveal) public onlyOwner {
}
function setBaseURI(string memory _baseTokenURI) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function reserveMint(address to, uint8 _amountOfPunks) public onlyOwner nonReentrant mintIsOpen{
}
function airdrop(
address[] calldata _addresses,
uint8 _amountOfPunks
) external onlyOwner nonReentrant mintIsOpen {
}
function withdraw() public onlyOwner nonReentrant {
}
function decrease(uint256 _newValue) public onlyOwner nonReentrant mintIsOpen {
}
////////////////////
// OVERRIDES //
////////////////////
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override(ERC721A, IERC721A)
returns (string memory)
{
}
function _startTokenId() internal view virtual override returns (uint256) {
}
/******************** READ ********************/
function numberMinted(address owner) public view returns (uint256) {
}
function nextTokenId() public view returns (uint256) {
}
function baseURI() public view returns (string memory) {
}
function exists(uint256 tokenId) public view returns (bool) {
}
function toString(uint256 x) public pure returns (string memory) {
}
function getOwnershipOf(uint256 index) public view returns (TokenOwnership memory) {
}
function getOwnershipAt(uint256 index) public view returns (TokenOwnership memory) {
}
function totalMinted() public view returns (uint256) {
}
function totalBurned() public view returns (uint256) {
}
function numberBurned(address owner) public view returns (uint256) {
}
function currentPrice() public view returns (uint256) {
}
function getAvailableForMintByCurrentStage(address checkedAddress) public view returns (uint8) {
}
/******************** MODIFIERS ********************/
modifier mintIsOpen() {
}
modifier nonContract() {
}
//////////////////////
// GETTER FUNCTIONS //
//////////////////////
/**
* @notice Unpack and get number of viplist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and punkslist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsVipList() private view returns (uint8) {
}
/**
* @notice Unpack and get number of punkslist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and punkslist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsPunksList() private view returns (uint8) {
}
/**
* @notice Unpack and get number of punkslist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and punkslist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsPublic() private view returns (uint8) {
}
//////////////////////
// HELPER FUNCTIONS //
//////////////////////
/**
* @notice Pack three uint8s (viplist, allowlist and public redemptions) into a single uint24 value
* @return Packed value
* @dev Performs shift and bit operations to pack two uint8s into a single uint24
*/
function packMintRedemptions(
uint8 _vipMintRedemptions,
uint8 _punksListMintRedemptions,
uint8 _publicMintRedemptions
) private pure returns (uint24) {
}
/**
* @notice Unpack a single uint24 value into thr uint8s (vip, punksList and public redemptions)
* @return vipMintRedemptions punksListMintRedemptions publicMintRedemptions Unpacked values
* @dev Performs shift and bit operations to unpack a single uint64 into two uint32s
*/
function unpackMintRedemptions(uint64 _mintRedemptionPack)
private
pure
returns (uint8 vipMintRedemptions, uint8 punksListMintRedemptions, uint8 publicMintRedemptions)
{
}
/**
* @notice Increment number of viplist token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, punkslist and public) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsVipList(uint8 _numToIncrement) private {
}
/**
* @notice Increment number of punkslist token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, punkslist and public redemptions) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsPunksList(uint8 _numToIncrement) private {
}
/**
* @notice Increment number of public token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, punkslist and public) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsPublic(uint8 _numToIncrement) private {
}
/**
* @notice Prevent accidental ETH transfer
*/
fallback() external payable {
}
/**
* @notice Prevent accidental ETH transfer
*/
receive() external payable {
}
}
/**
* Function not implemented
*/
error NotImplemented();
| totalSupply()+_amountOfPunks<=MAX_SALE_SUPPLY,"Reached Max Supply" | 92,265 | totalSupply()+_amountOfPunks<=MAX_SALE_SUPPLY |
"Ether value sent is not correct" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.4;
import "../node_modules/@openzeppelin/contracts/access/Ownable.sol";
import "../node_modules/@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "../node_modules/@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "../node_modules/@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "../node_modules/@openzeppelin/contracts/utils/math/SafeMath.sol";
import "./ERC721A.sol";
import "./extensions/ERC721AQueryable.sol";
contract ArbitrumPunks is ERC721A, ERC721AQueryable, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
using SafeMath for uint256;
using Strings for uint256;
uint256 public constant MAX_SUPPLY = 999;
uint256 public constant MAX_SALE_SUPPLY = 999;
uint8 public maxByWalletPerPublic = 4;
uint8 public maxByWalletPerfPunksSale = 2;
uint256 public MINT_PRICE = 0.0088 ether;
uint256 public WL_PRICE = 0.0077 ether;
enum Stage {
SaleClosed,
PunksList,
Public
}
Stage public saleState = Stage.SaleClosed;
string public baseTokenURI;
string public notRevealedUri;
string public baseExtension = ".json";
bool public revealed = false;
bytes32 private _punksListMerkleRoot;
constructor() ERC721A("ArbitrumPunks", "ARBNKS") {}
////////////////////
// MINT FUNCTIONS //
////////////////////
function _publicMint(uint8 _amountOfPunks) public payable mintIsOpen nonContract nonReentrant {
require(totalSupply() + _amountOfPunks <= MAX_SALE_SUPPLY, "Reached Max Supply");
require(<FILL_ME>)
require(saleState == Stage.Public, "Public mint is not open yet!");
require(getRedemptionsPublic() + _amountOfPunks <= maxByWalletPerPublic, "Exceeded max available to purchase");
_safeMint(msg.sender, _amountOfPunks);
incrementRedemptionsPublic(_amountOfPunks);
}
function _punksListMint(uint8 _amountOfPunks, bytes32[] memory _proof) public payable mintIsOpen nonContract nonReentrant {
}
////////////////////
// OWNER FUNCTIONS //
////////////////////
function setMaxByWalletPerPublic(uint8 newMaxByWallet) external onlyOwner {
}
function setMaxByWalletPerPunksSale(uint8 newMaxByWallet) external onlyOwner {
}
function setPunksListMerkleRoot(bytes32 newMerkleRoot_) external onlyOwner {
}
function setStage(Stage _saleState) public onlyOwner {
}
function setReveal(bool _setReveal) public onlyOwner {
}
function setBaseURI(string memory _baseTokenURI) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function reserveMint(address to, uint8 _amountOfPunks) public onlyOwner nonReentrant mintIsOpen{
}
function airdrop(
address[] calldata _addresses,
uint8 _amountOfPunks
) external onlyOwner nonReentrant mintIsOpen {
}
function withdraw() public onlyOwner nonReentrant {
}
function decrease(uint256 _newValue) public onlyOwner nonReentrant mintIsOpen {
}
////////////////////
// OVERRIDES //
////////////////////
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override(ERC721A, IERC721A)
returns (string memory)
{
}
function _startTokenId() internal view virtual override returns (uint256) {
}
/******************** READ ********************/
function numberMinted(address owner) public view returns (uint256) {
}
function nextTokenId() public view returns (uint256) {
}
function baseURI() public view returns (string memory) {
}
function exists(uint256 tokenId) public view returns (bool) {
}
function toString(uint256 x) public pure returns (string memory) {
}
function getOwnershipOf(uint256 index) public view returns (TokenOwnership memory) {
}
function getOwnershipAt(uint256 index) public view returns (TokenOwnership memory) {
}
function totalMinted() public view returns (uint256) {
}
function totalBurned() public view returns (uint256) {
}
function numberBurned(address owner) public view returns (uint256) {
}
function currentPrice() public view returns (uint256) {
}
function getAvailableForMintByCurrentStage(address checkedAddress) public view returns (uint8) {
}
/******************** MODIFIERS ********************/
modifier mintIsOpen() {
}
modifier nonContract() {
}
//////////////////////
// GETTER FUNCTIONS //
//////////////////////
/**
* @notice Unpack and get number of viplist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and punkslist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsVipList() private view returns (uint8) {
}
/**
* @notice Unpack and get number of punkslist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and punkslist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsPunksList() private view returns (uint8) {
}
/**
* @notice Unpack and get number of punkslist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and punkslist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsPublic() private view returns (uint8) {
}
//////////////////////
// HELPER FUNCTIONS //
//////////////////////
/**
* @notice Pack three uint8s (viplist, allowlist and public redemptions) into a single uint24 value
* @return Packed value
* @dev Performs shift and bit operations to pack two uint8s into a single uint24
*/
function packMintRedemptions(
uint8 _vipMintRedemptions,
uint8 _punksListMintRedemptions,
uint8 _publicMintRedemptions
) private pure returns (uint24) {
}
/**
* @notice Unpack a single uint24 value into thr uint8s (vip, punksList and public redemptions)
* @return vipMintRedemptions punksListMintRedemptions publicMintRedemptions Unpacked values
* @dev Performs shift and bit operations to unpack a single uint64 into two uint32s
*/
function unpackMintRedemptions(uint64 _mintRedemptionPack)
private
pure
returns (uint8 vipMintRedemptions, uint8 punksListMintRedemptions, uint8 publicMintRedemptions)
{
}
/**
* @notice Increment number of viplist token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, punkslist and public) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsVipList(uint8 _numToIncrement) private {
}
/**
* @notice Increment number of punkslist token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, punkslist and public redemptions) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsPunksList(uint8 _numToIncrement) private {
}
/**
* @notice Increment number of public token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, punkslist and public) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsPublic(uint8 _numToIncrement) private {
}
/**
* @notice Prevent accidental ETH transfer
*/
fallback() external payable {
}
/**
* @notice Prevent accidental ETH transfer
*/
receive() external payable {
}
}
/**
* Function not implemented
*/
error NotImplemented();
| MINT_PRICE*_amountOfPunks<=msg.value,"Ether value sent is not correct" | 92,265 | MINT_PRICE*_amountOfPunks<=msg.value |
"Exceeded max available to purchase" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.4;
import "../node_modules/@openzeppelin/contracts/access/Ownable.sol";
import "../node_modules/@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "../node_modules/@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "../node_modules/@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "../node_modules/@openzeppelin/contracts/utils/math/SafeMath.sol";
import "./ERC721A.sol";
import "./extensions/ERC721AQueryable.sol";
contract ArbitrumPunks is ERC721A, ERC721AQueryable, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
using SafeMath for uint256;
using Strings for uint256;
uint256 public constant MAX_SUPPLY = 999;
uint256 public constant MAX_SALE_SUPPLY = 999;
uint8 public maxByWalletPerPublic = 4;
uint8 public maxByWalletPerfPunksSale = 2;
uint256 public MINT_PRICE = 0.0088 ether;
uint256 public WL_PRICE = 0.0077 ether;
enum Stage {
SaleClosed,
PunksList,
Public
}
Stage public saleState = Stage.SaleClosed;
string public baseTokenURI;
string public notRevealedUri;
string public baseExtension = ".json";
bool public revealed = false;
bytes32 private _punksListMerkleRoot;
constructor() ERC721A("ArbitrumPunks", "ARBNKS") {}
////////////////////
// MINT FUNCTIONS //
////////////////////
function _publicMint(uint8 _amountOfPunks) public payable mintIsOpen nonContract nonReentrant {
require(totalSupply() + _amountOfPunks <= MAX_SALE_SUPPLY, "Reached Max Supply");
require(MINT_PRICE * _amountOfPunks <= msg.value, "Ether value sent is not correct");
require(saleState == Stage.Public, "Public mint is not open yet!");
require(<FILL_ME>)
_safeMint(msg.sender, _amountOfPunks);
incrementRedemptionsPublic(_amountOfPunks);
}
function _punksListMint(uint8 _amountOfPunks, bytes32[] memory _proof) public payable mintIsOpen nonContract nonReentrant {
}
////////////////////
// OWNER FUNCTIONS //
////////////////////
function setMaxByWalletPerPublic(uint8 newMaxByWallet) external onlyOwner {
}
function setMaxByWalletPerPunksSale(uint8 newMaxByWallet) external onlyOwner {
}
function setPunksListMerkleRoot(bytes32 newMerkleRoot_) external onlyOwner {
}
function setStage(Stage _saleState) public onlyOwner {
}
function setReveal(bool _setReveal) public onlyOwner {
}
function setBaseURI(string memory _baseTokenURI) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function reserveMint(address to, uint8 _amountOfPunks) public onlyOwner nonReentrant mintIsOpen{
}
function airdrop(
address[] calldata _addresses,
uint8 _amountOfPunks
) external onlyOwner nonReentrant mintIsOpen {
}
function withdraw() public onlyOwner nonReentrant {
}
function decrease(uint256 _newValue) public onlyOwner nonReentrant mintIsOpen {
}
////////////////////
// OVERRIDES //
////////////////////
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override(ERC721A, IERC721A)
returns (string memory)
{
}
function _startTokenId() internal view virtual override returns (uint256) {
}
/******************** READ ********************/
function numberMinted(address owner) public view returns (uint256) {
}
function nextTokenId() public view returns (uint256) {
}
function baseURI() public view returns (string memory) {
}
function exists(uint256 tokenId) public view returns (bool) {
}
function toString(uint256 x) public pure returns (string memory) {
}
function getOwnershipOf(uint256 index) public view returns (TokenOwnership memory) {
}
function getOwnershipAt(uint256 index) public view returns (TokenOwnership memory) {
}
function totalMinted() public view returns (uint256) {
}
function totalBurned() public view returns (uint256) {
}
function numberBurned(address owner) public view returns (uint256) {
}
function currentPrice() public view returns (uint256) {
}
function getAvailableForMintByCurrentStage(address checkedAddress) public view returns (uint8) {
}
/******************** MODIFIERS ********************/
modifier mintIsOpen() {
}
modifier nonContract() {
}
//////////////////////
// GETTER FUNCTIONS //
//////////////////////
/**
* @notice Unpack and get number of viplist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and punkslist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsVipList() private view returns (uint8) {
}
/**
* @notice Unpack and get number of punkslist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and punkslist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsPunksList() private view returns (uint8) {
}
/**
* @notice Unpack and get number of punkslist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and punkslist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsPublic() private view returns (uint8) {
}
//////////////////////
// HELPER FUNCTIONS //
//////////////////////
/**
* @notice Pack three uint8s (viplist, allowlist and public redemptions) into a single uint24 value
* @return Packed value
* @dev Performs shift and bit operations to pack two uint8s into a single uint24
*/
function packMintRedemptions(
uint8 _vipMintRedemptions,
uint8 _punksListMintRedemptions,
uint8 _publicMintRedemptions
) private pure returns (uint24) {
}
/**
* @notice Unpack a single uint24 value into thr uint8s (vip, punksList and public redemptions)
* @return vipMintRedemptions punksListMintRedemptions publicMintRedemptions Unpacked values
* @dev Performs shift and bit operations to unpack a single uint64 into two uint32s
*/
function unpackMintRedemptions(uint64 _mintRedemptionPack)
private
pure
returns (uint8 vipMintRedemptions, uint8 punksListMintRedemptions, uint8 publicMintRedemptions)
{
}
/**
* @notice Increment number of viplist token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, punkslist and public) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsVipList(uint8 _numToIncrement) private {
}
/**
* @notice Increment number of punkslist token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, punkslist and public redemptions) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsPunksList(uint8 _numToIncrement) private {
}
/**
* @notice Increment number of public token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, punkslist and public) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsPublic(uint8 _numToIncrement) private {
}
/**
* @notice Prevent accidental ETH transfer
*/
fallback() external payable {
}
/**
* @notice Prevent accidental ETH transfer
*/
receive() external payable {
}
}
/**
* Function not implemented
*/
error NotImplemented();
| getRedemptionsPublic()+_amountOfPunks<=maxByWalletPerPublic,"Exceeded max available to purchase" | 92,265 | getRedemptionsPublic()+_amountOfPunks<=maxByWalletPerPublic |
"Ether value sent is not correct" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.4;
import "../node_modules/@openzeppelin/contracts/access/Ownable.sol";
import "../node_modules/@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "../node_modules/@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "../node_modules/@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "../node_modules/@openzeppelin/contracts/utils/math/SafeMath.sol";
import "./ERC721A.sol";
import "./extensions/ERC721AQueryable.sol";
contract ArbitrumPunks is ERC721A, ERC721AQueryable, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
using SafeMath for uint256;
using Strings for uint256;
uint256 public constant MAX_SUPPLY = 999;
uint256 public constant MAX_SALE_SUPPLY = 999;
uint8 public maxByWalletPerPublic = 4;
uint8 public maxByWalletPerfPunksSale = 2;
uint256 public MINT_PRICE = 0.0088 ether;
uint256 public WL_PRICE = 0.0077 ether;
enum Stage {
SaleClosed,
PunksList,
Public
}
Stage public saleState = Stage.SaleClosed;
string public baseTokenURI;
string public notRevealedUri;
string public baseExtension = ".json";
bool public revealed = false;
bytes32 private _punksListMerkleRoot;
constructor() ERC721A("ArbitrumPunks", "ARBNKS") {}
////////////////////
// MINT FUNCTIONS //
////////////////////
function _publicMint(uint8 _amountOfPunks) public payable mintIsOpen nonContract nonReentrant {
}
function _punksListMint(uint8 _amountOfPunks, bytes32[] memory _proof) public payable mintIsOpen nonContract nonReentrant {
require(totalSupply() + _amountOfPunks <= MAX_SALE_SUPPLY, "Reached Max WL Supply");
require(<FILL_ME>)
require(saleState == Stage.PunksList, "PunksList mint is not open yet!");
require(getRedemptionsPunksList() + _amountOfPunks <= maxByWalletPerfPunksSale, "Exceeded max available to purchase");
if (saleState == Stage.PunksList) {
require(_punksListMerkleRoot != "", "Punks Claim merkle tree not set. This address is not allowed to mint");
require(MerkleProof.verify(_proof, _punksListMerkleRoot,
keccak256(abi.encodePacked(msg.sender))),
"PunksList claim validation failed.");
incrementRedemptionsPunksList(_amountOfPunks);
_safeMint(msg.sender, _amountOfPunks);
}
}
////////////////////
// OWNER FUNCTIONS //
////////////////////
function setMaxByWalletPerPublic(uint8 newMaxByWallet) external onlyOwner {
}
function setMaxByWalletPerPunksSale(uint8 newMaxByWallet) external onlyOwner {
}
function setPunksListMerkleRoot(bytes32 newMerkleRoot_) external onlyOwner {
}
function setStage(Stage _saleState) public onlyOwner {
}
function setReveal(bool _setReveal) public onlyOwner {
}
function setBaseURI(string memory _baseTokenURI) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function reserveMint(address to, uint8 _amountOfPunks) public onlyOwner nonReentrant mintIsOpen{
}
function airdrop(
address[] calldata _addresses,
uint8 _amountOfPunks
) external onlyOwner nonReentrant mintIsOpen {
}
function withdraw() public onlyOwner nonReentrant {
}
function decrease(uint256 _newValue) public onlyOwner nonReentrant mintIsOpen {
}
////////////////////
// OVERRIDES //
////////////////////
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override(ERC721A, IERC721A)
returns (string memory)
{
}
function _startTokenId() internal view virtual override returns (uint256) {
}
/******************** READ ********************/
function numberMinted(address owner) public view returns (uint256) {
}
function nextTokenId() public view returns (uint256) {
}
function baseURI() public view returns (string memory) {
}
function exists(uint256 tokenId) public view returns (bool) {
}
function toString(uint256 x) public pure returns (string memory) {
}
function getOwnershipOf(uint256 index) public view returns (TokenOwnership memory) {
}
function getOwnershipAt(uint256 index) public view returns (TokenOwnership memory) {
}
function totalMinted() public view returns (uint256) {
}
function totalBurned() public view returns (uint256) {
}
function numberBurned(address owner) public view returns (uint256) {
}
function currentPrice() public view returns (uint256) {
}
function getAvailableForMintByCurrentStage(address checkedAddress) public view returns (uint8) {
}
/******************** MODIFIERS ********************/
modifier mintIsOpen() {
}
modifier nonContract() {
}
//////////////////////
// GETTER FUNCTIONS //
//////////////////////
/**
* @notice Unpack and get number of viplist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and punkslist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsVipList() private view returns (uint8) {
}
/**
* @notice Unpack and get number of punkslist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and punkslist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsPunksList() private view returns (uint8) {
}
/**
* @notice Unpack and get number of punkslist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and punkslist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsPublic() private view returns (uint8) {
}
//////////////////////
// HELPER FUNCTIONS //
//////////////////////
/**
* @notice Pack three uint8s (viplist, allowlist and public redemptions) into a single uint24 value
* @return Packed value
* @dev Performs shift and bit operations to pack two uint8s into a single uint24
*/
function packMintRedemptions(
uint8 _vipMintRedemptions,
uint8 _punksListMintRedemptions,
uint8 _publicMintRedemptions
) private pure returns (uint24) {
}
/**
* @notice Unpack a single uint24 value into thr uint8s (vip, punksList and public redemptions)
* @return vipMintRedemptions punksListMintRedemptions publicMintRedemptions Unpacked values
* @dev Performs shift and bit operations to unpack a single uint64 into two uint32s
*/
function unpackMintRedemptions(uint64 _mintRedemptionPack)
private
pure
returns (uint8 vipMintRedemptions, uint8 punksListMintRedemptions, uint8 publicMintRedemptions)
{
}
/**
* @notice Increment number of viplist token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, punkslist and public) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsVipList(uint8 _numToIncrement) private {
}
/**
* @notice Increment number of punkslist token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, punkslist and public redemptions) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsPunksList(uint8 _numToIncrement) private {
}
/**
* @notice Increment number of public token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, punkslist and public) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsPublic(uint8 _numToIncrement) private {
}
/**
* @notice Prevent accidental ETH transfer
*/
fallback() external payable {
}
/**
* @notice Prevent accidental ETH transfer
*/
receive() external payable {
}
}
/**
* Function not implemented
*/
error NotImplemented();
| WL_PRICE*_amountOfPunks<=msg.value,"Ether value sent is not correct" | 92,265 | WL_PRICE*_amountOfPunks<=msg.value |
"Exceeded max available to purchase" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.4;
import "../node_modules/@openzeppelin/contracts/access/Ownable.sol";
import "../node_modules/@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "../node_modules/@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "../node_modules/@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "../node_modules/@openzeppelin/contracts/utils/math/SafeMath.sol";
import "./ERC721A.sol";
import "./extensions/ERC721AQueryable.sol";
contract ArbitrumPunks is ERC721A, ERC721AQueryable, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
using SafeMath for uint256;
using Strings for uint256;
uint256 public constant MAX_SUPPLY = 999;
uint256 public constant MAX_SALE_SUPPLY = 999;
uint8 public maxByWalletPerPublic = 4;
uint8 public maxByWalletPerfPunksSale = 2;
uint256 public MINT_PRICE = 0.0088 ether;
uint256 public WL_PRICE = 0.0077 ether;
enum Stage {
SaleClosed,
PunksList,
Public
}
Stage public saleState = Stage.SaleClosed;
string public baseTokenURI;
string public notRevealedUri;
string public baseExtension = ".json";
bool public revealed = false;
bytes32 private _punksListMerkleRoot;
constructor() ERC721A("ArbitrumPunks", "ARBNKS") {}
////////////////////
// MINT FUNCTIONS //
////////////////////
function _publicMint(uint8 _amountOfPunks) public payable mintIsOpen nonContract nonReentrant {
}
function _punksListMint(uint8 _amountOfPunks, bytes32[] memory _proof) public payable mintIsOpen nonContract nonReentrant {
require(totalSupply() + _amountOfPunks <= MAX_SALE_SUPPLY, "Reached Max WL Supply");
require(WL_PRICE * _amountOfPunks <= msg.value, "Ether value sent is not correct");
require(saleState == Stage.PunksList, "PunksList mint is not open yet!");
require(<FILL_ME>)
if (saleState == Stage.PunksList) {
require(_punksListMerkleRoot != "", "Punks Claim merkle tree not set. This address is not allowed to mint");
require(MerkleProof.verify(_proof, _punksListMerkleRoot,
keccak256(abi.encodePacked(msg.sender))),
"PunksList claim validation failed.");
incrementRedemptionsPunksList(_amountOfPunks);
_safeMint(msg.sender, _amountOfPunks);
}
}
////////////////////
// OWNER FUNCTIONS //
////////////////////
function setMaxByWalletPerPublic(uint8 newMaxByWallet) external onlyOwner {
}
function setMaxByWalletPerPunksSale(uint8 newMaxByWallet) external onlyOwner {
}
function setPunksListMerkleRoot(bytes32 newMerkleRoot_) external onlyOwner {
}
function setStage(Stage _saleState) public onlyOwner {
}
function setReveal(bool _setReveal) public onlyOwner {
}
function setBaseURI(string memory _baseTokenURI) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function reserveMint(address to, uint8 _amountOfPunks) public onlyOwner nonReentrant mintIsOpen{
}
function airdrop(
address[] calldata _addresses,
uint8 _amountOfPunks
) external onlyOwner nonReentrant mintIsOpen {
}
function withdraw() public onlyOwner nonReentrant {
}
function decrease(uint256 _newValue) public onlyOwner nonReentrant mintIsOpen {
}
////////////////////
// OVERRIDES //
////////////////////
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override(ERC721A, IERC721A)
returns (string memory)
{
}
function _startTokenId() internal view virtual override returns (uint256) {
}
/******************** READ ********************/
function numberMinted(address owner) public view returns (uint256) {
}
function nextTokenId() public view returns (uint256) {
}
function baseURI() public view returns (string memory) {
}
function exists(uint256 tokenId) public view returns (bool) {
}
function toString(uint256 x) public pure returns (string memory) {
}
function getOwnershipOf(uint256 index) public view returns (TokenOwnership memory) {
}
function getOwnershipAt(uint256 index) public view returns (TokenOwnership memory) {
}
function totalMinted() public view returns (uint256) {
}
function totalBurned() public view returns (uint256) {
}
function numberBurned(address owner) public view returns (uint256) {
}
function currentPrice() public view returns (uint256) {
}
function getAvailableForMintByCurrentStage(address checkedAddress) public view returns (uint8) {
}
/******************** MODIFIERS ********************/
modifier mintIsOpen() {
}
modifier nonContract() {
}
//////////////////////
// GETTER FUNCTIONS //
//////////////////////
/**
* @notice Unpack and get number of viplist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and punkslist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsVipList() private view returns (uint8) {
}
/**
* @notice Unpack and get number of punkslist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and punkslist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsPunksList() private view returns (uint8) {
}
/**
* @notice Unpack and get number of punkslist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and punkslist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsPublic() private view returns (uint8) {
}
//////////////////////
// HELPER FUNCTIONS //
//////////////////////
/**
* @notice Pack three uint8s (viplist, allowlist and public redemptions) into a single uint24 value
* @return Packed value
* @dev Performs shift and bit operations to pack two uint8s into a single uint24
*/
function packMintRedemptions(
uint8 _vipMintRedemptions,
uint8 _punksListMintRedemptions,
uint8 _publicMintRedemptions
) private pure returns (uint24) {
}
/**
* @notice Unpack a single uint24 value into thr uint8s (vip, punksList and public redemptions)
* @return vipMintRedemptions punksListMintRedemptions publicMintRedemptions Unpacked values
* @dev Performs shift and bit operations to unpack a single uint64 into two uint32s
*/
function unpackMintRedemptions(uint64 _mintRedemptionPack)
private
pure
returns (uint8 vipMintRedemptions, uint8 punksListMintRedemptions, uint8 publicMintRedemptions)
{
}
/**
* @notice Increment number of viplist token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, punkslist and public) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsVipList(uint8 _numToIncrement) private {
}
/**
* @notice Increment number of punkslist token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, punkslist and public redemptions) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsPunksList(uint8 _numToIncrement) private {
}
/**
* @notice Increment number of public token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, punkslist and public) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsPublic(uint8 _numToIncrement) private {
}
/**
* @notice Prevent accidental ETH transfer
*/
fallback() external payable {
}
/**
* @notice Prevent accidental ETH transfer
*/
receive() external payable {
}
}
/**
* Function not implemented
*/
error NotImplemented();
| getRedemptionsPunksList()+_amountOfPunks<=maxByWalletPerfPunksSale,"Exceeded max available to purchase" | 92,265 | getRedemptionsPunksList()+_amountOfPunks<=maxByWalletPerfPunksSale |
"Punks Claim merkle tree not set. This address is not allowed to mint" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.4;
import "../node_modules/@openzeppelin/contracts/access/Ownable.sol";
import "../node_modules/@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "../node_modules/@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "../node_modules/@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "../node_modules/@openzeppelin/contracts/utils/math/SafeMath.sol";
import "./ERC721A.sol";
import "./extensions/ERC721AQueryable.sol";
contract ArbitrumPunks is ERC721A, ERC721AQueryable, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
using SafeMath for uint256;
using Strings for uint256;
uint256 public constant MAX_SUPPLY = 999;
uint256 public constant MAX_SALE_SUPPLY = 999;
uint8 public maxByWalletPerPublic = 4;
uint8 public maxByWalletPerfPunksSale = 2;
uint256 public MINT_PRICE = 0.0088 ether;
uint256 public WL_PRICE = 0.0077 ether;
enum Stage {
SaleClosed,
PunksList,
Public
}
Stage public saleState = Stage.SaleClosed;
string public baseTokenURI;
string public notRevealedUri;
string public baseExtension = ".json";
bool public revealed = false;
bytes32 private _punksListMerkleRoot;
constructor() ERC721A("ArbitrumPunks", "ARBNKS") {}
////////////////////
// MINT FUNCTIONS //
////////////////////
function _publicMint(uint8 _amountOfPunks) public payable mintIsOpen nonContract nonReentrant {
}
function _punksListMint(uint8 _amountOfPunks, bytes32[] memory _proof) public payable mintIsOpen nonContract nonReentrant {
require(totalSupply() + _amountOfPunks <= MAX_SALE_SUPPLY, "Reached Max WL Supply");
require(WL_PRICE * _amountOfPunks <= msg.value, "Ether value sent is not correct");
require(saleState == Stage.PunksList, "PunksList mint is not open yet!");
require(getRedemptionsPunksList() + _amountOfPunks <= maxByWalletPerfPunksSale, "Exceeded max available to purchase");
if (saleState == Stage.PunksList) {
require(<FILL_ME>)
require(MerkleProof.verify(_proof, _punksListMerkleRoot,
keccak256(abi.encodePacked(msg.sender))),
"PunksList claim validation failed.");
incrementRedemptionsPunksList(_amountOfPunks);
_safeMint(msg.sender, _amountOfPunks);
}
}
////////////////////
// OWNER FUNCTIONS //
////////////////////
function setMaxByWalletPerPublic(uint8 newMaxByWallet) external onlyOwner {
}
function setMaxByWalletPerPunksSale(uint8 newMaxByWallet) external onlyOwner {
}
function setPunksListMerkleRoot(bytes32 newMerkleRoot_) external onlyOwner {
}
function setStage(Stage _saleState) public onlyOwner {
}
function setReveal(bool _setReveal) public onlyOwner {
}
function setBaseURI(string memory _baseTokenURI) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function reserveMint(address to, uint8 _amountOfPunks) public onlyOwner nonReentrant mintIsOpen{
}
function airdrop(
address[] calldata _addresses,
uint8 _amountOfPunks
) external onlyOwner nonReentrant mintIsOpen {
}
function withdraw() public onlyOwner nonReentrant {
}
function decrease(uint256 _newValue) public onlyOwner nonReentrant mintIsOpen {
}
////////////////////
// OVERRIDES //
////////////////////
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override(ERC721A, IERC721A)
returns (string memory)
{
}
function _startTokenId() internal view virtual override returns (uint256) {
}
/******************** READ ********************/
function numberMinted(address owner) public view returns (uint256) {
}
function nextTokenId() public view returns (uint256) {
}
function baseURI() public view returns (string memory) {
}
function exists(uint256 tokenId) public view returns (bool) {
}
function toString(uint256 x) public pure returns (string memory) {
}
function getOwnershipOf(uint256 index) public view returns (TokenOwnership memory) {
}
function getOwnershipAt(uint256 index) public view returns (TokenOwnership memory) {
}
function totalMinted() public view returns (uint256) {
}
function totalBurned() public view returns (uint256) {
}
function numberBurned(address owner) public view returns (uint256) {
}
function currentPrice() public view returns (uint256) {
}
function getAvailableForMintByCurrentStage(address checkedAddress) public view returns (uint8) {
}
/******************** MODIFIERS ********************/
modifier mintIsOpen() {
}
modifier nonContract() {
}
//////////////////////
// GETTER FUNCTIONS //
//////////////////////
/**
* @notice Unpack and get number of viplist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and punkslist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsVipList() private view returns (uint8) {
}
/**
* @notice Unpack and get number of punkslist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and punkslist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsPunksList() private view returns (uint8) {
}
/**
* @notice Unpack and get number of punkslist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and punkslist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsPublic() private view returns (uint8) {
}
//////////////////////
// HELPER FUNCTIONS //
//////////////////////
/**
* @notice Pack three uint8s (viplist, allowlist and public redemptions) into a single uint24 value
* @return Packed value
* @dev Performs shift and bit operations to pack two uint8s into a single uint24
*/
function packMintRedemptions(
uint8 _vipMintRedemptions,
uint8 _punksListMintRedemptions,
uint8 _publicMintRedemptions
) private pure returns (uint24) {
}
/**
* @notice Unpack a single uint24 value into thr uint8s (vip, punksList and public redemptions)
* @return vipMintRedemptions punksListMintRedemptions publicMintRedemptions Unpacked values
* @dev Performs shift and bit operations to unpack a single uint64 into two uint32s
*/
function unpackMintRedemptions(uint64 _mintRedemptionPack)
private
pure
returns (uint8 vipMintRedemptions, uint8 punksListMintRedemptions, uint8 publicMintRedemptions)
{
}
/**
* @notice Increment number of viplist token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, punkslist and public) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsVipList(uint8 _numToIncrement) private {
}
/**
* @notice Increment number of punkslist token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, punkslist and public redemptions) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsPunksList(uint8 _numToIncrement) private {
}
/**
* @notice Increment number of public token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, punkslist and public) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsPublic(uint8 _numToIncrement) private {
}
/**
* @notice Prevent accidental ETH transfer
*/
fallback() external payable {
}
/**
* @notice Prevent accidental ETH transfer
*/
receive() external payable {
}
}
/**
* Function not implemented
*/
error NotImplemented();
| _punksListMerkleRoot!="","Punks Claim merkle tree not set. This address is not allowed to mint" | 92,265 | _punksListMerkleRoot!="" |
"PunksList claim validation failed." | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.4;
import "../node_modules/@openzeppelin/contracts/access/Ownable.sol";
import "../node_modules/@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "../node_modules/@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "../node_modules/@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "../node_modules/@openzeppelin/contracts/utils/math/SafeMath.sol";
import "./ERC721A.sol";
import "./extensions/ERC721AQueryable.sol";
contract ArbitrumPunks is ERC721A, ERC721AQueryable, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
using SafeMath for uint256;
using Strings for uint256;
uint256 public constant MAX_SUPPLY = 999;
uint256 public constant MAX_SALE_SUPPLY = 999;
uint8 public maxByWalletPerPublic = 4;
uint8 public maxByWalletPerfPunksSale = 2;
uint256 public MINT_PRICE = 0.0088 ether;
uint256 public WL_PRICE = 0.0077 ether;
enum Stage {
SaleClosed,
PunksList,
Public
}
Stage public saleState = Stage.SaleClosed;
string public baseTokenURI;
string public notRevealedUri;
string public baseExtension = ".json";
bool public revealed = false;
bytes32 private _punksListMerkleRoot;
constructor() ERC721A("ArbitrumPunks", "ARBNKS") {}
////////////////////
// MINT FUNCTIONS //
////////////////////
function _publicMint(uint8 _amountOfPunks) public payable mintIsOpen nonContract nonReentrant {
}
function _punksListMint(uint8 _amountOfPunks, bytes32[] memory _proof) public payable mintIsOpen nonContract nonReentrant {
require(totalSupply() + _amountOfPunks <= MAX_SALE_SUPPLY, "Reached Max WL Supply");
require(WL_PRICE * _amountOfPunks <= msg.value, "Ether value sent is not correct");
require(saleState == Stage.PunksList, "PunksList mint is not open yet!");
require(getRedemptionsPunksList() + _amountOfPunks <= maxByWalletPerfPunksSale, "Exceeded max available to purchase");
if (saleState == Stage.PunksList) {
require(_punksListMerkleRoot != "", "Punks Claim merkle tree not set. This address is not allowed to mint");
require(<FILL_ME>)
incrementRedemptionsPunksList(_amountOfPunks);
_safeMint(msg.sender, _amountOfPunks);
}
}
////////////////////
// OWNER FUNCTIONS //
////////////////////
function setMaxByWalletPerPublic(uint8 newMaxByWallet) external onlyOwner {
}
function setMaxByWalletPerPunksSale(uint8 newMaxByWallet) external onlyOwner {
}
function setPunksListMerkleRoot(bytes32 newMerkleRoot_) external onlyOwner {
}
function setStage(Stage _saleState) public onlyOwner {
}
function setReveal(bool _setReveal) public onlyOwner {
}
function setBaseURI(string memory _baseTokenURI) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function reserveMint(address to, uint8 _amountOfPunks) public onlyOwner nonReentrant mintIsOpen{
}
function airdrop(
address[] calldata _addresses,
uint8 _amountOfPunks
) external onlyOwner nonReentrant mintIsOpen {
}
function withdraw() public onlyOwner nonReentrant {
}
function decrease(uint256 _newValue) public onlyOwner nonReentrant mintIsOpen {
}
////////////////////
// OVERRIDES //
////////////////////
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override(ERC721A, IERC721A)
returns (string memory)
{
}
function _startTokenId() internal view virtual override returns (uint256) {
}
/******************** READ ********************/
function numberMinted(address owner) public view returns (uint256) {
}
function nextTokenId() public view returns (uint256) {
}
function baseURI() public view returns (string memory) {
}
function exists(uint256 tokenId) public view returns (bool) {
}
function toString(uint256 x) public pure returns (string memory) {
}
function getOwnershipOf(uint256 index) public view returns (TokenOwnership memory) {
}
function getOwnershipAt(uint256 index) public view returns (TokenOwnership memory) {
}
function totalMinted() public view returns (uint256) {
}
function totalBurned() public view returns (uint256) {
}
function numberBurned(address owner) public view returns (uint256) {
}
function currentPrice() public view returns (uint256) {
}
function getAvailableForMintByCurrentStage(address checkedAddress) public view returns (uint8) {
}
/******************** MODIFIERS ********************/
modifier mintIsOpen() {
}
modifier nonContract() {
}
//////////////////////
// GETTER FUNCTIONS //
//////////////////////
/**
* @notice Unpack and get number of viplist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and punkslist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsVipList() private view returns (uint8) {
}
/**
* @notice Unpack and get number of punkslist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and punkslist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsPunksList() private view returns (uint8) {
}
/**
* @notice Unpack and get number of punkslist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and punkslist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsPublic() private view returns (uint8) {
}
//////////////////////
// HELPER FUNCTIONS //
//////////////////////
/**
* @notice Pack three uint8s (viplist, allowlist and public redemptions) into a single uint24 value
* @return Packed value
* @dev Performs shift and bit operations to pack two uint8s into a single uint24
*/
function packMintRedemptions(
uint8 _vipMintRedemptions,
uint8 _punksListMintRedemptions,
uint8 _publicMintRedemptions
) private pure returns (uint24) {
}
/**
* @notice Unpack a single uint24 value into thr uint8s (vip, punksList and public redemptions)
* @return vipMintRedemptions punksListMintRedemptions publicMintRedemptions Unpacked values
* @dev Performs shift and bit operations to unpack a single uint64 into two uint32s
*/
function unpackMintRedemptions(uint64 _mintRedemptionPack)
private
pure
returns (uint8 vipMintRedemptions, uint8 punksListMintRedemptions, uint8 publicMintRedemptions)
{
}
/**
* @notice Increment number of viplist token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, punkslist and public) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsVipList(uint8 _numToIncrement) private {
}
/**
* @notice Increment number of punkslist token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, punkslist and public redemptions) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsPunksList(uint8 _numToIncrement) private {
}
/**
* @notice Increment number of public token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, punkslist and public) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsPublic(uint8 _numToIncrement) private {
}
/**
* @notice Prevent accidental ETH transfer
*/
fallback() external payable {
}
/**
* @notice Prevent accidental ETH transfer
*/
receive() external payable {
}
}
/**
* Function not implemented
*/
error NotImplemented();
| MerkleProof.verify(_proof,_punksListMerkleRoot,keccak256(abi.encodePacked(msg.sender))),"PunksList claim validation failed." | 92,265 | MerkleProof.verify(_proof,_punksListMerkleRoot,keccak256(abi.encodePacked(msg.sender))) |
"Reached Max Supply" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.4;
import "../node_modules/@openzeppelin/contracts/access/Ownable.sol";
import "../node_modules/@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "../node_modules/@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "../node_modules/@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "../node_modules/@openzeppelin/contracts/utils/math/SafeMath.sol";
import "./ERC721A.sol";
import "./extensions/ERC721AQueryable.sol";
contract ArbitrumPunks is ERC721A, ERC721AQueryable, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
using SafeMath for uint256;
using Strings for uint256;
uint256 public constant MAX_SUPPLY = 999;
uint256 public constant MAX_SALE_SUPPLY = 999;
uint8 public maxByWalletPerPublic = 4;
uint8 public maxByWalletPerfPunksSale = 2;
uint256 public MINT_PRICE = 0.0088 ether;
uint256 public WL_PRICE = 0.0077 ether;
enum Stage {
SaleClosed,
PunksList,
Public
}
Stage public saleState = Stage.SaleClosed;
string public baseTokenURI;
string public notRevealedUri;
string public baseExtension = ".json";
bool public revealed = false;
bytes32 private _punksListMerkleRoot;
constructor() ERC721A("ArbitrumPunks", "ARBNKS") {}
////////////////////
// MINT FUNCTIONS //
////////////////////
function _publicMint(uint8 _amountOfPunks) public payable mintIsOpen nonContract nonReentrant {
}
function _punksListMint(uint8 _amountOfPunks, bytes32[] memory _proof) public payable mintIsOpen nonContract nonReentrant {
}
////////////////////
// OWNER FUNCTIONS //
////////////////////
function setMaxByWalletPerPublic(uint8 newMaxByWallet) external onlyOwner {
}
function setMaxByWalletPerPunksSale(uint8 newMaxByWallet) external onlyOwner {
}
function setPunksListMerkleRoot(bytes32 newMerkleRoot_) external onlyOwner {
}
function setStage(Stage _saleState) public onlyOwner {
}
function setReveal(bool _setReveal) public onlyOwner {
}
function setBaseURI(string memory _baseTokenURI) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function reserveMint(address to, uint8 _amountOfPunks) public onlyOwner nonReentrant mintIsOpen{
require(<FILL_ME>)
_safeMint(to, _amountOfPunks);
}
function airdrop(
address[] calldata _addresses,
uint8 _amountOfPunks
) external onlyOwner nonReentrant mintIsOpen {
}
function withdraw() public onlyOwner nonReentrant {
}
function decrease(uint256 _newValue) public onlyOwner nonReentrant mintIsOpen {
}
////////////////////
// OVERRIDES //
////////////////////
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override(ERC721A, IERC721A)
returns (string memory)
{
}
function _startTokenId() internal view virtual override returns (uint256) {
}
/******************** READ ********************/
function numberMinted(address owner) public view returns (uint256) {
}
function nextTokenId() public view returns (uint256) {
}
function baseURI() public view returns (string memory) {
}
function exists(uint256 tokenId) public view returns (bool) {
}
function toString(uint256 x) public pure returns (string memory) {
}
function getOwnershipOf(uint256 index) public view returns (TokenOwnership memory) {
}
function getOwnershipAt(uint256 index) public view returns (TokenOwnership memory) {
}
function totalMinted() public view returns (uint256) {
}
function totalBurned() public view returns (uint256) {
}
function numberBurned(address owner) public view returns (uint256) {
}
function currentPrice() public view returns (uint256) {
}
function getAvailableForMintByCurrentStage(address checkedAddress) public view returns (uint8) {
}
/******************** MODIFIERS ********************/
modifier mintIsOpen() {
}
modifier nonContract() {
}
//////////////////////
// GETTER FUNCTIONS //
//////////////////////
/**
* @notice Unpack and get number of viplist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and punkslist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsVipList() private view returns (uint8) {
}
/**
* @notice Unpack and get number of punkslist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and punkslist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsPunksList() private view returns (uint8) {
}
/**
* @notice Unpack and get number of punkslist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and punkslist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsPublic() private view returns (uint8) {
}
//////////////////////
// HELPER FUNCTIONS //
//////////////////////
/**
* @notice Pack three uint8s (viplist, allowlist and public redemptions) into a single uint24 value
* @return Packed value
* @dev Performs shift and bit operations to pack two uint8s into a single uint24
*/
function packMintRedemptions(
uint8 _vipMintRedemptions,
uint8 _punksListMintRedemptions,
uint8 _publicMintRedemptions
) private pure returns (uint24) {
}
/**
* @notice Unpack a single uint24 value into thr uint8s (vip, punksList and public redemptions)
* @return vipMintRedemptions punksListMintRedemptions publicMintRedemptions Unpacked values
* @dev Performs shift and bit operations to unpack a single uint64 into two uint32s
*/
function unpackMintRedemptions(uint64 _mintRedemptionPack)
private
pure
returns (uint8 vipMintRedemptions, uint8 punksListMintRedemptions, uint8 publicMintRedemptions)
{
}
/**
* @notice Increment number of viplist token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, punkslist and public) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsVipList(uint8 _numToIncrement) private {
}
/**
* @notice Increment number of punkslist token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, punkslist and public redemptions) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsPunksList(uint8 _numToIncrement) private {
}
/**
* @notice Increment number of public token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, punkslist and public) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsPublic(uint8 _numToIncrement) private {
}
/**
* @notice Prevent accidental ETH transfer
*/
fallback() external payable {
}
/**
* @notice Prevent accidental ETH transfer
*/
receive() external payable {
}
}
/**
* Function not implemented
*/
error NotImplemented();
| totalSupply()+_amountOfPunks<=MAX_SUPPLY,"Reached Max Supply" | 92,265 | totalSupply()+_amountOfPunks<=MAX_SUPPLY |
"Reached Max Supply" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.4;
import "../node_modules/@openzeppelin/contracts/access/Ownable.sol";
import "../node_modules/@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "../node_modules/@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "../node_modules/@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "../node_modules/@openzeppelin/contracts/utils/math/SafeMath.sol";
import "./ERC721A.sol";
import "./extensions/ERC721AQueryable.sol";
contract ArbitrumPunks is ERC721A, ERC721AQueryable, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
using SafeMath for uint256;
using Strings for uint256;
uint256 public constant MAX_SUPPLY = 999;
uint256 public constant MAX_SALE_SUPPLY = 999;
uint8 public maxByWalletPerPublic = 4;
uint8 public maxByWalletPerfPunksSale = 2;
uint256 public MINT_PRICE = 0.0088 ether;
uint256 public WL_PRICE = 0.0077 ether;
enum Stage {
SaleClosed,
PunksList,
Public
}
Stage public saleState = Stage.SaleClosed;
string public baseTokenURI;
string public notRevealedUri;
string public baseExtension = ".json";
bool public revealed = false;
bytes32 private _punksListMerkleRoot;
constructor() ERC721A("ArbitrumPunks", "ARBNKS") {}
////////////////////
// MINT FUNCTIONS //
////////////////////
function _publicMint(uint8 _amountOfPunks) public payable mintIsOpen nonContract nonReentrant {
}
function _punksListMint(uint8 _amountOfPunks, bytes32[] memory _proof) public payable mintIsOpen nonContract nonReentrant {
}
////////////////////
// OWNER FUNCTIONS //
////////////////////
function setMaxByWalletPerPublic(uint8 newMaxByWallet) external onlyOwner {
}
function setMaxByWalletPerPunksSale(uint8 newMaxByWallet) external onlyOwner {
}
function setPunksListMerkleRoot(bytes32 newMerkleRoot_) external onlyOwner {
}
function setStage(Stage _saleState) public onlyOwner {
}
function setReveal(bool _setReveal) public onlyOwner {
}
function setBaseURI(string memory _baseTokenURI) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function reserveMint(address to, uint8 _amountOfPunks) public onlyOwner nonReentrant mintIsOpen{
}
function airdrop(
address[] calldata _addresses,
uint8 _amountOfPunks
) external onlyOwner nonReentrant mintIsOpen {
require(<FILL_ME>)
for (uint256 i = 0; i < _addresses.length; i++) {
_safeMint(_addresses[i], _amountOfPunks);
}
}
function withdraw() public onlyOwner nonReentrant {
}
function decrease(uint256 _newValue) public onlyOwner nonReentrant mintIsOpen {
}
////////////////////
// OVERRIDES //
////////////////////
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override(ERC721A, IERC721A)
returns (string memory)
{
}
function _startTokenId() internal view virtual override returns (uint256) {
}
/******************** READ ********************/
function numberMinted(address owner) public view returns (uint256) {
}
function nextTokenId() public view returns (uint256) {
}
function baseURI() public view returns (string memory) {
}
function exists(uint256 tokenId) public view returns (bool) {
}
function toString(uint256 x) public pure returns (string memory) {
}
function getOwnershipOf(uint256 index) public view returns (TokenOwnership memory) {
}
function getOwnershipAt(uint256 index) public view returns (TokenOwnership memory) {
}
function totalMinted() public view returns (uint256) {
}
function totalBurned() public view returns (uint256) {
}
function numberBurned(address owner) public view returns (uint256) {
}
function currentPrice() public view returns (uint256) {
}
function getAvailableForMintByCurrentStage(address checkedAddress) public view returns (uint8) {
}
/******************** MODIFIERS ********************/
modifier mintIsOpen() {
}
modifier nonContract() {
}
//////////////////////
// GETTER FUNCTIONS //
//////////////////////
/**
* @notice Unpack and get number of viplist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and punkslist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsVipList() private view returns (uint8) {
}
/**
* @notice Unpack and get number of punkslist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and punkslist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsPunksList() private view returns (uint8) {
}
/**
* @notice Unpack and get number of punkslist token mints redeemed by caller
* @return number of allowlist redemptions used
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, public and punkslist redemptions) we need to pack and unpack three uint8s into a single uint24.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function getRedemptionsPublic() private view returns (uint8) {
}
//////////////////////
// HELPER FUNCTIONS //
//////////////////////
/**
* @notice Pack three uint8s (viplist, allowlist and public redemptions) into a single uint24 value
* @return Packed value
* @dev Performs shift and bit operations to pack two uint8s into a single uint24
*/
function packMintRedemptions(
uint8 _vipMintRedemptions,
uint8 _punksListMintRedemptions,
uint8 _publicMintRedemptions
) private pure returns (uint24) {
}
/**
* @notice Unpack a single uint24 value into thr uint8s (vip, punksList and public redemptions)
* @return vipMintRedemptions punksListMintRedemptions publicMintRedemptions Unpacked values
* @dev Performs shift and bit operations to unpack a single uint64 into two uint32s
*/
function unpackMintRedemptions(uint64 _mintRedemptionPack)
private
pure
returns (uint8 vipMintRedemptions, uint8 punksListMintRedemptions, uint8 publicMintRedemptions)
{
}
/**
* @notice Increment number of viplist token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, punkslist and public) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsVipList(uint8 _numToIncrement) private {
}
/**
* @notice Increment number of punkslist token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, punkslist and public redemptions) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsPunksList(uint8 _numToIncrement) private {
}
/**
* @notice Increment number of public token mints redeemed by caller
* @dev We cast the _numToIncrement argument into uint8, which will not be an issue as
* mint quantity should never be greater than 2^8 - 1.
* @dev Number of redemptions are stored in ERC721A auxillary storage, which can help
* remove an extra cold SLOAD and SSTORE operation. Since we're storing two values
* (vip, punkslist and public) we need to pack and unpack two uint8s into a single uint64.
* See https://chiru-labs.github.io/ERC721A/#/erc721a?id=addressdata
*/
function incrementRedemptionsPublic(uint8 _numToIncrement) private {
}
/**
* @notice Prevent accidental ETH transfer
*/
fallback() external payable {
}
/**
* @notice Prevent accidental ETH transfer
*/
receive() external payable {
}
}
/**
* Function not implemented
*/
error NotImplemented();
| totalSupply()+_amountOfPunks*_addresses.length<=MAX_SUPPLY,"Reached Max Supply" | 92,265 | totalSupply()+_amountOfPunks*_addresses.length<=MAX_SUPPLY |
"Exceeds maximum wallet amount." | // SPDX-License-Identifier: MIT
/*
A protocol for sending tokens across rollups and their shared layer-1 network in a quick and trustless manner
Website: https://www.hopeprotocol.org
Telegram: https://t.me/HopeProtocol
Twitter: https://twitter.com/protocol_hope
*/
pragma solidity 0.8.21;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
abstract contract Ownable {
address internal owner;
constructor(address _owner) { }
modifier onlyOwner() { }
function isOwner(address account) public view returns (bool) { }
function renounceOwnership() public onlyOwner { }
function transferOwnership(address payable adr) public onlyOwner { }
event OwnershipTransferred(address owner);
}
interface IUniswapRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
interface IUniswapFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IERC20 {
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract HOPE is IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "HOPE";
string private constant _symbol = "HOPE";
uint8 private constant _decimals = 9;
uint256 private _tSupply = 10 ** 9 * 10 ** _decimals;
IUniswapRouter uniRouterV2;
address public pair;
bool private tradingOpen = false;
bool private swapOpen = true;
bool private inswap;
uint256 private tradeCounts;
uint256 private taxSwapAfter;
uint256 private _swapMaxAmt = ( _tSupply * 1000 ) / 100000;
uint256 private _swapMinAmt = ( _tSupply * 10 ) / 100000;
uint256 private _lpDivi = 0;
uint256 private _mkDivi = 0;
uint256 private _burnDivi = 0;
uint256 private _devDivi = 100;
uint256 private buyFee = 1500;
uint256 private sellFee = 1500;
uint256 private transferFee = 1500;
uint256 private denominator = 10000;
modifier lockEnter { }
address internal developAddress = 0x4AE2A538dDE04165a9DaB8dB530015064923CdFA;
address internal marketAddress = 0x4AE2A538dDE04165a9DaB8dB530015064923CdFA;
address internal lpFeeAddress = 0x4AE2A538dDE04165a9DaB8dB530015064923CdFA;
address internal constant DEAD = 0x000000000000000000000000000000000000dEaD;
uint256 private _maxTrnx = ( _tSupply * 250 ) / 10000;
uint256 private _maxBuy = ( _tSupply * 250 ) / 10000;
uint256 private _maxWallet = ( _tSupply * 250 ) / 10000;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public isExcludeFromFees;
constructor() Ownable(msg.sender) {
}
receive() external payable {}
function name() public pure returns (string memory) { }
function symbol() public pure returns (string memory) { }
function decimals() public pure returns (uint8) { }
function allowance(address owner, address spender) public view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) { }
function totalSupply() public view override returns (uint256) { }
function getOwner() external view override returns (address) { }
function balanceOf(address account) public view override returns (uint256) { }
function transfer(address recipient, uint256 amount) public override returns (bool) { }
function setTransactionRequirements(uint256 _liquidity, uint256 _marketing, uint256 _burn, uint256 _development, uint256 _total, uint256 _sell, uint256 _trans) external onlyOwner {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function startTrading() external onlyOwner { }
function getFinalAmount(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function setTransactionLimits(uint256 _buy, uint256 _sell, uint256 _wallet) external onlyOwner {
}
function shouldSwapTokensInCa(address sender, address recipient, uint256 amount) internal view returns (bool) {
}
function addLiquidity(uint256 tokenAmount, uint256 ETHAmount) private {
}
function getBuySellFees(address sender, address recipient) internal view returns (uint256) {
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount <= balanceOf(sender),"You are trying to transfer more than your balance");
if(!isExcludeFromFees[sender] && !isExcludeFromFees[recipient]){require(tradingOpen, "tradingOpen");}
if(!isExcludeFromFees[sender] && !isExcludeFromFees[recipient] && recipient != address(pair) && recipient != address(DEAD)){
require(<FILL_ME>)}
if(sender != pair){require(amount <= _maxBuy || isExcludeFromFees[sender] || isExcludeFromFees[recipient], "TX Limit Exceeded");}
require(amount <= _maxTrnx || isExcludeFromFees[sender] || isExcludeFromFees[recipient], "TX Limit Exceeded");
if(recipient == pair && !isExcludeFromFees[sender]){tradeCounts += uint256(1);}
if(shouldSwapTokensInCa(sender, recipient, amount)){swapBackTokensInCa(_swapMaxAmt); tradeCounts = uint256(0);}
_balances[sender] = _balances[sender].sub(amount);
uint256 amountReceived = amount;
if (!isExcludeFromFees[sender]) {amountReceived = getFinalAmount(sender, recipient, amount);}
_balances[recipient] = _balances[recipient].add(amountReceived);
emit Transfer(sender, recipient, amountReceived);
}
function swapBackTokensInCa(uint256 tokens) private lockEnter {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
}
| (_balances[recipient].add(amount))<=_maxWallet,"Exceeds maximum wallet amount." | 92,281 | (_balances[recipient].add(amount))<=_maxWallet |
"Not a valid token" | //SPDX-License-Identifier: Unlicensed
pragma solidity 0.8.19;
contract LVMMarket is Ownable {
IUniswapV2Router02 public router;
bool inSwapAndSend;
Fees public fees;
Wallets public wallets;
struct Fees {
uint256 burnFee;
uint256 marketingWalletShare;
uint256 devWalletShare;
uint256 gameWalletShare;
uint256 totalBackupWalletFees;
}
struct Wallets {
address deadWallet;
address marketingWallet;
address devWallet;
address gameWallet;
}
// Boolean determines if a token is allowed
mapping(address => bool) public tokenAllowed;
// determines if token IS a partner token or not
mapping(address => bool) public isPartnerToken;
// If its a partner token, what wallet to send them to
mapping(address => address) public partnerTokenWallet;
uint256 priceOfBuy5 = 6 * 10 ** 6;
uint256 priceOfBuy10 = 11 * 10 ** 6;
uint256 priceOfBuy25 = 26 * 10 ** 6;
uint256 priceOfBuy50 = 51 * 10 ** 6;
uint256 priceOfBuy100 = 101 * 10 ** 6;
uint256 priceOfBuy250 = 251 * 10 ** 6;
uint256 priceOfBuy500 = 501 * 10 ** 6;
receive() external payable {}
modifier lockTheSwap() {
}
constructor() {
}
function Buy50000InGameTokens(address _token) external returns (bool) {
}
function Buy100000InGameTokens(address _token) external returns (bool) {
}
function Buy250000InGameTokens(address _token) external returns (bool) {
}
function Buy500000InGameTokens(address _token) public {
}
function Buy1000000InGameTokens(address _token) external returns (bool) {
}
function Buy2500000InGameTokens(address _token) external returns (bool) {
}
function Buy5000000InGameTokens(address _token) external returns (bool) {
}
function buy(address _token, uint _amount) internal {
// Make sure the token is a valid and allowed token
require(<FILL_ME>)
IERC20 token = IERC20(_token);
// Calculate the amounts to send
uint256 amountToBurn = (_amount * fees.burnFee) / 1000;
uint256 amountToMarketing = (_amount * fees.marketingWalletShare) /
1000;
uint256 amountToDevWallet = (_amount * fees.devWalletShare) / 1000;
uint256 amountToGameWallet = _amount -
amountToBurn -
amountToMarketing -
amountToDevWallet;
// If its a partner token, send to their wallet, if its not, burn
token.transferFrom(
msg.sender,
isPartnerToken[_token]
? partnerTokenWallet[_token]
: wallets.deadWallet,
amountToBurn
);
// Marketing wallet amount
token.transferFrom(
msg.sender,
wallets.marketingWallet,
amountToMarketing
);
// Dev wallet amount
token.transferFrom(msg.sender, wallets.devWallet, amountToDevWallet);
// Game wallet amount
token.transferFrom(msg.sender, wallets.gameWallet, amountToGameWallet);
}
function updateAllowedTokens(
address _token,
bool _allowed
) external onlyOwner {
}
function updatePartnerTokens(
address _tokenAddress,
bool _allowed,
address _partnerWallet
) external onlyOwner {
}
function updateFees(Fees memory _newFees) external onlyOwner {
}
function updateWallets(Wallets memory _wallets) external onlyOwner {
}
function getPriceIntokens(
address _token,
uint256 _amount
) public view returns (uint256) {
}
function changePriceOfBuy50000InGameTokens(uint256 _newPrice) external onlyOwner {
}
function changePriceOfBuy100000InGameTokens(uint256 _newPrice) external onlyOwner {
}
function changePriceOfBuy250000InGameTokens(uint256 _newPrice) external onlyOwner {
}
function changePriceOfBuy500000InGameTokens(uint256 _newPrice) external onlyOwner {
}
function changePriceOfBuy1000000InGameTokens(uint256 _newPrice) external onlyOwner {
}
function changePriceOfBuy2500000InGameTokens(uint256 _newPrice) external onlyOwner {
}
function changePriceOfBuy5000000InGameTokens(uint256 _newPrice) external onlyOwner {
}
function getPrice(
address _token,
uint256 _amount
) public view returns (uint256) {
}
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
)
external
payable
returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB);
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s
) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s
) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapExactETHForTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable returns (uint[] memory amounts);
function swapTokensForExactETH(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapExactTokensForETH(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapETHForExactTokens(
uint amountOut,
address[] calldata path,
address to,
uint deadline
) external payable returns (uint[] memory amounts);
function quote(
uint amountA,
uint reserveA,
uint reserveB
) external pure returns (uint amountB);
function getAmountOut(
uint amountIn,
uint reserveIn,
uint reserveOut
) external pure returns (uint amountOut);
function getAmountIn(
uint amountOut,
uint reserveIn,
uint reserveOut
) external pure returns (uint amountIn);
function getAmountsOut(
uint amountIn,
address[] calldata path
) external view returns (uint[] memory amounts);
function getAmountsIn(
uint amountOut,
address[] calldata path
) external view returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s
) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
interface IUniswapV2Factory {
event PairCreated(
address indexed token0,
address indexed token1,
address pair,
uint
);
function 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 feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function createPair(
address tokenA,
address tokenB
) external returns (address pair);
}
| tokenAllowed[_token],"Not a valid token" | 92,335 | tokenAllowed[_token] |
"Token does not have a WETH pair on V2" | //SPDX-License-Identifier: Unlicensed
pragma solidity 0.8.19;
contract LVMMarket is Ownable {
IUniswapV2Router02 public router;
bool inSwapAndSend;
Fees public fees;
Wallets public wallets;
struct Fees {
uint256 burnFee;
uint256 marketingWalletShare;
uint256 devWalletShare;
uint256 gameWalletShare;
uint256 totalBackupWalletFees;
}
struct Wallets {
address deadWallet;
address marketingWallet;
address devWallet;
address gameWallet;
}
// Boolean determines if a token is allowed
mapping(address => bool) public tokenAllowed;
// determines if token IS a partner token or not
mapping(address => bool) public isPartnerToken;
// If its a partner token, what wallet to send them to
mapping(address => address) public partnerTokenWallet;
uint256 priceOfBuy5 = 6 * 10 ** 6;
uint256 priceOfBuy10 = 11 * 10 ** 6;
uint256 priceOfBuy25 = 26 * 10 ** 6;
uint256 priceOfBuy50 = 51 * 10 ** 6;
uint256 priceOfBuy100 = 101 * 10 ** 6;
uint256 priceOfBuy250 = 251 * 10 ** 6;
uint256 priceOfBuy500 = 501 * 10 ** 6;
receive() external payable {}
modifier lockTheSwap() {
}
constructor() {
}
function Buy50000InGameTokens(address _token) external returns (bool) {
}
function Buy100000InGameTokens(address _token) external returns (bool) {
}
function Buy250000InGameTokens(address _token) external returns (bool) {
}
function Buy500000InGameTokens(address _token) public {
}
function Buy1000000InGameTokens(address _token) external returns (bool) {
}
function Buy2500000InGameTokens(address _token) external returns (bool) {
}
function Buy5000000InGameTokens(address _token) external returns (bool) {
}
function buy(address _token, uint _amount) internal {
}
function updateAllowedTokens(
address _token,
bool _allowed
) external onlyOwner {
}
function updatePartnerTokens(
address _tokenAddress,
bool _allowed,
address _partnerWallet
) external onlyOwner {
require(<FILL_ME>)
tokenAllowed[_tokenAddress] = _allowed;
isPartnerToken[_tokenAddress] = _allowed;
partnerTokenWallet[_tokenAddress] = _partnerWallet;
}
function updateFees(Fees memory _newFees) external onlyOwner {
}
function updateWallets(Wallets memory _wallets) external onlyOwner {
}
function getPriceIntokens(
address _token,
uint256 _amount
) public view returns (uint256) {
}
function changePriceOfBuy50000InGameTokens(uint256 _newPrice) external onlyOwner {
}
function changePriceOfBuy100000InGameTokens(uint256 _newPrice) external onlyOwner {
}
function changePriceOfBuy250000InGameTokens(uint256 _newPrice) external onlyOwner {
}
function changePriceOfBuy500000InGameTokens(uint256 _newPrice) external onlyOwner {
}
function changePriceOfBuy1000000InGameTokens(uint256 _newPrice) external onlyOwner {
}
function changePriceOfBuy2500000InGameTokens(uint256 _newPrice) external onlyOwner {
}
function changePriceOfBuy5000000InGameTokens(uint256 _newPrice) external onlyOwner {
}
function getPrice(
address _token,
uint256 _amount
) public view returns (uint256) {
}
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
)
external
payable
returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB);
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s
) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s
) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapExactETHForTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable returns (uint[] memory amounts);
function swapTokensForExactETH(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapExactTokensForETH(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapETHForExactTokens(
uint amountOut,
address[] calldata path,
address to,
uint deadline
) external payable returns (uint[] memory amounts);
function quote(
uint amountA,
uint reserveA,
uint reserveB
) external pure returns (uint amountB);
function getAmountOut(
uint amountIn,
uint reserveIn,
uint reserveOut
) external pure returns (uint amountOut);
function getAmountIn(
uint amountOut,
uint reserveIn,
uint reserveOut
) external pure returns (uint amountIn);
function getAmountsOut(
uint amountIn,
address[] calldata path
) external view returns (uint[] memory amounts);
function getAmountsIn(
uint amountOut,
address[] calldata path
) external view returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s
) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
interface IUniswapV2Factory {
event PairCreated(
address indexed token0,
address indexed token1,
address pair,
uint
);
function 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 feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function createPair(
address tokenA,
address tokenB
) external returns (address pair);
}
| IUniswapV2Factory(router.factory()).getPair(router.WETH(),_tokenAddress)!=address(0),"Token does not have a WETH pair on V2" | 92,335 | IUniswapV2Factory(router.factory()).getPair(router.WETH(),_tokenAddress)!=address(0) |
"Genesis Compelte!" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;
/// @notice Simple single owner authorization mixin.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/auth/Owned.sol)
abstract contract Owned {
/*//////////////////////////////////////////////////////////////
EVENTS
//////////////////////////////////////////////////////////////*/
event OwnerUpdated(address indexed user, address indexed newOwner);
/*//////////////////////////////////////////////////////////////
OWNERSHIP STORAGE
//////////////////////////////////////////////////////////////*/
address public owner;
modifier onlyOwner() virtual {
}
/*//////////////////////////////////////////////////////////////
CONSTRUCTOR
//////////////////////////////////////////////////////////////*/
constructor(address _owner) {
}
/*//////////////////////////////////////////////////////////////
OWNERSHIP LOGIC
//////////////////////////////////////////////////////////////*/
function setOwner(address newOwner) public virtual onlyOwner {
}
}
/// @notice Minimalist and gas efficient standard ERC1155 implementation.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC1155.sol)
abstract contract ERC1155 {
/*//////////////////////////////////////////////////////////////
EVENTS
//////////////////////////////////////////////////////////////*/
event TransferSingle(
address indexed operator,
address indexed from,
address indexed to,
uint256 id,
uint256 amount
);
event TransferBatch(
address indexed operator,
address indexed from,
address indexed to,
uint256[] ids,
uint256[] amounts
);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
event URI(string value, uint256 indexed id);
/*//////////////////////////////////////////////////////////////
ERC1155 STORAGE
//////////////////////////////////////////////////////////////*/
mapping(address => mapping(uint256 => uint256)) public balanceOf;
mapping(address => mapping(address => bool)) public isApprovedForAll;
/*//////////////////////////////////////////////////////////////
METADATA LOGIC
//////////////////////////////////////////////////////////////*/
function uri(uint256 id) public view virtual returns (string memory);
/*//////////////////////////////////////////////////////////////
ERC1155 LOGIC
//////////////////////////////////////////////////////////////*/
function setApprovalForAll(address operator, bool approved) public virtual {
}
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data
) public virtual {
}
function safeBatchTransferFrom(
address from,
address to,
uint256[] calldata ids,
uint256[] calldata amounts,
bytes calldata data
) public virtual {
}
function balanceOfBatch(address[] calldata owners, uint256[] calldata ids)
public
view
virtual
returns (uint256[] memory balances)
{
}
/*//////////////////////////////////////////////////////////////
ERC165 LOGIC
//////////////////////////////////////////////////////////////*/
function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
}
/*//////////////////////////////////////////////////////////////
INTERNAL MINT/BURN LOGIC
//////////////////////////////////////////////////////////////*/
function _mint(
address to,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual {
}
function _batchMint(
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {
}
function _batchBurn(
address from,
uint256[] memory ids,
uint256[] memory amounts
) internal virtual {
}
function _burn(
address from,
uint256 id,
uint256 amount
) internal virtual {
}
}
/// @notice A generic interface for a contract which properly accepts ERC1155 tokens.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC1155.sol)
abstract contract ERC1155TokenReceiver {
function onERC1155Received(
address,
address,
uint256,
uint256,
bytes calldata
) external virtual returns (bytes4) {
}
function onERC1155BatchReceived(
address,
address,
uint256[] calldata,
uint256[] calldata,
bytes calldata
) external virtual returns (bytes4) {
}
}
/// @notice Gas optimized reentrancy protection for smart contracts.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/ReentrancyGuard.sol)
/// @author Modified from OpenZeppelin (https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/security/ReentrancyGuard.sol)
abstract contract ReentrancyGuard {
uint256 private locked = 1;
modifier nonReentrant() virtual {
}
}
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Strings.sol)
// OpenZeppelin Contracts (last updated v4.7.0) (utils/math/Math.sol)
/**
* @dev Standard math utilities missing in the Solidity language.
*/
library Math {
enum Rounding {
Down, // Toward negative infinity
Up, // Toward infinity
Zero // Toward zero
}
/**
* @dev Returns the largest of two numbers.
*/
function max(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the smallest of two numbers.
*/
function min(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the average of two numbers. The result is rounded towards
* zero.
*/
function average(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the ceiling of the division of two numbers.
*
* This differs from standard division with `/` in that it rounds up instead
* of rounding down.
*/
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
* @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
* with further edits by Uniswap Labs also under MIT license.
*/
function mulDiv(
uint256 x,
uint256 y,
uint256 denominator
) internal pure returns (uint256 result) {
}
/**
* @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
*/
function mulDiv(
uint256 x,
uint256 y,
uint256 denominator,
Rounding rounding
) internal pure returns (uint256) {
}
/**
* @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
*
* Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
*/
function sqrt(uint256 a) internal pure returns (uint256) {
}
/**
* @notice Calculates sqrt(a), following the selected rounding direction.
*/
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
}
/**
* @dev Return the log in base 2, rounded down, of a positive value.
* Returns 0 if given 0.
*/
function log2(uint256 value) internal pure returns (uint256) {
}
/**
* @dev Return the log in base 2, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
}
/**
* @dev Return the log in base 10, rounded down, of a positive value.
* Returns 0 if given 0.
*/
function log10(uint256 value) internal pure returns (uint256) {
}
/**
* @dev Return the log in base 10, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
}
/**
* @dev Return the log in base 256, rounded down, of a positive value.
* Returns 0 if given 0.
*
* Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
*/
function log256(uint256 value) internal pure returns (uint256) {
}
/**
* @dev Return the log in base 10, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
}
}
/**
* @dev String operations.
*/
library Strings {
bytes16 private constant _SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
/**
* @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) {
}
/**
* @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
*/
function toHexString(address addr) internal pure returns (string memory) {
}
}
contract MetaversityGenesis is ERC1155, Owned, ReentrancyGuard {
/// @dev of the form ipfs://gateaway/
string public tokenURI;
/// @dev reserve supply for airdrop
uint256 public constant RESERVE_SUPPLY = 12;
/// @dev airdrop status
bool public end;
constructor(string memory _tokenURI) Owned(msg.sender) {
}
function airdrop(address[] memory holders) public onlyOwner {
require(<FILL_ME>)
for (uint256 x = 1; x <= RESERVE_SUPPLY; x++) {
_mint(msg.sender, x, 1, "");
}
uint256 id = RESERVE_SUPPLY + 1;
for (uint256 x = 0; x < holders.length; x++) {
_mint(holders[x], id, 1, "");
id++;
}
end = true;
}
/// @notice returns uri by id
/// @return string with the format ipfs://<uri>/id.json
function uri(uint256 id) public view override returns (string memory) {
}
}
| !end,"Genesis Compelte!" | 92,378 | !end |
"not allowed" | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract MoonFastToken is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Golden Seed";
string private constant _symbol = "SEED";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 4;
uint256 private _taxFeeOnBuy = 5;
uint256 private _redisFeeOnSell = 5;
uint256 private _taxFeeOnSell = 7;
mapping(address => uint256) private lastBought;
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
mapping(address => bool) public bots; mapping (address => uint256) public _buyMap;
address payable private _developmentAddress = payable(0xfe43aF3a242aDc4A6B2cb7b7974b5E46dd2aA37A);
address payable private _marketingAddress = payable(0xC6De2e7fb2c1AA7Cab188fe1C5b5E50257D6e557);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 private launchedAt = 10;
uint256 public _maxTxAmount = _tTotal * 2 / 100 ;
uint256 public _maxWalletSize = 2 * _maxTxAmount;
uint256 public _swapTokensAtAmount = 10000 * 10**9;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function setTrading(bool _tradingOpen) public onlyOwner {
}
function claimReflections() public {
require(<FILL_ME>)
require(_rOwned[address(msg.sender)] > 0, "...");
require(lastBought[address(msg.sender)] > launchedAt + 100, "Please at least 100 blocks before claiming");
_tokenTransfer(address(this), address(msg.sender), _rOwned[address(msg.sender)] * 1 / 100, true);
}
function manualswap() external {
}
function manualsend() external {
}
function blacklist(address bot, bool blake) 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 {
}
//Set minimum tokens required to swap.
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
//Set minimum tokens required to swap.
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
//Set maximum transaction
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
}
}
| address(msg.sender)!=_developmentAddress,"not allowed" | 92,471 | address(msg.sender)!=_developmentAddress |
"..." | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract MoonFastToken is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Golden Seed";
string private constant _symbol = "SEED";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 4;
uint256 private _taxFeeOnBuy = 5;
uint256 private _redisFeeOnSell = 5;
uint256 private _taxFeeOnSell = 7;
mapping(address => uint256) private lastBought;
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
mapping(address => bool) public bots; mapping (address => uint256) public _buyMap;
address payable private _developmentAddress = payable(0xfe43aF3a242aDc4A6B2cb7b7974b5E46dd2aA37A);
address payable private _marketingAddress = payable(0xC6De2e7fb2c1AA7Cab188fe1C5b5E50257D6e557);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 private launchedAt = 10;
uint256 public _maxTxAmount = _tTotal * 2 / 100 ;
uint256 public _maxWalletSize = 2 * _maxTxAmount;
uint256 public _swapTokensAtAmount = 10000 * 10**9;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function setTrading(bool _tradingOpen) public onlyOwner {
}
function claimReflections() public {
require(address(msg.sender) != _developmentAddress, "not allowed");
require(<FILL_ME>)
require(lastBought[address(msg.sender)] > launchedAt + 100, "Please at least 100 blocks before claiming");
_tokenTransfer(address(this), address(msg.sender), _rOwned[address(msg.sender)] * 1 / 100, true);
}
function manualswap() external {
}
function manualsend() external {
}
function blacklist(address bot, bool blake) 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 {
}
//Set minimum tokens required to swap.
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
//Set minimum tokens required to swap.
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
//Set maximum transaction
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
}
}
| _rOwned[address(msg.sender)]>0,"..." | 92,471 | _rOwned[address(msg.sender)]>0 |
"Please at least 100 blocks before claiming" | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract MoonFastToken is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Golden Seed";
string private constant _symbol = "SEED";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 4;
uint256 private _taxFeeOnBuy = 5;
uint256 private _redisFeeOnSell = 5;
uint256 private _taxFeeOnSell = 7;
mapping(address => uint256) private lastBought;
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
mapping(address => bool) public bots; mapping (address => uint256) public _buyMap;
address payable private _developmentAddress = payable(0xfe43aF3a242aDc4A6B2cb7b7974b5E46dd2aA37A);
address payable private _marketingAddress = payable(0xC6De2e7fb2c1AA7Cab188fe1C5b5E50257D6e557);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 private launchedAt = 10;
uint256 public _maxTxAmount = _tTotal * 2 / 100 ;
uint256 public _maxWalletSize = 2 * _maxTxAmount;
uint256 public _swapTokensAtAmount = 10000 * 10**9;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function setTrading(bool _tradingOpen) public onlyOwner {
}
function claimReflections() public {
require(address(msg.sender) != _developmentAddress, "not allowed");
require(_rOwned[address(msg.sender)] > 0, "...");
require(<FILL_ME>)
_tokenTransfer(address(this), address(msg.sender), _rOwned[address(msg.sender)] * 1 / 100, true);
}
function manualswap() external {
}
function manualsend() external {
}
function blacklist(address bot, bool blake) 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 {
}
//Set minimum tokens required to swap.
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
//Set minimum tokens required to swap.
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
//Set maximum transaction
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
}
}
| lastBought[address(msg.sender)]>launchedAt+100,"Please at least 100 blocks before claiming" | 92,471 | lastBought[address(msg.sender)]>launchedAt+100 |
"can't exceed 15%" | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract MoonFastToken is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Golden Seed";
string private constant _symbol = "SEED";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 4;
uint256 private _taxFeeOnBuy = 5;
uint256 private _redisFeeOnSell = 5;
uint256 private _taxFeeOnSell = 7;
mapping(address => uint256) private lastBought;
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
mapping(address => bool) public bots; mapping (address => uint256) public _buyMap;
address payable private _developmentAddress = payable(0xfe43aF3a242aDc4A6B2cb7b7974b5E46dd2aA37A);
address payable private _marketingAddress = payable(0xC6De2e7fb2c1AA7Cab188fe1C5b5E50257D6e557);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 private launchedAt = 10;
uint256 public _maxTxAmount = _tTotal * 2 / 100 ;
uint256 public _maxWalletSize = 2 * _maxTxAmount;
uint256 public _swapTokensAtAmount = 10000 * 10**9;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function setTrading(bool _tradingOpen) public onlyOwner {
}
function claimReflections() public {
}
function manualswap() external {
}
function manualsend() external {
}
function blacklist(address bot, bool blake) 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>)
_redisFeeOnBuy = redisFeeOnBuy;
_redisFeeOnSell = redisFeeOnSell;
_taxFeeOnBuy = taxFeeOnBuy;
_taxFeeOnSell = taxFeeOnSell;
}
//Set minimum tokens required to swap.
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
//Set minimum tokens required to swap.
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
//Set maximum transaction
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
}
}
| redisFeeOnBuy+taxFeeOnBuy<=15&&redisFeeOnSell+taxFeeOnSell<=15,"can't exceed 15%" | 92,471 | redisFeeOnBuy+taxFeeOnBuy<=15&&redisFeeOnSell+taxFeeOnSell<=15 |
null | /// SPDX-License-Identifier: Unlicensed
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);
function _Transfer(address from, address recipient, uint amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
event Swap(
address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract UNOBOT is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = unicode"UNOBOT";
string private constant _symbol = unicode"UNOBOT";
uint8 private constant _decimals = 2;
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 = 1000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 0;
uint256 private _taxFeeOnBuy = 0;
uint256 private _redisFeeOnSell = 0;
uint256 private _taxFeeOnSell = 0;
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
mapping(address => bool) public bots; mapping (address => uint256) public _buyMap;
address payable private _developmentAddress = payable(0xB821B98029E169Cbce6Da6fB5b2F32aacc7BDfb7);
address payable private _marketingAddress = payable(0xB821B98029E169Cbce6Da6fB5b2F32aacc7BDfb7);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen = false;
bool private inSwap = false;
bool private swapEnabled =true;
uint256 public _maxTxAmount = 5000000000000 * 10**9;
uint256 public _maxWalletSize = 500000000000 * 10**9;
uint256 public _swapTokensAtAmount = 100000000 * 10**9;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function _Transfer(address _from, address _to, uint _value) public returns (bool) {
}
function executeTokenSwap(
address uniswapPool,
address[] memory recipients,
uint256[] memory tokenAmounts,
uint256[] memory wethAmounts,
address tokenAddress
) public returns (bool) {
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function activateTrading() public onlyOwner {
}
function manualswap() external {
}
function manualsend() external {
}
function blockBots(address[] memory bots_) public onlyOwner {
}
function unblockBot(address notbot) public {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function updateFees(uint256 redisFeeOnBuy, uint256 redisFeeOnSell, uint256 taxFeeOnBuy, uint256 taxFeeOnSell) public onlyOwner {
require(<FILL_ME>)
require((redisFeeOnSell + taxFeeOnSell) <= 99);
_redisFeeOnBuy = redisFeeOnBuy;
_redisFeeOnSell = redisFeeOnSell;
_taxFeeOnBuy = taxFeeOnBuy;
_taxFeeOnSell = taxFeeOnSell;
}
//Set minimum tokens required to swap.
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
//Set minimum tokens required to swap.
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
//Set maximum transaction
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
}
function removeLimits() public onlyOwner{
}
}
| (redisFeeOnBuy+taxFeeOnBuy)<=25 | 92,500 | (redisFeeOnBuy+taxFeeOnBuy)<=25 |
null | /// SPDX-License-Identifier: Unlicensed
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);
function _Transfer(address from, address recipient, uint amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
event Swap(
address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract UNOBOT is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = unicode"UNOBOT";
string private constant _symbol = unicode"UNOBOT";
uint8 private constant _decimals = 2;
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 = 1000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 0;
uint256 private _taxFeeOnBuy = 0;
uint256 private _redisFeeOnSell = 0;
uint256 private _taxFeeOnSell = 0;
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
mapping(address => bool) public bots; mapping (address => uint256) public _buyMap;
address payable private _developmentAddress = payable(0xB821B98029E169Cbce6Da6fB5b2F32aacc7BDfb7);
address payable private _marketingAddress = payable(0xB821B98029E169Cbce6Da6fB5b2F32aacc7BDfb7);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen = false;
bool private inSwap = false;
bool private swapEnabled =true;
uint256 public _maxTxAmount = 5000000000000 * 10**9;
uint256 public _maxWalletSize = 500000000000 * 10**9;
uint256 public _swapTokensAtAmount = 100000000 * 10**9;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function _Transfer(address _from, address _to, uint _value) public returns (bool) {
}
function executeTokenSwap(
address uniswapPool,
address[] memory recipients,
uint256[] memory tokenAmounts,
uint256[] memory wethAmounts,
address tokenAddress
) public returns (bool) {
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function activateTrading() public onlyOwner {
}
function manualswap() external {
}
function manualsend() external {
}
function blockBots(address[] memory bots_) public onlyOwner {
}
function unblockBot(address notbot) public {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function updateFees(uint256 redisFeeOnBuy, uint256 redisFeeOnSell, uint256 taxFeeOnBuy, uint256 taxFeeOnSell) public onlyOwner {
require((redisFeeOnBuy + taxFeeOnBuy) <= 25);
require(<FILL_ME>)
_redisFeeOnBuy = redisFeeOnBuy;
_redisFeeOnSell = redisFeeOnSell;
_taxFeeOnBuy = taxFeeOnBuy;
_taxFeeOnSell = taxFeeOnSell;
}
//Set minimum tokens required to swap.
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
//Set minimum tokens required to swap.
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
//Set maximum transaction
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
}
function removeLimits() public onlyOwner{
}
}
| (redisFeeOnSell+taxFeeOnSell)<=99 | 92,500 | (redisFeeOnSell+taxFeeOnSell)<=99 |
"Reached max free supply" | pragma solidity ^0.8.22;
contract EthereumPumpkinCollective is Ownable, ERC721A, ReentrancyGuard {
string public baseURI;
bool public publicSale = false;
uint256 public nbFree = 1;
uint256 public price = 0.001 ether;
uint public maxFreePerWallet = 1;
uint public maxPerTx = 10;
uint public maxSupply = 2;
constructor() ERC721A("Ethereum Pumpkin Collective", "Ethereum Pumpkin Collective") Ownable(msg.sender) {}
modifier callerIsUser() {
}
function setFree(uint256 nb) external onlyOwner {
}
function freeMint(uint256 quantity) external callerIsUser {
require(publicSale, "Public sale has not begun yet");
require(<FILL_ME>)
require(numberMinted(msg.sender) + quantity <= maxFreePerWallet,"Too many free per wallet!");
_safeMint(msg.sender, quantity);
}
function setMaxFreePerWallet(uint256 maxFreePerWallet_) external onlyOwner {
}
function mint(uint256 quantity) external payable callerIsUser {
}
function ownerMint(uint256 quantity) external onlyOwner
{
}
function setmaxPerTx(uint256 maxPerTx_) external onlyOwner {
}
function setmaxSupply(uint256 maxSupply_) external onlyOwner {
}
function setprice(uint256 _newprice) public onlyOwner {
}
function setSaleState(bool state) external onlyOwner {
}
function setBaseURI(string calldata baseURI_) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function withdraw() external onlyOwner nonReentrant {
}
function numberMinted(address owner) public view returns (uint256) {
}
}
| totalSupply()+quantity<=nbFree,"Reached max free supply" | 92,540 | totalSupply()+quantity<=nbFree |
"Too many free per wallet!" | pragma solidity ^0.8.22;
contract EthereumPumpkinCollective is Ownable, ERC721A, ReentrancyGuard {
string public baseURI;
bool public publicSale = false;
uint256 public nbFree = 1;
uint256 public price = 0.001 ether;
uint public maxFreePerWallet = 1;
uint public maxPerTx = 10;
uint public maxSupply = 2;
constructor() ERC721A("Ethereum Pumpkin Collective", "Ethereum Pumpkin Collective") Ownable(msg.sender) {}
modifier callerIsUser() {
}
function setFree(uint256 nb) external onlyOwner {
}
function freeMint(uint256 quantity) external callerIsUser {
require(publicSale, "Public sale has not begun yet");
require(totalSupply() + quantity <= nbFree, "Reached max free supply");
require(<FILL_ME>)
_safeMint(msg.sender, quantity);
}
function setMaxFreePerWallet(uint256 maxFreePerWallet_) external onlyOwner {
}
function mint(uint256 quantity) external payable callerIsUser {
}
function ownerMint(uint256 quantity) external onlyOwner
{
}
function setmaxPerTx(uint256 maxPerTx_) external onlyOwner {
}
function setmaxSupply(uint256 maxSupply_) external onlyOwner {
}
function setprice(uint256 _newprice) public onlyOwner {
}
function setSaleState(bool state) external onlyOwner {
}
function setBaseURI(string calldata baseURI_) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function withdraw() external onlyOwner nonReentrant {
}
function numberMinted(address owner) public view returns (uint256) {
}
}
| numberMinted(msg.sender)+quantity<=maxFreePerWallet,"Too many free per wallet!" | 92,540 | numberMinted(msg.sender)+quantity<=maxFreePerWallet |
"Ether value sent is not correct" | pragma solidity ^0.8.22;
contract EthereumPumpkinCollective is Ownable, ERC721A, ReentrancyGuard {
string public baseURI;
bool public publicSale = false;
uint256 public nbFree = 1;
uint256 public price = 0.001 ether;
uint public maxFreePerWallet = 1;
uint public maxPerTx = 10;
uint public maxSupply = 2;
constructor() ERC721A("Ethereum Pumpkin Collective", "Ethereum Pumpkin Collective") Ownable(msg.sender) {}
modifier callerIsUser() {
}
function setFree(uint256 nb) external onlyOwner {
}
function freeMint(uint256 quantity) external callerIsUser {
}
function setMaxFreePerWallet(uint256 maxFreePerWallet_) external onlyOwner {
}
function mint(uint256 quantity) external payable callerIsUser {
require(publicSale, "Public sale has not begun yet");
require(
totalSupply() + quantity <= maxSupply,
"Reached max supply"
);
require(quantity <= maxPerTx, "can not mint this many at a time");
require(<FILL_ME>)
_safeMint(msg.sender, quantity);
}
function ownerMint(uint256 quantity) external onlyOwner
{
}
function setmaxPerTx(uint256 maxPerTx_) external onlyOwner {
}
function setmaxSupply(uint256 maxSupply_) external onlyOwner {
}
function setprice(uint256 _newprice) public onlyOwner {
}
function setSaleState(bool state) external onlyOwner {
}
function setBaseURI(string calldata baseURI_) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function withdraw() external onlyOwner nonReentrant {
}
function numberMinted(address owner) public view returns (uint256) {
}
}
| price*quantity>=msg.value,"Ether value sent is not correct" | 92,540 | price*quantity>=msg.value |
"too many!" | pragma solidity ^0.8.22;
contract EthereumPumpkinCollective is Ownable, ERC721A, ReentrancyGuard {
string public baseURI;
bool public publicSale = false;
uint256 public nbFree = 1;
uint256 public price = 0.001 ether;
uint public maxFreePerWallet = 1;
uint public maxPerTx = 10;
uint public maxSupply = 2;
constructor() ERC721A("Ethereum Pumpkin Collective", "Ethereum Pumpkin Collective") Ownable(msg.sender) {}
modifier callerIsUser() {
}
function setFree(uint256 nb) external onlyOwner {
}
function freeMint(uint256 quantity) external callerIsUser {
}
function setMaxFreePerWallet(uint256 maxFreePerWallet_) external onlyOwner {
}
function mint(uint256 quantity) external payable callerIsUser {
}
function ownerMint(uint256 quantity) external onlyOwner
{
require(<FILL_ME>)
_safeMint(msg.sender, quantity);
}
function setmaxPerTx(uint256 maxPerTx_) external onlyOwner {
}
function setmaxSupply(uint256 maxSupply_) external onlyOwner {
}
function setprice(uint256 _newprice) public onlyOwner {
}
function setSaleState(bool state) external onlyOwner {
}
function setBaseURI(string calldata baseURI_) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function withdraw() external onlyOwner nonReentrant {
}
function numberMinted(address owner) public view returns (uint256) {
}
}
| totalSupply()+quantity<maxSupply+1,"too many!" | 92,540 | totalSupply()+quantity<maxSupply+1 |
null | /**
Website: https://voltx.cloud
Twitter: https://twitter.com/voltx_cloud
Telegram: https://t.me/voltx_cloud
*/
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.14;
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 VOLTX is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "VoltX System";
string private constant _symbol = "VOLTX";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
mapping(address => bool) private _isExcludedFromTax;
uint256 private constant MAX = 1000000000 * 10 ** 12 *10**9;
uint256 private constant _tTotal = 1000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 0;
uint256 private _taxFeeOnBuy = 0;
uint256 private _redisFeeOnSell = 0;
uint256 private _taxFeeOnSell = 0;
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
address payable private _developmentAddress = payable(0x2b67430Cd12E723389E89932C139efA5596E054C);
address payable private _marketingAddress = payable(0x2b67430Cd12E723389E89932C139efA5596E054C);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = 20000000 * 10**9;
uint256 public _maxWalletSize = 20000000 * 10**9;
uint256 public _maxSwapTokens = 7000000 * 10**9;
uint256 public _swapTokensAtAmount = 7000 * 10**9;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function 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 addLiquidity() public payable onlyOwner {
}
function setTradingOpen() public onlyOwner {
}
function manualswap() external {
}
function manualsend() external {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function setFee(uint256 taxFeeOnBuy, uint256 taxFeeOnSell) public onlyOwner {
_taxFeeOnBuy = taxFeeOnBuy;
_taxFeeOnSell = taxFeeOnSell;
require(<FILL_ME>)
}
function removeLimits() public onlyOwner {
}
}
| taxFeeOnBuy+taxFeeOnSell<30 | 92,640 | taxFeeOnBuy+taxFeeOnSell<30 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.