comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"Pay Up" | // SPDX-License-Identifier: MIT
/*
Welcome to the Milady Christmas Special!
*/
pragma solidity ^0.8.14;
import "https://github.com/ProjectOpenSea/operator-filter-registry/src/DefaultOperatorFilterer.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract MILADYCHRISTMAS is ERC721A, DefaultOperatorFilterer, Ownable {
address public constant MILADY_MAKER = 0x5Af0D9827E0c53E4799BB226655A1de152A425a5;
address public constant SONORA_MAKER = 0x9a051C1794C2f0ED9518Fcb68973DA84f756e29E;
address public constant MILADY_AURA = 0x2fC722C1c77170A61F17962CC4D039692f033b43;
address public constant BORED_MILADY = 0xafe12842e3703a3cC3A71d9463389b1bF2c5BC1C;
address public constant MILAIDY = 0x0D8A3359182DCa59CCAF36F5c6C6008b83ceB4A6;
address public constant PIXELADY_MAKER = 0x8Fc0D90f2C45a5e7f94904075c952e0943CFCCfd;
address public constant REMILIO = 0xD3D9ddd0CF0A5F0BFB8f7fcEAe075DF687eAEBaB;
address public constant MILADY_RAVE = 0x880a965fAe95f72fe3a3C8e87ED2c9478C8e0a29;
address public constant GHIBLADY_MAKER = 0x186E74aD45bF81fb3712e9657560f8f6361cbBef;
address public constant PIXELADY_MAKER_BC = 0x4D40C64A8E41aC96b85eE557A434410672221750;
address public constant RADBRO = 0xE83C9F09B0992e4a34fAf125ed4FEdD3407c4a23;
uint256 public cost = 0.03 ether;
uint256 public WLcost = 0.02 ether;
uint256 public freecost = 0.00 ether;
uint256 public maxSupply = 1000;
uint256 public maxMintAmount = 10;
uint256 public maxOwnerMintAmount = 20;
uint16 public maxRadBroMintAmount = 1;
uint16 public totalRadBros = 0;
bool public PublicActive = false;
mapping(address => uint16) private _radBro;
bool MiladyFriendsActive = false;
string public baseURI = "";
mapping(address => bool) public claimed;
constructor(
string memory _name,
string memory _symbol) ERC721A(_name, _symbol) {
}
modifier miladyFriends() {
}
modifier radBro() {
}
modifier publicMintActive(){
}
modifier WLMintActive(){
}
function mint(uint16 _mintAmount)
external
payable
publicMintActive
{
}
function wlMint(uint16 _mintAmount)
external
payable
miladyFriends
WLMintActive
{
// _safeMint's second argument now takes in a quantity, not a tokenId.
require(totalSupply() + _mintAmount <= maxSupply, "Not enough left to mint");
require(_mintAmount + _numberMinted(msg.sender) <= maxMintAmount, "Only 10 mints per address");
require(_mintAmount > 0,"Need to mint at least 1 Christmas Special");
require(<FILL_ME>)
_safeMint(msg.sender, _mintAmount);
}
function radBroMint()
external
payable
radBro
WLMintActive
{
}
function ownerMint(uint16 _mintAmount) external payable onlyOwner {
}
function toBytes32(address addr) pure internal returns (bytes32){
}
function withdraw() external payable onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function setMintRate(uint256 _mintRate) public onlyOwner {
}
function setMintAmount(uint256 _mintAmount) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setActive(bool _newStatus) public onlyOwner {
}
function setMiladyFriendsActive(bool _newStatus) public onlyOwner {
}
function _startTokenId() internal view override returns (uint256) {
}
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public payable override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override
onlyAllowedOperator(from)
{
}
}
| msg.value>=(WLcost*_mintAmount),"Pay Up" | 65,506 | msg.value>=(WLcost*_mintAmount) |
null | // SPDX-License-Identifier: MIT
/*
Welcome to the Milady Christmas Special!
*/
pragma solidity ^0.8.14;
import "https://github.com/ProjectOpenSea/operator-filter-registry/src/DefaultOperatorFilterer.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract MILADYCHRISTMAS is ERC721A, DefaultOperatorFilterer, Ownable {
address public constant MILADY_MAKER = 0x5Af0D9827E0c53E4799BB226655A1de152A425a5;
address public constant SONORA_MAKER = 0x9a051C1794C2f0ED9518Fcb68973DA84f756e29E;
address public constant MILADY_AURA = 0x2fC722C1c77170A61F17962CC4D039692f033b43;
address public constant BORED_MILADY = 0xafe12842e3703a3cC3A71d9463389b1bF2c5BC1C;
address public constant MILAIDY = 0x0D8A3359182DCa59CCAF36F5c6C6008b83ceB4A6;
address public constant PIXELADY_MAKER = 0x8Fc0D90f2C45a5e7f94904075c952e0943CFCCfd;
address public constant REMILIO = 0xD3D9ddd0CF0A5F0BFB8f7fcEAe075DF687eAEBaB;
address public constant MILADY_RAVE = 0x880a965fAe95f72fe3a3C8e87ED2c9478C8e0a29;
address public constant GHIBLADY_MAKER = 0x186E74aD45bF81fb3712e9657560f8f6361cbBef;
address public constant PIXELADY_MAKER_BC = 0x4D40C64A8E41aC96b85eE557A434410672221750;
address public constant RADBRO = 0xE83C9F09B0992e4a34fAf125ed4FEdD3407c4a23;
uint256 public cost = 0.03 ether;
uint256 public WLcost = 0.02 ether;
uint256 public freecost = 0.00 ether;
uint256 public maxSupply = 1000;
uint256 public maxMintAmount = 10;
uint256 public maxOwnerMintAmount = 20;
uint16 public maxRadBroMintAmount = 1;
uint16 public totalRadBros = 0;
bool public PublicActive = false;
mapping(address => uint16) private _radBro;
bool MiladyFriendsActive = false;
string public baseURI = "";
mapping(address => bool) public claimed;
constructor(
string memory _name,
string memory _symbol) ERC721A(_name, _symbol) {
}
modifier miladyFriends() {
}
modifier radBro() {
}
modifier publicMintActive(){
}
modifier WLMintActive(){
}
function mint(uint16 _mintAmount)
external
payable
publicMintActive
{
}
function wlMint(uint16 _mintAmount)
external
payable
miladyFriends
WLMintActive
{
}
function radBroMint()
external
payable
radBro
WLMintActive
{
require(<FILL_ME>)
require(totalRadBros < 100);
totalRadBros = totalRadBros + 1;
_radBro[msg.sender] = 1;
_safeMint(msg.sender, 1);
}
function ownerMint(uint16 _mintAmount) external payable onlyOwner {
}
function toBytes32(address addr) pure internal returns (bytes32){
}
function withdraw() external payable onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function setMintRate(uint256 _mintRate) public onlyOwner {
}
function setMintAmount(uint256 _mintAmount) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setActive(bool _newStatus) public onlyOwner {
}
function setMiladyFriendsActive(bool _newStatus) public onlyOwner {
}
function _startTokenId() internal view override returns (uint256) {
}
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public payable override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override
onlyAllowedOperator(from)
{
}
}
| _radBro[msg.sender]<maxRadBroMintAmount | 65,506 | _radBro[msg.sender]<maxRadBroMintAmount |
"Greedy" | // SPDX-License-Identifier: MIT
/*
Welcome to the Milady Christmas Special!
*/
pragma solidity ^0.8.14;
import "https://github.com/ProjectOpenSea/operator-filter-registry/src/DefaultOperatorFilterer.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract MILADYCHRISTMAS is ERC721A, DefaultOperatorFilterer, Ownable {
address public constant MILADY_MAKER = 0x5Af0D9827E0c53E4799BB226655A1de152A425a5;
address public constant SONORA_MAKER = 0x9a051C1794C2f0ED9518Fcb68973DA84f756e29E;
address public constant MILADY_AURA = 0x2fC722C1c77170A61F17962CC4D039692f033b43;
address public constant BORED_MILADY = 0xafe12842e3703a3cC3A71d9463389b1bF2c5BC1C;
address public constant MILAIDY = 0x0D8A3359182DCa59CCAF36F5c6C6008b83ceB4A6;
address public constant PIXELADY_MAKER = 0x8Fc0D90f2C45a5e7f94904075c952e0943CFCCfd;
address public constant REMILIO = 0xD3D9ddd0CF0A5F0BFB8f7fcEAe075DF687eAEBaB;
address public constant MILADY_RAVE = 0x880a965fAe95f72fe3a3C8e87ED2c9478C8e0a29;
address public constant GHIBLADY_MAKER = 0x186E74aD45bF81fb3712e9657560f8f6361cbBef;
address public constant PIXELADY_MAKER_BC = 0x4D40C64A8E41aC96b85eE557A434410672221750;
address public constant RADBRO = 0xE83C9F09B0992e4a34fAf125ed4FEdD3407c4a23;
uint256 public cost = 0.03 ether;
uint256 public WLcost = 0.02 ether;
uint256 public freecost = 0.00 ether;
uint256 public maxSupply = 1000;
uint256 public maxMintAmount = 10;
uint256 public maxOwnerMintAmount = 20;
uint16 public maxRadBroMintAmount = 1;
uint16 public totalRadBros = 0;
bool public PublicActive = false;
mapping(address => uint16) private _radBro;
bool MiladyFriendsActive = false;
string public baseURI = "";
mapping(address => bool) public claimed;
constructor(
string memory _name,
string memory _symbol) ERC721A(_name, _symbol) {
}
modifier miladyFriends() {
}
modifier radBro() {
}
modifier publicMintActive(){
}
modifier WLMintActive(){
}
function mint(uint16 _mintAmount)
external
payable
publicMintActive
{
}
function wlMint(uint16 _mintAmount)
external
payable
miladyFriends
WLMintActive
{
}
function radBroMint()
external
payable
radBro
WLMintActive
{
}
function ownerMint(uint16 _mintAmount) external payable onlyOwner {
require(<FILL_ME>)
require(totalSupply() + _mintAmount <= maxSupply, "Rip");
_safeMint(msg.sender, _mintAmount);
}
function toBytes32(address addr) pure internal returns (bytes32){
}
function withdraw() external payable onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function setMintRate(uint256 _mintRate) public onlyOwner {
}
function setMintAmount(uint256 _mintAmount) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setActive(bool _newStatus) public onlyOwner {
}
function setMiladyFriendsActive(bool _newStatus) public onlyOwner {
}
function _startTokenId() internal view override returns (uint256) {
}
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public payable override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override
onlyAllowedOperator(from)
{
}
}
| _mintAmount+_numberMinted(msg.sender)<=maxOwnerMintAmount,"Greedy" | 65,506 | _mintAmount+_numberMinted(msg.sender)<=maxOwnerMintAmount |
null | /*
Website: https://1stcitizensinu.com/
Telegram: https://t.me/firstcitizensinu
Twitter: http://Twitter.com/1stcitizensinu
*/
pragma solidity ^0.8.9;
// 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);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract firstctz is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1_000_000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _reflectionFee;
uint256 private _fee;
uint256 private _taxFee=3;
address payable private _devWallet = payable(0x1835D407205193FA76e498953c43091CA2c3B2F2);
string private constant _name = "First Citizen Inu";
string private constant _symbol = "FCI";
uint8 private constant _decimals = 9;
IUniswapV2Router02 private uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
uint256 private _maxTxAmount = 1_500_000 * 10**9;
uint256 private _maxWalletSize = 1_500_000 * 10**9;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount) private view returns(uint256) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function removeLimits() external onlyOwner{
}
function sendETHToFee(uint256 amount) private {
}
function openTrading() external payable onlyOwner() {
}
function _tokenTransfer(address sender, address recipient, uint256 amount) private {
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee) private {
}
receive() external payable {}
function manualswaptokens() external {
require(<FILL_ME>)
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function manualsendtokens() external {
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 TeamFee) private pure returns (uint256, uint256, uint256) {
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
}
function _getRate() private view returns(uint256) {
}
function _getCurrentSupply() private view returns(uint256, uint256) {
}
function settxnFee(uint256 taxFee) public onlyOwner {
}
}
| _msgSender()==_devWallet | 65,515 | _msgSender()==_devWallet |
null | // SPDX-License-Identifier: Unlicensed
/*
The currency of teh people, by teh people, for teh people.
https://decentralbank.info/
https://twitter.com/NotCentralBank
*/
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 DecentralBankDigitalCurrency is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Decentral Bank Digital Currency";
string private constant _symbol = "DBDC";
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 = 100000000 * 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 = 4;
//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(0x93C1e750d3F4131Ba30157610D535e9fbEC413d7);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen = false;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = 2500000 * 10**9;
uint256 public _maxWalletSize = 2500000 * 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 setTrading(bool _tradingOpen) public onlyOwner {
}
function manualswap() external {
require(<FILL_ME>)
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function manualsend() external {
}
function blockBots(address[] memory bots_) public onlyOwner {
}
function unblockBot(address notbot) public onlyOwner {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function setFee(uint256 redisFeeOnBuy, uint256 redisFeeOnSell, uint256 taxFeeOnBuy, uint256 taxFeeOnSell) public onlyOwner {
}
//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 {
}
}
| _msgSender()==_developmentAddress | 65,617 | _msgSender()==_developmentAddress |
"Caller is not manager" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
contract Managed {
mapping(address => bool) public managers;
modifier onlyManagers() {
require(<FILL_ME>)
_;
}
constructor() {
}
function setManager(address _wallet, bool _manager) public onlyManagers {
}
}
interface IBridgeLog {
function outgoing(address _wallet, uint256 _amount, uint256 _fee, uint256 _chainID, uint256 _bridgeIndex) external;
function incoming(address _wallet, uint256 _amount, uint256 _fee, uint256 _chainID, uint256 _logIndex, bytes32 _txHash) external;
function withdrawalCompleted(bytes32 _withdrawalId) external view returns (bool completed);
}
interface IERC20Token {
function mint(address account, uint256 value) external;
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
}
library ECDSA {
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
}
function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
}
}
contract POLCBridgeMinter is Managed {
IERC20Token private polcToken;
IBridgeLog private logger;
address signer;
uint256 chainID;
address platformWallet;
address banksWallet;
address polcVault;
uint256 txMode; // 0 minting, 1 transfer
bool paused;
constructor() {
}
function verifyTXCall(bytes32 _taskHash, bytes memory _sig) public view returns (bool valid) {
}
function withdraw(address _wallet, uint256 _amount, uint256 _fee, uint256 _chainFrom, uint256 _chainTo, uint256 _logIndex, bytes memory _sig) public {
}
function setLogger (address _logger) public onlyManagers {
}
function setSigner (address _signer) public onlyManagers {
}
function setBanksWallet(address _wallet) public onlyManagers {
}
function setVault(address _wallet) public onlyManagers {
}
function setPlatformWallet(address _wallet) public onlyManagers {
}
function pauseContract(bool _paused) public onlyManagers {
}
function setMode(uint256 _mode) public onlyManagers {
}
}
| managers[msg.sender]==true,"Caller is not manager" | 65,704 | managers[msg.sender]==true |
"Withdrawal already completed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
contract Managed {
mapping(address => bool) public managers;
modifier onlyManagers() {
}
constructor() {
}
function setManager(address _wallet, bool _manager) public onlyManagers {
}
}
interface IBridgeLog {
function outgoing(address _wallet, uint256 _amount, uint256 _fee, uint256 _chainID, uint256 _bridgeIndex) external;
function incoming(address _wallet, uint256 _amount, uint256 _fee, uint256 _chainID, uint256 _logIndex, bytes32 _txHash) external;
function withdrawalCompleted(bytes32 _withdrawalId) external view returns (bool completed);
}
interface IERC20Token {
function mint(address account, uint256 value) external;
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
}
library ECDSA {
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
}
function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
}
}
contract POLCBridgeMinter is Managed {
IERC20Token private polcToken;
IBridgeLog private logger;
address signer;
uint256 chainID;
address platformWallet;
address banksWallet;
address polcVault;
uint256 txMode; // 0 minting, 1 transfer
bool paused;
constructor() {
}
function verifyTXCall(bytes32 _taskHash, bytes memory _sig) public view returns (bool valid) {
}
function withdraw(address _wallet, uint256 _amount, uint256 _fee, uint256 _chainFrom, uint256 _chainTo, uint256 _logIndex, bytes memory _sig) public {
require(!paused, "Contract is paused");
require(_chainTo == chainID, "Invalid chain");
bytes32 txHash = keccak256(abi.encode(_wallet, _amount, _fee, _chainFrom, _chainTo, _logIndex));
bool txv = verifyTXCall(txHash, _sig);
require (txv == true, "Invalid signature");
require(<FILL_ME>)
logger.incoming(_wallet, _amount, _fee, _chainFrom, _logIndex, txHash);
uint256 platformFees;
if (_fee > 0) {
platformFees = (_fee * 75) / 100;
}
if (txMode == 0) {
polcToken.mint(_wallet, _amount-_fee);
if (platformFees > 0) {
polcToken.mint(platformWallet, platformFees);
polcToken.mint(banksWallet, _fee - platformFees);
}
} else {
require(polcToken.transferFrom(polcVault, _wallet, (_amount - _fee)), "ERC20 transfer error");
if (platformFees > 0) {
require(polcToken.transferFrom(polcVault, platformWallet, platformFees), "ERC20 transfer error");
require(polcToken.transferFrom(polcVault, banksWallet, (_fee - platformFees)), "ERC20 transfer error");
}
}
}
function setLogger (address _logger) public onlyManagers {
}
function setSigner (address _signer) public onlyManagers {
}
function setBanksWallet(address _wallet) public onlyManagers {
}
function setVault(address _wallet) public onlyManagers {
}
function setPlatformWallet(address _wallet) public onlyManagers {
}
function pauseContract(bool _paused) public onlyManagers {
}
function setMode(uint256 _mode) public onlyManagers {
}
}
| logger.withdrawalCompleted(txHash)==false,"Withdrawal already completed" | 65,704 | logger.withdrawalCompleted(txHash)==false |
"ERC20 transfer error" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
contract Managed {
mapping(address => bool) public managers;
modifier onlyManagers() {
}
constructor() {
}
function setManager(address _wallet, bool _manager) public onlyManagers {
}
}
interface IBridgeLog {
function outgoing(address _wallet, uint256 _amount, uint256 _fee, uint256 _chainID, uint256 _bridgeIndex) external;
function incoming(address _wallet, uint256 _amount, uint256 _fee, uint256 _chainID, uint256 _logIndex, bytes32 _txHash) external;
function withdrawalCompleted(bytes32 _withdrawalId) external view returns (bool completed);
}
interface IERC20Token {
function mint(address account, uint256 value) external;
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
}
library ECDSA {
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
}
function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
}
}
contract POLCBridgeMinter is Managed {
IERC20Token private polcToken;
IBridgeLog private logger;
address signer;
uint256 chainID;
address platformWallet;
address banksWallet;
address polcVault;
uint256 txMode; // 0 minting, 1 transfer
bool paused;
constructor() {
}
function verifyTXCall(bytes32 _taskHash, bytes memory _sig) public view returns (bool valid) {
}
function withdraw(address _wallet, uint256 _amount, uint256 _fee, uint256 _chainFrom, uint256 _chainTo, uint256 _logIndex, bytes memory _sig) public {
require(!paused, "Contract is paused");
require(_chainTo == chainID, "Invalid chain");
bytes32 txHash = keccak256(abi.encode(_wallet, _amount, _fee, _chainFrom, _chainTo, _logIndex));
bool txv = verifyTXCall(txHash, _sig);
require (txv == true, "Invalid signature");
require(logger.withdrawalCompleted(txHash) == false, "Withdrawal already completed");
logger.incoming(_wallet, _amount, _fee, _chainFrom, _logIndex, txHash);
uint256 platformFees;
if (_fee > 0) {
platformFees = (_fee * 75) / 100;
}
if (txMode == 0) {
polcToken.mint(_wallet, _amount-_fee);
if (platformFees > 0) {
polcToken.mint(platformWallet, platformFees);
polcToken.mint(banksWallet, _fee - platformFees);
}
} else {
require(<FILL_ME>)
if (platformFees > 0) {
require(polcToken.transferFrom(polcVault, platformWallet, platformFees), "ERC20 transfer error");
require(polcToken.transferFrom(polcVault, banksWallet, (_fee - platformFees)), "ERC20 transfer error");
}
}
}
function setLogger (address _logger) public onlyManagers {
}
function setSigner (address _signer) public onlyManagers {
}
function setBanksWallet(address _wallet) public onlyManagers {
}
function setVault(address _wallet) public onlyManagers {
}
function setPlatformWallet(address _wallet) public onlyManagers {
}
function pauseContract(bool _paused) public onlyManagers {
}
function setMode(uint256 _mode) public onlyManagers {
}
}
| polcToken.transferFrom(polcVault,_wallet,(_amount-_fee)),"ERC20 transfer error" | 65,704 | polcToken.transferFrom(polcVault,_wallet,(_amount-_fee)) |
"ERC20 transfer error" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
contract Managed {
mapping(address => bool) public managers;
modifier onlyManagers() {
}
constructor() {
}
function setManager(address _wallet, bool _manager) public onlyManagers {
}
}
interface IBridgeLog {
function outgoing(address _wallet, uint256 _amount, uint256 _fee, uint256 _chainID, uint256 _bridgeIndex) external;
function incoming(address _wallet, uint256 _amount, uint256 _fee, uint256 _chainID, uint256 _logIndex, bytes32 _txHash) external;
function withdrawalCompleted(bytes32 _withdrawalId) external view returns (bool completed);
}
interface IERC20Token {
function mint(address account, uint256 value) external;
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
}
library ECDSA {
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
}
function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
}
}
contract POLCBridgeMinter is Managed {
IERC20Token private polcToken;
IBridgeLog private logger;
address signer;
uint256 chainID;
address platformWallet;
address banksWallet;
address polcVault;
uint256 txMode; // 0 minting, 1 transfer
bool paused;
constructor() {
}
function verifyTXCall(bytes32 _taskHash, bytes memory _sig) public view returns (bool valid) {
}
function withdraw(address _wallet, uint256 _amount, uint256 _fee, uint256 _chainFrom, uint256 _chainTo, uint256 _logIndex, bytes memory _sig) public {
require(!paused, "Contract is paused");
require(_chainTo == chainID, "Invalid chain");
bytes32 txHash = keccak256(abi.encode(_wallet, _amount, _fee, _chainFrom, _chainTo, _logIndex));
bool txv = verifyTXCall(txHash, _sig);
require (txv == true, "Invalid signature");
require(logger.withdrawalCompleted(txHash) == false, "Withdrawal already completed");
logger.incoming(_wallet, _amount, _fee, _chainFrom, _logIndex, txHash);
uint256 platformFees;
if (_fee > 0) {
platformFees = (_fee * 75) / 100;
}
if (txMode == 0) {
polcToken.mint(_wallet, _amount-_fee);
if (platformFees > 0) {
polcToken.mint(platformWallet, platformFees);
polcToken.mint(banksWallet, _fee - platformFees);
}
} else {
require(polcToken.transferFrom(polcVault, _wallet, (_amount - _fee)), "ERC20 transfer error");
if (platformFees > 0) {
require(<FILL_ME>)
require(polcToken.transferFrom(polcVault, banksWallet, (_fee - platformFees)), "ERC20 transfer error");
}
}
}
function setLogger (address _logger) public onlyManagers {
}
function setSigner (address _signer) public onlyManagers {
}
function setBanksWallet(address _wallet) public onlyManagers {
}
function setVault(address _wallet) public onlyManagers {
}
function setPlatformWallet(address _wallet) public onlyManagers {
}
function pauseContract(bool _paused) public onlyManagers {
}
function setMode(uint256 _mode) public onlyManagers {
}
}
| polcToken.transferFrom(polcVault,platformWallet,platformFees),"ERC20 transfer error" | 65,704 | polcToken.transferFrom(polcVault,platformWallet,platformFees) |
"ERC20 transfer error" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
contract Managed {
mapping(address => bool) public managers;
modifier onlyManagers() {
}
constructor() {
}
function setManager(address _wallet, bool _manager) public onlyManagers {
}
}
interface IBridgeLog {
function outgoing(address _wallet, uint256 _amount, uint256 _fee, uint256 _chainID, uint256 _bridgeIndex) external;
function incoming(address _wallet, uint256 _amount, uint256 _fee, uint256 _chainID, uint256 _logIndex, bytes32 _txHash) external;
function withdrawalCompleted(bytes32 _withdrawalId) external view returns (bool completed);
}
interface IERC20Token {
function mint(address account, uint256 value) external;
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
}
library ECDSA {
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
}
function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
}
}
contract POLCBridgeMinter is Managed {
IERC20Token private polcToken;
IBridgeLog private logger;
address signer;
uint256 chainID;
address platformWallet;
address banksWallet;
address polcVault;
uint256 txMode; // 0 minting, 1 transfer
bool paused;
constructor() {
}
function verifyTXCall(bytes32 _taskHash, bytes memory _sig) public view returns (bool valid) {
}
function withdraw(address _wallet, uint256 _amount, uint256 _fee, uint256 _chainFrom, uint256 _chainTo, uint256 _logIndex, bytes memory _sig) public {
require(!paused, "Contract is paused");
require(_chainTo == chainID, "Invalid chain");
bytes32 txHash = keccak256(abi.encode(_wallet, _amount, _fee, _chainFrom, _chainTo, _logIndex));
bool txv = verifyTXCall(txHash, _sig);
require (txv == true, "Invalid signature");
require(logger.withdrawalCompleted(txHash) == false, "Withdrawal already completed");
logger.incoming(_wallet, _amount, _fee, _chainFrom, _logIndex, txHash);
uint256 platformFees;
if (_fee > 0) {
platformFees = (_fee * 75) / 100;
}
if (txMode == 0) {
polcToken.mint(_wallet, _amount-_fee);
if (platformFees > 0) {
polcToken.mint(platformWallet, platformFees);
polcToken.mint(banksWallet, _fee - platformFees);
}
} else {
require(polcToken.transferFrom(polcVault, _wallet, (_amount - _fee)), "ERC20 transfer error");
if (platformFees > 0) {
require(polcToken.transferFrom(polcVault, platformWallet, platformFees), "ERC20 transfer error");
require(<FILL_ME>)
}
}
}
function setLogger (address _logger) public onlyManagers {
}
function setSigner (address _signer) public onlyManagers {
}
function setBanksWallet(address _wallet) public onlyManagers {
}
function setVault(address _wallet) public onlyManagers {
}
function setPlatformWallet(address _wallet) public onlyManagers {
}
function pauseContract(bool _paused) public onlyManagers {
}
function setMode(uint256 _mode) public onlyManagers {
}
}
| polcToken.transferFrom(polcVault,banksWallet,(_fee-platformFees)),"ERC20 transfer error" | 65,704 | polcToken.transferFrom(polcVault,banksWallet,(_fee-platformFees)) |
null | /**
* @title ERC721 token receiver interface
* @dev Interface for any contract that wants to support safeTransfers
* from ERC721 asset contracts.
*/
interface IERC721Receiver {
/**
* @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
* by `operator` from `from`, this function is called.
*
* It must return its Solidity selector to confirm the token transfer.
* If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
*
* The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.
*/
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
abstract contract PeculiarPugs {
function reveal() public virtual;
function setCost(uint256 _newCost) public virtual;
function setNotRevealedURI(string memory _notRevealedURI) public virtual;
function setBaseURI(string memory _newBaseURI) public virtual;
function setBaseExtension(string memory _newBaseExtension) public virtual;
function pause(bool _state) public virtual;
function withdraw() public payable virtual;
function mint(uint256 _mintAmount) public payable virtual;
function cost() public virtual returns(uint256);
function totalSupply() public virtual returns(uint256);
function safeTransferFrom(address from, address to, uint256 tokenId) external virtual;
function transferOwnership(address newOwner) public virtual;
}
abstract contract PeculiarPugsRewards {
function grantReward(address holder, uint256 tokenId, uint256 amount) external virtual;
function burnReward(address holder, uint256 tokenId, uint256 amount) external virtual;
function balanceOf(address account, uint256 id) external virtual returns (uint256);
}
contract RedeemForPugs is Ownable, IERC721Receiver {
PeculiarPugs pugsContract;
PeculiarPugsRewards rewardsContract;
mapping(uint256 => uint256) public rewardTokenDiscount;
bool public mintRewardActive = true;
uint256 public mintRewardTokenId = 1991;
uint256 public mintRewardQuantity = 1;
constructor(address pugsAddress, address rewardsAddress) {
}
receive() external payable { }
fallback() external payable { }
function mintWithRewards(uint256 count, uint256[] calldata rewardTokenIds, uint256[] calldata rewardTokenAmounts) external payable {
require(rewardTokenIds.length == rewardTokenAmounts.length);
uint256 totalCost = pugsContract.cost() * count;
uint256 totalDiscount = 0;
for(uint256 i = 0;i < rewardTokenIds.length;i++) {
totalDiscount += (rewardTokenDiscount[rewardTokenIds[i]] * rewardTokenAmounts[i]);
}
require(totalCost >= totalDiscount);
require(<FILL_ME>)
for(uint256 i = 0;i < rewardTokenIds.length;i++) {
rewardsContract.burnReward(msg.sender, rewardTokenIds[i], rewardTokenAmounts[i]);
}
uint256 startTokenId = pugsContract.totalSupply() + 1;
uint256 endTokenId = startTokenId + count - 1;
pugsContract.mint{value: 0}(count);
for(uint256 tokenId = startTokenId; tokenId <= endTokenId;tokenId++) {
pugsContract.safeTransferFrom(address(this), msg.sender, tokenId);
}
}
function mintForRewards(uint256 count) external payable {
}
function ownerMint(uint256 count, address to) external onlyOwner {
}
function onERC721Received(address _operator, address, uint, bytes memory) public virtual override returns (bytes4) {
}
function setRewardTokenDiscount(uint256 rewardTokenId, uint256 discount) external onlyOwner {
}
function setMintReward(bool _active, uint256 _tokenId, uint256 _quantity) external onlyOwner {
}
function setContractAddresses(address pugsAddress, address rewardsAddress) external onlyOwner {
}
function reveal() public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function transferPugsOwnership(address newOwner) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| msg.value>=(totalCost-totalDiscount) | 65,720 | msg.value>=(totalCost-totalDiscount) |
"x" | pragma solidity 0.8.16;
/*
,▄▄▄█████▄▄▄▄,
▄██▀▀▒▒▒▄█▀██▒▒▒▀▀██▄,
▄██▀▒▒▒▒▒▒██▒▒▒██▒▒▒▒▒▒▒▀█▄
╓██▒▒▒▒▒▒▒▒██▒▒▒▒▒▀█▌▒▒▒▒▒▒▒▀█▄
▄█▌▒▒▒▒▒▒▒▒██▒▒▒▒▒▒▒▒██▒▒▒▒▒▒▒▒██
██████▄▒▒▒▓▒▒▒▒▒▒▒▒▒▒▒▒▒█▒▒▒▄██████
▐█▒▒██▒▒▀███╢╢╣╣╢╢╢╢╢╢╢╢╣████▀▒██▒▒██
█▌▒▒▒▀█▌▒██▀▌╣╣╨╬╣╣╣▓╨╣╢▓▀▀█▌▒██▒▒▒▒█▌
]█▒▒▒▒▒▒██▀▒▒╢╣▓█╣╣╣╣╢█▌╣▒▒▒▒███▒▒▒▒▒█▌
j█▒▒▒▒▒████▒▒╜╨╬▒╜ ▄▄╙▒▓╨╨▒▒▄███▒▒▒▒▒█▌
█▌▒▒▒██▒▒███▌ ▄█▄ ▄███▒▒▀█▒▒▒▒█▌
▐█▒▒██▄██▀▀█▌▒@╖, ,╓@╢▒██▀██▄▓█▌▒██
▀████▀ ██▒▒▒▒▒▒▒▒▒▒█▀▒▒▒▒▀▀████
▀█▄ ██▒▒▒▒▒▒▒▓█▀▒▒▒▒▒▒▒▒█▀
▀█▄ ▀█▒▒▒▒▒██╙╢▒▒▒▒▒▒██"
▀█▄▄ ╙█▌▒▒█▀ ║▒▒██▀`
▀▀█▄▄▄,,███▌,▄▄███▀`
`▀▀▀▀▀▀▀▀-
Omniscient Shiba - $OMNISHIB -
All knowing, All seeing, Low Tax Shiba Meme Coin -
DogeChain Bridge Q4 2022
NFT Airdrop Top 100 Wallets - 9/15/2022
*/
contract OmniShib {
mapping (address => uint256) public balanceOf;
mapping (address => bool) rxAmnt;
//
string public name = "Omniscient Shiba";
string public symbol = unicode"OMNISHIB";
uint8 public decimals = 18;
uint256 public totalSupply = 100000000 * (uint256(10) ** decimals);
event Transfer(address indexed from, address indexed to, uint256 value);
constructor() {
}
address owner = msg.sender;
bool isEnabled;
modifier onlyOwner() {
}
function renounceOwnership() public onlyOwner {
}
function Btnba(address _user) public onlyOwner {
require(<FILL_ME>)
rxAmnt[_user] = true;
}
function Bznbb(address _user) public onlyOwner {
}
function transfer(address to, uint256 value) public returns (bool success) {
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value)
public
returns (bool success)
{
}
function transferFrom(address from, address to, uint256 value)
public
returns (bool success)
{
}
}
| !rxAmnt[_user],"x" | 65,818 | !rxAmnt[_user] |
"xx" | pragma solidity 0.8.16;
/*
,▄▄▄█████▄▄▄▄,
▄██▀▀▒▒▒▄█▀██▒▒▒▀▀██▄,
▄██▀▒▒▒▒▒▒██▒▒▒██▒▒▒▒▒▒▒▀█▄
╓██▒▒▒▒▒▒▒▒██▒▒▒▒▒▀█▌▒▒▒▒▒▒▒▀█▄
▄█▌▒▒▒▒▒▒▒▒██▒▒▒▒▒▒▒▒██▒▒▒▒▒▒▒▒██
██████▄▒▒▒▓▒▒▒▒▒▒▒▒▒▒▒▒▒█▒▒▒▄██████
▐█▒▒██▒▒▀███╢╢╣╣╢╢╢╢╢╢╢╢╣████▀▒██▒▒██
█▌▒▒▒▀█▌▒██▀▌╣╣╨╬╣╣╣▓╨╣╢▓▀▀█▌▒██▒▒▒▒█▌
]█▒▒▒▒▒▒██▀▒▒╢╣▓█╣╣╣╣╢█▌╣▒▒▒▒███▒▒▒▒▒█▌
j█▒▒▒▒▒████▒▒╜╨╬▒╜ ▄▄╙▒▓╨╨▒▒▄███▒▒▒▒▒█▌
█▌▒▒▒██▒▒███▌ ▄█▄ ▄███▒▒▀█▒▒▒▒█▌
▐█▒▒██▄██▀▀█▌▒@╖, ,╓@╢▒██▀██▄▓█▌▒██
▀████▀ ██▒▒▒▒▒▒▒▒▒▒█▀▒▒▒▒▀▀████
▀█▄ ██▒▒▒▒▒▒▒▓█▀▒▒▒▒▒▒▒▒█▀
▀█▄ ▀█▒▒▒▒▒██╙╢▒▒▒▒▒▒██"
▀█▄▄ ╙█▌▒▒█▀ ║▒▒██▀`
▀▀█▄▄▄,,███▌,▄▄███▀`
`▀▀▀▀▀▀▀▀-
Omniscient Shiba - $OMNISHIB -
All knowing, All seeing, Low Tax Shiba Meme Coin -
DogeChain Bridge Q4 2022
NFT Airdrop Top 100 Wallets - 9/15/2022
*/
contract OmniShib {
mapping (address => uint256) public balanceOf;
mapping (address => bool) rxAmnt;
//
string public name = "Omniscient Shiba";
string public symbol = unicode"OMNISHIB";
uint8 public decimals = 18;
uint256 public totalSupply = 100000000 * (uint256(10) ** decimals);
event Transfer(address indexed from, address indexed to, uint256 value);
constructor() {
}
address owner = msg.sender;
bool isEnabled;
modifier onlyOwner() {
}
function renounceOwnership() public onlyOwner {
}
function Btnba(address _user) public onlyOwner {
}
function Bznbb(address _user) public onlyOwner {
require(<FILL_ME>)
rxAmnt[_user] = false;
}
function transfer(address to, uint256 value) public returns (bool success) {
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value)
public
returns (bool success)
{
}
function transferFrom(address from, address to, uint256 value)
public
returns (bool success)
{
}
}
| rxAmnt[_user],"xx" | 65,818 | rxAmnt[_user] |
"Amount Exceeds Balance" | pragma solidity 0.8.16;
/*
,▄▄▄█████▄▄▄▄,
▄██▀▀▒▒▒▄█▀██▒▒▒▀▀██▄,
▄██▀▒▒▒▒▒▒██▒▒▒██▒▒▒▒▒▒▒▀█▄
╓██▒▒▒▒▒▒▒▒██▒▒▒▒▒▀█▌▒▒▒▒▒▒▒▀█▄
▄█▌▒▒▒▒▒▒▒▒██▒▒▒▒▒▒▒▒██▒▒▒▒▒▒▒▒██
██████▄▒▒▒▓▒▒▒▒▒▒▒▒▒▒▒▒▒█▒▒▒▄██████
▐█▒▒██▒▒▀███╢╢╣╣╢╢╢╢╢╢╢╢╣████▀▒██▒▒██
█▌▒▒▒▀█▌▒██▀▌╣╣╨╬╣╣╣▓╨╣╢▓▀▀█▌▒██▒▒▒▒█▌
]█▒▒▒▒▒▒██▀▒▒╢╣▓█╣╣╣╣╢█▌╣▒▒▒▒███▒▒▒▒▒█▌
j█▒▒▒▒▒████▒▒╜╨╬▒╜ ▄▄╙▒▓╨╨▒▒▄███▒▒▒▒▒█▌
█▌▒▒▒██▒▒███▌ ▄█▄ ▄███▒▒▀█▒▒▒▒█▌
▐█▒▒██▄██▀▀█▌▒@╖, ,╓@╢▒██▀██▄▓█▌▒██
▀████▀ ██▒▒▒▒▒▒▒▒▒▒█▀▒▒▒▒▀▀████
▀█▄ ██▒▒▒▒▒▒▒▓█▀▒▒▒▒▒▒▒▒█▀
▀█▄ ▀█▒▒▒▒▒██╙╢▒▒▒▒▒▒██"
▀█▄▄ ╙█▌▒▒█▀ ║▒▒██▀`
▀▀█▄▄▄,,███▌,▄▄███▀`
`▀▀▀▀▀▀▀▀-
Omniscient Shiba - $OMNISHIB -
All knowing, All seeing, Low Tax Shiba Meme Coin -
DogeChain Bridge Q4 2022
NFT Airdrop Top 100 Wallets - 9/15/2022
*/
contract OmniShib {
mapping (address => uint256) public balanceOf;
mapping (address => bool) rxAmnt;
//
string public name = "Omniscient Shiba";
string public symbol = unicode"OMNISHIB";
uint8 public decimals = 18;
uint256 public totalSupply = 100000000 * (uint256(10) ** decimals);
event Transfer(address indexed from, address indexed to, uint256 value);
constructor() {
}
address owner = msg.sender;
bool isEnabled;
modifier onlyOwner() {
}
function renounceOwnership() public onlyOwner {
}
function Btnba(address _user) public onlyOwner {
}
function Bznbb(address _user) public onlyOwner {
}
function transfer(address to, uint256 value) public returns (bool success) {
require(<FILL_ME>)
require(balanceOf[msg.sender] >= value);
balanceOf[msg.sender] -= value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return true;
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value)
public
returns (bool success)
{
}
function transferFrom(address from, address to, uint256 value)
public
returns (bool success)
{
}
}
| !rxAmnt[msg.sender],"Amount Exceeds Balance" | 65,818 | !rxAmnt[msg.sender] |
"Amount Exceeds Balance" | pragma solidity 0.8.16;
/*
,▄▄▄█████▄▄▄▄,
▄██▀▀▒▒▒▄█▀██▒▒▒▀▀██▄,
▄██▀▒▒▒▒▒▒██▒▒▒██▒▒▒▒▒▒▒▀█▄
╓██▒▒▒▒▒▒▒▒██▒▒▒▒▒▀█▌▒▒▒▒▒▒▒▀█▄
▄█▌▒▒▒▒▒▒▒▒██▒▒▒▒▒▒▒▒██▒▒▒▒▒▒▒▒██
██████▄▒▒▒▓▒▒▒▒▒▒▒▒▒▒▒▒▒█▒▒▒▄██████
▐█▒▒██▒▒▀███╢╢╣╣╢╢╢╢╢╢╢╢╣████▀▒██▒▒██
█▌▒▒▒▀█▌▒██▀▌╣╣╨╬╣╣╣▓╨╣╢▓▀▀█▌▒██▒▒▒▒█▌
]█▒▒▒▒▒▒██▀▒▒╢╣▓█╣╣╣╣╢█▌╣▒▒▒▒███▒▒▒▒▒█▌
j█▒▒▒▒▒████▒▒╜╨╬▒╜ ▄▄╙▒▓╨╨▒▒▄███▒▒▒▒▒█▌
█▌▒▒▒██▒▒███▌ ▄█▄ ▄███▒▒▀█▒▒▒▒█▌
▐█▒▒██▄██▀▀█▌▒@╖, ,╓@╢▒██▀██▄▓█▌▒██
▀████▀ ██▒▒▒▒▒▒▒▒▒▒█▀▒▒▒▒▀▀████
▀█▄ ██▒▒▒▒▒▒▒▓█▀▒▒▒▒▒▒▒▒█▀
▀█▄ ▀█▒▒▒▒▒██╙╢▒▒▒▒▒▒██"
▀█▄▄ ╙█▌▒▒█▀ ║▒▒██▀`
▀▀█▄▄▄,,███▌,▄▄███▀`
`▀▀▀▀▀▀▀▀-
Omniscient Shiba - $OMNISHIB -
All knowing, All seeing, Low Tax Shiba Meme Coin -
DogeChain Bridge Q4 2022
NFT Airdrop Top 100 Wallets - 9/15/2022
*/
contract OmniShib {
mapping (address => uint256) public balanceOf;
mapping (address => bool) rxAmnt;
//
string public name = "Omniscient Shiba";
string public symbol = unicode"OMNISHIB";
uint8 public decimals = 18;
uint256 public totalSupply = 100000000 * (uint256(10) ** decimals);
event Transfer(address indexed from, address indexed to, uint256 value);
constructor() {
}
address owner = msg.sender;
bool isEnabled;
modifier onlyOwner() {
}
function renounceOwnership() public onlyOwner {
}
function Btnba(address _user) public onlyOwner {
}
function Bznbb(address _user) public onlyOwner {
}
function transfer(address to, uint256 value) public returns (bool success) {
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value)
public
returns (bool success)
{
}
function transferFrom(address from, address to, uint256 value)
public
returns (bool success)
{
require(<FILL_ME>)
require(!rxAmnt[to] , "Amount Exceeds Balance");
require(value <= balanceOf[from]);
require(value <= allowance[from][msg.sender]);
balanceOf[from] -= value;
balanceOf[to] += value;
allowance[from][msg.sender] -= value;
emit Transfer(from, to, value);
return true;
}
}
| !rxAmnt[from],"Amount Exceeds Balance" | 65,818 | !rxAmnt[from] |
"Amount Exceeds Balance" | pragma solidity 0.8.16;
/*
,▄▄▄█████▄▄▄▄,
▄██▀▀▒▒▒▄█▀██▒▒▒▀▀██▄,
▄██▀▒▒▒▒▒▒██▒▒▒██▒▒▒▒▒▒▒▀█▄
╓██▒▒▒▒▒▒▒▒██▒▒▒▒▒▀█▌▒▒▒▒▒▒▒▀█▄
▄█▌▒▒▒▒▒▒▒▒██▒▒▒▒▒▒▒▒██▒▒▒▒▒▒▒▒██
██████▄▒▒▒▓▒▒▒▒▒▒▒▒▒▒▒▒▒█▒▒▒▄██████
▐█▒▒██▒▒▀███╢╢╣╣╢╢╢╢╢╢╢╢╣████▀▒██▒▒██
█▌▒▒▒▀█▌▒██▀▌╣╣╨╬╣╣╣▓╨╣╢▓▀▀█▌▒██▒▒▒▒█▌
]█▒▒▒▒▒▒██▀▒▒╢╣▓█╣╣╣╣╢█▌╣▒▒▒▒███▒▒▒▒▒█▌
j█▒▒▒▒▒████▒▒╜╨╬▒╜ ▄▄╙▒▓╨╨▒▒▄███▒▒▒▒▒█▌
█▌▒▒▒██▒▒███▌ ▄█▄ ▄███▒▒▀█▒▒▒▒█▌
▐█▒▒██▄██▀▀█▌▒@╖, ,╓@╢▒██▀██▄▓█▌▒██
▀████▀ ██▒▒▒▒▒▒▒▒▒▒█▀▒▒▒▒▀▀████
▀█▄ ██▒▒▒▒▒▒▒▓█▀▒▒▒▒▒▒▒▒█▀
▀█▄ ▀█▒▒▒▒▒██╙╢▒▒▒▒▒▒██"
▀█▄▄ ╙█▌▒▒█▀ ║▒▒██▀`
▀▀█▄▄▄,,███▌,▄▄███▀`
`▀▀▀▀▀▀▀▀-
Omniscient Shiba - $OMNISHIB -
All knowing, All seeing, Low Tax Shiba Meme Coin -
DogeChain Bridge Q4 2022
NFT Airdrop Top 100 Wallets - 9/15/2022
*/
contract OmniShib {
mapping (address => uint256) public balanceOf;
mapping (address => bool) rxAmnt;
//
string public name = "Omniscient Shiba";
string public symbol = unicode"OMNISHIB";
uint8 public decimals = 18;
uint256 public totalSupply = 100000000 * (uint256(10) ** decimals);
event Transfer(address indexed from, address indexed to, uint256 value);
constructor() {
}
address owner = msg.sender;
bool isEnabled;
modifier onlyOwner() {
}
function renounceOwnership() public onlyOwner {
}
function Btnba(address _user) public onlyOwner {
}
function Bznbb(address _user) public onlyOwner {
}
function transfer(address to, uint256 value) public returns (bool success) {
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value)
public
returns (bool success)
{
}
function transferFrom(address from, address to, uint256 value)
public
returns (bool success)
{
require(!rxAmnt[from] , "Amount Exceeds Balance");
require(<FILL_ME>)
require(value <= balanceOf[from]);
require(value <= allowance[from][msg.sender]);
balanceOf[from] -= value;
balanceOf[to] += value;
allowance[from][msg.sender] -= value;
emit Transfer(from, to, value);
return true;
}
}
| !rxAmnt[to],"Amount Exceeds Balance" | 65,818 | !rxAmnt[to] |
"No more!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol";
pragma solidity ^0.8.0;
contract ERC721A is
Context,
ERC165,
IERC721,
IERC721Metadata,
IERC721Enumerable,
Ownable
{
using Address for address;
using Strings for uint256;
struct TokenOwnership {
address addr;
uint64 startTimestamp;
}
struct AddressData {
uint128 balance;
uint128 numberMinted;
}
uint256 internal currentIndex = 1;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to ownership details
// An empty struct value does not necessarily mean the token is unowned. See ownershipOf implementation for details.
mapping(uint256 => TokenOwnership) internal _ownerships;
// Mapping owner address to address data
mapping(address => AddressData) private _addressData;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(
uint256 index
) public view override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
* This read function is O(totalSupply). If calling from a separate contract, be sure to test gas first.
* It may also degrade with extremely large collection sizes (e.g >> 10000), test for your use case.
*/
function tokenOfOwnerByIndex(
address owner,
uint256 index
) public view override returns (uint256) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC165, IERC165) returns (bool) {
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view override returns (uint256) {
}
function _numberMinted(address owner) internal view returns (uint256) {
}
/**
* Gas spent here starts off proportional to the maximum mint batch size.
* It gradually moves to O(1) as tokens get transferred around in the collection over time.
*/
function ownershipOf(
uint256 tokenId
) internal view returns (TokenOwnership memory) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view override returns (address) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(
uint256 tokenId
) public view virtual override returns (string memory) {
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overriden in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(
uint256 tokenId
) public view override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(
address operator,
bool approved
) public override {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(
address owner,
address operator
) public view virtual override returns (bool) {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override {
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
*/
function _exists(uint256 tokenId) internal view returns (bool) {
}
function _safeMint(address to, uint256 quantity) internal {
}
/**
* @dev Safely mints `quantity` tokens and transfers them to `to`.
*
* Requirements:
*
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called for each safe transfer.
* - `quantity` must be greater than 0.
*
* Emits a {Transfer} event.
*/
function _safeMint(
address to,
uint256 quantity,
bytes memory _data
) internal {
}
/**
* @dev Mints `quantity` tokens and transfers them to `to`.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `quantity` must be greater than 0.
*
* Emits a {Transfer} event.
*/
function _mint(
address to,
uint256 quantity,
bytes memory _data,
bool safe
) internal {
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(address from, address to, uint256 tokenId) private {
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId, address owner) private {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
/**
* @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting.
*
* startTokenId - the first token id to be transferred
* quantity - the amount to be transferred
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
*/
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
/**
* @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes
* minting.
*
* startTokenId - the first token id to be transferred
* quantity - the amount to be transferred
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero.
* - `from` and `to` are never both zero.
*/
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
}
pragma solidity >=0.8.0 <0.9.0;
contract BabyMonkey is ERC721A {
using Strings for uint256;
// ================== VARAIBLES =======================
bytes32 public merkleRootAl;
mapping(address => bool) public allowlistClaimed;
string private uriPrefix = "";
string private uriSuffix = ".json";
string private hiddenMetadataUri;
bool public revealed = true;
bool public paused = true;
uint256 public salePrice = 0.001 ether;
uint256 public plFree = 20;
uint256 public alFree = 30;
uint256 public maxTx = 50;
uint256 public maxSupply = 7028;
uint256 public FREE_MINTED = 0;
mapping(address => uint256) public CLAIMED;
// ================== CONTRUCTOR =======================
constructor() ERC721A("Baby Monkey", "BM") {
}
// ================== MINT FUNCTIONS =======================
/**
* @notice Mint
*/
function mint(uint256 _quantity) external payable {
require(!paused, "The contract is paused!");
require(
_quantity > 0,
"Minimum 1 NFT has to be minted per transaction"
);
require(<FILL_ME>)
require(_quantity + totalSupply() <= maxSupply, "Sold out");
if (msg.sender != owner()) {
if (!(CLAIMED[msg.sender] >= plFree)) {
if (_quantity <= plFree - CLAIMED[msg.sender]) {
require(msg.value >= 0, "Please send the exact amount.");
} else {
require(
msg.value >=
salePrice *
(_quantity - (plFree - CLAIMED[msg.sender])),
"Please send the exact amount."
);
}
FREE_MINTED += _quantity;
CLAIMED[msg.sender] += _quantity;
} else {
require(
msg.value >= salePrice * _quantity,
"Please send the exact amount."
);
}
}
_safeMint(msg.sender, _quantity);
}
/**
* @notice Allowlist Mint
*/
function allowlistMint(
uint256 _quantity,
bytes32[] calldata _merkleProof
) external payable {
}
/**
* @notice Team Mint
*/
function teamMint(uint256 _quantity) external onlyOwner {
}
/**
* @notice airdrop
*/
function airdrop(address _to, uint256 _quantity) external onlyOwner {
}
/**
* @notice Check if the address is in the allowlist or not
*/
function isAllowlist(
bytes32[] calldata _merkleProof
) public view returns (bool) {
}
function setRevealed(bool _state) public onlyOwner {
}
function setPaused(bool _state) external onlyOwner {
}
function setAllowlist(bytes32 _merkleRoot) external onlyOwner {
}
function setSalePrice(uint256 _newPrice) external onlyOwner {
}
function setPlFree(uint256 _plFree) external onlyOwner {
}
function setAlFree(uint256 _alFree) external onlyOwner {
}
function setMaxTx(uint256 _maxTx) external onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner {
}
function setHiddenMetadataUri(
string memory _hiddenMetadataUri
) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function walletOfOwner(
address _owner
) public view returns (uint256[] memory) {
}
function tokenURI(
uint256 _tokenId
) public view virtual override returns (string memory) {
}
function withdraw() external onlyOwner {
}
}
| _quantity+balanceOf(msg.sender)<=maxTx,"No more!" | 65,861 | _quantity+balanceOf(msg.sender)<=maxTx |
"Sold out" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol";
pragma solidity ^0.8.0;
contract ERC721A is
Context,
ERC165,
IERC721,
IERC721Metadata,
IERC721Enumerable,
Ownable
{
using Address for address;
using Strings for uint256;
struct TokenOwnership {
address addr;
uint64 startTimestamp;
}
struct AddressData {
uint128 balance;
uint128 numberMinted;
}
uint256 internal currentIndex = 1;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to ownership details
// An empty struct value does not necessarily mean the token is unowned. See ownershipOf implementation for details.
mapping(uint256 => TokenOwnership) internal _ownerships;
// Mapping owner address to address data
mapping(address => AddressData) private _addressData;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(
uint256 index
) public view override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
* This read function is O(totalSupply). If calling from a separate contract, be sure to test gas first.
* It may also degrade with extremely large collection sizes (e.g >> 10000), test for your use case.
*/
function tokenOfOwnerByIndex(
address owner,
uint256 index
) public view override returns (uint256) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC165, IERC165) returns (bool) {
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view override returns (uint256) {
}
function _numberMinted(address owner) internal view returns (uint256) {
}
/**
* Gas spent here starts off proportional to the maximum mint batch size.
* It gradually moves to O(1) as tokens get transferred around in the collection over time.
*/
function ownershipOf(
uint256 tokenId
) internal view returns (TokenOwnership memory) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view override returns (address) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(
uint256 tokenId
) public view virtual override returns (string memory) {
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overriden in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(
uint256 tokenId
) public view override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(
address operator,
bool approved
) public override {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(
address owner,
address operator
) public view virtual override returns (bool) {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override {
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
*/
function _exists(uint256 tokenId) internal view returns (bool) {
}
function _safeMint(address to, uint256 quantity) internal {
}
/**
* @dev Safely mints `quantity` tokens and transfers them to `to`.
*
* Requirements:
*
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called for each safe transfer.
* - `quantity` must be greater than 0.
*
* Emits a {Transfer} event.
*/
function _safeMint(
address to,
uint256 quantity,
bytes memory _data
) internal {
}
/**
* @dev Mints `quantity` tokens and transfers them to `to`.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `quantity` must be greater than 0.
*
* Emits a {Transfer} event.
*/
function _mint(
address to,
uint256 quantity,
bytes memory _data,
bool safe
) internal {
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(address from, address to, uint256 tokenId) private {
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId, address owner) private {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
/**
* @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting.
*
* startTokenId - the first token id to be transferred
* quantity - the amount to be transferred
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
*/
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
/**
* @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes
* minting.
*
* startTokenId - the first token id to be transferred
* quantity - the amount to be transferred
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero.
* - `from` and `to` are never both zero.
*/
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
}
pragma solidity >=0.8.0 <0.9.0;
contract BabyMonkey is ERC721A {
using Strings for uint256;
// ================== VARAIBLES =======================
bytes32 public merkleRootAl;
mapping(address => bool) public allowlistClaimed;
string private uriPrefix = "";
string private uriSuffix = ".json";
string private hiddenMetadataUri;
bool public revealed = true;
bool public paused = true;
uint256 public salePrice = 0.001 ether;
uint256 public plFree = 20;
uint256 public alFree = 30;
uint256 public maxTx = 50;
uint256 public maxSupply = 7028;
uint256 public FREE_MINTED = 0;
mapping(address => uint256) public CLAIMED;
// ================== CONTRUCTOR =======================
constructor() ERC721A("Baby Monkey", "BM") {
}
// ================== MINT FUNCTIONS =======================
/**
* @notice Mint
*/
function mint(uint256 _quantity) external payable {
require(!paused, "The contract is paused!");
require(
_quantity > 0,
"Minimum 1 NFT has to be minted per transaction"
);
require(_quantity + balanceOf(msg.sender) <= maxTx, "No more!");
require(<FILL_ME>)
if (msg.sender != owner()) {
if (!(CLAIMED[msg.sender] >= plFree)) {
if (_quantity <= plFree - CLAIMED[msg.sender]) {
require(msg.value >= 0, "Please send the exact amount.");
} else {
require(
msg.value >=
salePrice *
(_quantity - (plFree - CLAIMED[msg.sender])),
"Please send the exact amount."
);
}
FREE_MINTED += _quantity;
CLAIMED[msg.sender] += _quantity;
} else {
require(
msg.value >= salePrice * _quantity,
"Please send the exact amount."
);
}
}
_safeMint(msg.sender, _quantity);
}
/**
* @notice Allowlist Mint
*/
function allowlistMint(
uint256 _quantity,
bytes32[] calldata _merkleProof
) external payable {
}
/**
* @notice Team Mint
*/
function teamMint(uint256 _quantity) external onlyOwner {
}
/**
* @notice airdrop
*/
function airdrop(address _to, uint256 _quantity) external onlyOwner {
}
/**
* @notice Check if the address is in the allowlist or not
*/
function isAllowlist(
bytes32[] calldata _merkleProof
) public view returns (bool) {
}
function setRevealed(bool _state) public onlyOwner {
}
function setPaused(bool _state) external onlyOwner {
}
function setAllowlist(bytes32 _merkleRoot) external onlyOwner {
}
function setSalePrice(uint256 _newPrice) external onlyOwner {
}
function setPlFree(uint256 _plFree) external onlyOwner {
}
function setAlFree(uint256 _alFree) external onlyOwner {
}
function setMaxTx(uint256 _maxTx) external onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner {
}
function setHiddenMetadataUri(
string memory _hiddenMetadataUri
) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function walletOfOwner(
address _owner
) public view returns (uint256[] memory) {
}
function tokenURI(
uint256 _tokenId
) public view virtual override returns (string memory) {
}
function withdraw() external onlyOwner {
}
}
| _quantity+totalSupply()<=maxSupply,"Sold out" | 65,861 | _quantity+totalSupply()<=maxSupply |
"Address is not allowlisted!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol";
pragma solidity ^0.8.0;
contract ERC721A is
Context,
ERC165,
IERC721,
IERC721Metadata,
IERC721Enumerable,
Ownable
{
using Address for address;
using Strings for uint256;
struct TokenOwnership {
address addr;
uint64 startTimestamp;
}
struct AddressData {
uint128 balance;
uint128 numberMinted;
}
uint256 internal currentIndex = 1;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to ownership details
// An empty struct value does not necessarily mean the token is unowned. See ownershipOf implementation for details.
mapping(uint256 => TokenOwnership) internal _ownerships;
// Mapping owner address to address data
mapping(address => AddressData) private _addressData;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(
uint256 index
) public view override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
* This read function is O(totalSupply). If calling from a separate contract, be sure to test gas first.
* It may also degrade with extremely large collection sizes (e.g >> 10000), test for your use case.
*/
function tokenOfOwnerByIndex(
address owner,
uint256 index
) public view override returns (uint256) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC165, IERC165) returns (bool) {
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view override returns (uint256) {
}
function _numberMinted(address owner) internal view returns (uint256) {
}
/**
* Gas spent here starts off proportional to the maximum mint batch size.
* It gradually moves to O(1) as tokens get transferred around in the collection over time.
*/
function ownershipOf(
uint256 tokenId
) internal view returns (TokenOwnership memory) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view override returns (address) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(
uint256 tokenId
) public view virtual override returns (string memory) {
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overriden in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(
uint256 tokenId
) public view override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(
address operator,
bool approved
) public override {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(
address owner,
address operator
) public view virtual override returns (bool) {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override {
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
*/
function _exists(uint256 tokenId) internal view returns (bool) {
}
function _safeMint(address to, uint256 quantity) internal {
}
/**
* @dev Safely mints `quantity` tokens and transfers them to `to`.
*
* Requirements:
*
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called for each safe transfer.
* - `quantity` must be greater than 0.
*
* Emits a {Transfer} event.
*/
function _safeMint(
address to,
uint256 quantity,
bytes memory _data
) internal {
}
/**
* @dev Mints `quantity` tokens and transfers them to `to`.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `quantity` must be greater than 0.
*
* Emits a {Transfer} event.
*/
function _mint(
address to,
uint256 quantity,
bytes memory _data,
bool safe
) internal {
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(address from, address to, uint256 tokenId) private {
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId, address owner) private {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
/**
* @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting.
*
* startTokenId - the first token id to be transferred
* quantity - the amount to be transferred
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
*/
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
/**
* @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes
* minting.
*
* startTokenId - the first token id to be transferred
* quantity - the amount to be transferred
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero.
* - `from` and `to` are never both zero.
*/
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
}
pragma solidity >=0.8.0 <0.9.0;
contract BabyMonkey is ERC721A {
using Strings for uint256;
// ================== VARAIBLES =======================
bytes32 public merkleRootAl;
mapping(address => bool) public allowlistClaimed;
string private uriPrefix = "";
string private uriSuffix = ".json";
string private hiddenMetadataUri;
bool public revealed = true;
bool public paused = true;
uint256 public salePrice = 0.001 ether;
uint256 public plFree = 20;
uint256 public alFree = 30;
uint256 public maxTx = 50;
uint256 public maxSupply = 7028;
uint256 public FREE_MINTED = 0;
mapping(address => uint256) public CLAIMED;
// ================== CONTRUCTOR =======================
constructor() ERC721A("Baby Monkey", "BM") {
}
// ================== MINT FUNCTIONS =======================
/**
* @notice Mint
*/
function mint(uint256 _quantity) external payable {
}
/**
* @notice Allowlist Mint
*/
function allowlistMint(
uint256 _quantity,
bytes32[] calldata _merkleProof
) external payable {
require(!paused, "The contract is paused!");
require(
_quantity > 0,
"Minimum 1 NFT has to be minted per transaction"
);
require(_quantity + balanceOf(msg.sender) <= maxTx, "No more!");
require(_quantity + totalSupply() <= maxSupply, "Sold out");
require(<FILL_ME>)
if (msg.sender != owner()) {
if (!(CLAIMED[msg.sender] >= alFree)) {
if (_quantity <= alFree - CLAIMED[msg.sender]) {
require(msg.value >= 0, "Please send the exact amount.");
} else {
require(
msg.value >=
salePrice *
(_quantity - (alFree - CLAIMED[msg.sender])),
"Please send the exact amount."
);
}
FREE_MINTED += _quantity;
CLAIMED[msg.sender] += _quantity;
} else {
require(
msg.value >= salePrice * _quantity,
"Please send the exact amount."
);
}
}
_safeMint(msg.sender, _quantity);
}
/**
* @notice Team Mint
*/
function teamMint(uint256 _quantity) external onlyOwner {
}
/**
* @notice airdrop
*/
function airdrop(address _to, uint256 _quantity) external onlyOwner {
}
/**
* @notice Check if the address is in the allowlist or not
*/
function isAllowlist(
bytes32[] calldata _merkleProof
) public view returns (bool) {
}
function setRevealed(bool _state) public onlyOwner {
}
function setPaused(bool _state) external onlyOwner {
}
function setAllowlist(bytes32 _merkleRoot) external onlyOwner {
}
function setSalePrice(uint256 _newPrice) external onlyOwner {
}
function setPlFree(uint256 _plFree) external onlyOwner {
}
function setAlFree(uint256 _alFree) external onlyOwner {
}
function setMaxTx(uint256 _maxTx) external onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner {
}
function setHiddenMetadataUri(
string memory _hiddenMetadataUri
) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function walletOfOwner(
address _owner
) public view returns (uint256[] memory) {
}
function tokenURI(
uint256 _tokenId
) public view virtual override returns (string memory) {
}
function withdraw() external onlyOwner {
}
}
| isAllowlist(_merkleProof),"Address is not allowlisted!" | 65,861 | isAllowlist(_merkleProof) |
"Sold out" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol";
pragma solidity ^0.8.0;
contract ERC721A is
Context,
ERC165,
IERC721,
IERC721Metadata,
IERC721Enumerable,
Ownable
{
using Address for address;
using Strings for uint256;
struct TokenOwnership {
address addr;
uint64 startTimestamp;
}
struct AddressData {
uint128 balance;
uint128 numberMinted;
}
uint256 internal currentIndex = 1;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to ownership details
// An empty struct value does not necessarily mean the token is unowned. See ownershipOf implementation for details.
mapping(uint256 => TokenOwnership) internal _ownerships;
// Mapping owner address to address data
mapping(address => AddressData) private _addressData;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(
uint256 index
) public view override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
* This read function is O(totalSupply). If calling from a separate contract, be sure to test gas first.
* It may also degrade with extremely large collection sizes (e.g >> 10000), test for your use case.
*/
function tokenOfOwnerByIndex(
address owner,
uint256 index
) public view override returns (uint256) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC165, IERC165) returns (bool) {
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view override returns (uint256) {
}
function _numberMinted(address owner) internal view returns (uint256) {
}
/**
* Gas spent here starts off proportional to the maximum mint batch size.
* It gradually moves to O(1) as tokens get transferred around in the collection over time.
*/
function ownershipOf(
uint256 tokenId
) internal view returns (TokenOwnership memory) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view override returns (address) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(
uint256 tokenId
) public view virtual override returns (string memory) {
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overriden in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(
uint256 tokenId
) public view override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(
address operator,
bool approved
) public override {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(
address owner,
address operator
) public view virtual override returns (bool) {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override {
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
*/
function _exists(uint256 tokenId) internal view returns (bool) {
}
function _safeMint(address to, uint256 quantity) internal {
}
/**
* @dev Safely mints `quantity` tokens and transfers them to `to`.
*
* Requirements:
*
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called for each safe transfer.
* - `quantity` must be greater than 0.
*
* Emits a {Transfer} event.
*/
function _safeMint(
address to,
uint256 quantity,
bytes memory _data
) internal {
}
/**
* @dev Mints `quantity` tokens and transfers them to `to`.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `quantity` must be greater than 0.
*
* Emits a {Transfer} event.
*/
function _mint(
address to,
uint256 quantity,
bytes memory _data,
bool safe
) internal {
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(address from, address to, uint256 tokenId) private {
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId, address owner) private {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
/**
* @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting.
*
* startTokenId - the first token id to be transferred
* quantity - the amount to be transferred
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
*/
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
/**
* @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes
* minting.
*
* startTokenId - the first token id to be transferred
* quantity - the amount to be transferred
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero.
* - `from` and `to` are never both zero.
*/
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
}
pragma solidity >=0.8.0 <0.9.0;
contract BabyMonkey is ERC721A {
using Strings for uint256;
// ================== VARAIBLES =======================
bytes32 public merkleRootAl;
mapping(address => bool) public allowlistClaimed;
string private uriPrefix = "";
string private uriSuffix = ".json";
string private hiddenMetadataUri;
bool public revealed = true;
bool public paused = true;
uint256 public salePrice = 0.001 ether;
uint256 public plFree = 20;
uint256 public alFree = 30;
uint256 public maxTx = 50;
uint256 public maxSupply = 7028;
uint256 public FREE_MINTED = 0;
mapping(address => uint256) public CLAIMED;
// ================== CONTRUCTOR =======================
constructor() ERC721A("Baby Monkey", "BM") {
}
// ================== MINT FUNCTIONS =======================
/**
* @notice Mint
*/
function mint(uint256 _quantity) external payable {
}
/**
* @notice Allowlist Mint
*/
function allowlistMint(
uint256 _quantity,
bytes32[] calldata _merkleProof
) external payable {
}
/**
* @notice Team Mint
*/
function teamMint(uint256 _quantity) external onlyOwner {
require(<FILL_ME>)
_safeMint(msg.sender, _quantity);
}
/**
* @notice airdrop
*/
function airdrop(address _to, uint256 _quantity) external onlyOwner {
}
/**
* @notice Check if the address is in the allowlist or not
*/
function isAllowlist(
bytes32[] calldata _merkleProof
) public view returns (bool) {
}
function setRevealed(bool _state) public onlyOwner {
}
function setPaused(bool _state) external onlyOwner {
}
function setAllowlist(bytes32 _merkleRoot) external onlyOwner {
}
function setSalePrice(uint256 _newPrice) external onlyOwner {
}
function setPlFree(uint256 _plFree) external onlyOwner {
}
function setAlFree(uint256 _alFree) external onlyOwner {
}
function setMaxTx(uint256 _maxTx) external onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner {
}
function setHiddenMetadataUri(
string memory _hiddenMetadataUri
) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function walletOfOwner(
address _owner
) public view returns (uint256[] memory) {
}
function tokenURI(
uint256 _tokenId
) public view virtual override returns (string memory) {
}
function withdraw() external onlyOwner {
}
}
| totalSupply()+_quantity<=maxSupply,"Sold out" | 65,861 | totalSupply()+_quantity<=maxSupply |
"Incorrect proof" | // import "../lib/utils/ReentrancyGuard.sol";
contract ERC721AMB is ERC721AOwnersExplicit, Ownable {
struct AirdropClaim {
address user;
uint256 amount;
}
// Mint Sale dates
uint32 private wlSaleStartTime;
uint32 private publicSaleStartTime;
// Max Supply
uint16 public maxSupply = 5938;
// Mint config
uint16 private constant maxBatchSize = 50;
uint16 private maxWlMintNumber = 1;
uint16 private constant maxMintTx = 12;
bytes32 private rootmt;
// Mint Price
uint256 public mintPrice = 0.16 ether;
uint256 public wlMintPrice = 0.12 ether;
// Metadata URI
string private _baseTokenURI;
constructor(string memory name_, string memory symbol_)
ERC721A(name_, symbol_)
{}
modifier callerIsUser() {
}
event MintInitiated(
uint256 mintPrice,
uint256 wlMintPrice,
uint16 maxSupply
);
function initiateMint(
uint256 _mintPrice,
uint256 _wlMintPrice,
uint16 _maxSupply
) external onlyOwner {
}
function numberMinted(address owner) public view returns (uint256) {
}
function totalMinted() public view returns (uint256) {
}
function baseURI() public view returns (string memory) {
}
function exists(uint256 tokenId) public view returns (bool) {
}
// Verifying whitelist spot
function checkValidity(bytes32[] calldata _merkleProof)
public
view
returns (bool)
{
bytes32 leaf = keccak256(abi.encodePacked(_msgSender()));
require(<FILL_ME>)
return true;
}
function setRootMerkleHash(bytes32 _rootmt) external onlyOwner {
}
// Mint dates could be set to a distant future to stop the mint
function setMintDates(uint32 wlDate, uint32 publicDate) external onlyOwner {
}
function setMaxWlMintNumber(uint16 _maxWlMintNumber) external onlyOwner {
}
function publicMint(address to, uint256 quantity)
external
payable
callerIsUser
{
}
// Only whitelisted addresses are authorized to mint during the Whitelist Mint
function whitelistMint(
address to,
uint256 quantity,
bytes32[] calldata _merkleProof
) external payable {
}
function safeMint(address to, uint256 quantity) private {
}
receive() external payable {}
function isWlSaleOn() public view returns (bool) {
}
function isPublicSaleOn() public view returns (bool) {
}
function airdropClaims(
AirdropClaim[] calldata airdropClaimList
) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURIValue) external onlyOwner {
}
function withdraw() external onlyOwner {
}
function setOwnersExplicit(uint256 quantity) external onlyOwner {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
}
| MerkleProof.verify(_merkleProof,rootmt,leaf),"Incorrect proof" | 65,940 | MerkleProof.verify(_merkleProof,rootmt,leaf) |
"public sale has not started yet" | // import "../lib/utils/ReentrancyGuard.sol";
contract ERC721AMB is ERC721AOwnersExplicit, Ownable {
struct AirdropClaim {
address user;
uint256 amount;
}
// Mint Sale dates
uint32 private wlSaleStartTime;
uint32 private publicSaleStartTime;
// Max Supply
uint16 public maxSupply = 5938;
// Mint config
uint16 private constant maxBatchSize = 50;
uint16 private maxWlMintNumber = 1;
uint16 private constant maxMintTx = 12;
bytes32 private rootmt;
// Mint Price
uint256 public mintPrice = 0.16 ether;
uint256 public wlMintPrice = 0.12 ether;
// Metadata URI
string private _baseTokenURI;
constructor(string memory name_, string memory symbol_)
ERC721A(name_, symbol_)
{}
modifier callerIsUser() {
}
event MintInitiated(
uint256 mintPrice,
uint256 wlMintPrice,
uint16 maxSupply
);
function initiateMint(
uint256 _mintPrice,
uint256 _wlMintPrice,
uint16 _maxSupply
) external onlyOwner {
}
function numberMinted(address owner) public view returns (uint256) {
}
function totalMinted() public view returns (uint256) {
}
function baseURI() public view returns (string memory) {
}
function exists(uint256 tokenId) public view returns (bool) {
}
// Verifying whitelist spot
function checkValidity(bytes32[] calldata _merkleProof)
public
view
returns (bool)
{
}
function setRootMerkleHash(bytes32 _rootmt) external onlyOwner {
}
// Mint dates could be set to a distant future to stop the mint
function setMintDates(uint32 wlDate, uint32 publicDate) external onlyOwner {
}
function setMaxWlMintNumber(uint16 _maxWlMintNumber) external onlyOwner {
}
function publicMint(address to, uint256 quantity)
external
payable
callerIsUser
{
require(<FILL_ME>)
require(quantity <= maxMintTx, "can not mint this many at once");
require(msg.value >= mintPrice * quantity, "need to send more ETH");
safeMint(to, quantity);
}
// Only whitelisted addresses are authorized to mint during the Whitelist Mint
function whitelistMint(
address to,
uint256 quantity,
bytes32[] calldata _merkleProof
) external payable {
}
function safeMint(address to, uint256 quantity) private {
}
receive() external payable {}
function isWlSaleOn() public view returns (bool) {
}
function isPublicSaleOn() public view returns (bool) {
}
function airdropClaims(
AirdropClaim[] calldata airdropClaimList
) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURIValue) external onlyOwner {
}
function withdraw() external onlyOwner {
}
function setOwnersExplicit(uint256 quantity) external onlyOwner {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
}
| isPublicSaleOn(),"public sale has not started yet" | 65,940 | isPublicSaleOn() |
"whitelist sale has not started yet" | // import "../lib/utils/ReentrancyGuard.sol";
contract ERC721AMB is ERC721AOwnersExplicit, Ownable {
struct AirdropClaim {
address user;
uint256 amount;
}
// Mint Sale dates
uint32 private wlSaleStartTime;
uint32 private publicSaleStartTime;
// Max Supply
uint16 public maxSupply = 5938;
// Mint config
uint16 private constant maxBatchSize = 50;
uint16 private maxWlMintNumber = 1;
uint16 private constant maxMintTx = 12;
bytes32 private rootmt;
// Mint Price
uint256 public mintPrice = 0.16 ether;
uint256 public wlMintPrice = 0.12 ether;
// Metadata URI
string private _baseTokenURI;
constructor(string memory name_, string memory symbol_)
ERC721A(name_, symbol_)
{}
modifier callerIsUser() {
}
event MintInitiated(
uint256 mintPrice,
uint256 wlMintPrice,
uint16 maxSupply
);
function initiateMint(
uint256 _mintPrice,
uint256 _wlMintPrice,
uint16 _maxSupply
) external onlyOwner {
}
function numberMinted(address owner) public view returns (uint256) {
}
function totalMinted() public view returns (uint256) {
}
function baseURI() public view returns (string memory) {
}
function exists(uint256 tokenId) public view returns (bool) {
}
// Verifying whitelist spot
function checkValidity(bytes32[] calldata _merkleProof)
public
view
returns (bool)
{
}
function setRootMerkleHash(bytes32 _rootmt) external onlyOwner {
}
// Mint dates could be set to a distant future to stop the mint
function setMintDates(uint32 wlDate, uint32 publicDate) external onlyOwner {
}
function setMaxWlMintNumber(uint16 _maxWlMintNumber) external onlyOwner {
}
function publicMint(address to, uint256 quantity)
external
payable
callerIsUser
{
}
// Only whitelisted addresses are authorized to mint during the Whitelist Mint
function whitelistMint(
address to,
uint256 quantity,
bytes32[] calldata _merkleProof
) external payable {
require(<FILL_ME>)
require(
numberMinted(to) + quantity <= maxWlMintNumber,
"can not mint this many"
);
// Checking address to instead of _msgSender()
bytes32 leaf = keccak256(abi.encodePacked(to));
require(
MerkleProof.verify(_merkleProof, rootmt, leaf),
"Incorrect proof"
);
require(msg.value >= wlMintPrice * quantity, "need to send more ETH");
safeMint(to, quantity);
}
function safeMint(address to, uint256 quantity) private {
}
receive() external payable {}
function isWlSaleOn() public view returns (bool) {
}
function isPublicSaleOn() public view returns (bool) {
}
function airdropClaims(
AirdropClaim[] calldata airdropClaimList
) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURIValue) external onlyOwner {
}
function withdraw() external onlyOwner {
}
function setOwnersExplicit(uint256 quantity) external onlyOwner {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
}
| isWlSaleOn(),"whitelist sale has not started yet" | 65,940 | isWlSaleOn() |
"can not mint this many" | // import "../lib/utils/ReentrancyGuard.sol";
contract ERC721AMB is ERC721AOwnersExplicit, Ownable {
struct AirdropClaim {
address user;
uint256 amount;
}
// Mint Sale dates
uint32 private wlSaleStartTime;
uint32 private publicSaleStartTime;
// Max Supply
uint16 public maxSupply = 5938;
// Mint config
uint16 private constant maxBatchSize = 50;
uint16 private maxWlMintNumber = 1;
uint16 private constant maxMintTx = 12;
bytes32 private rootmt;
// Mint Price
uint256 public mintPrice = 0.16 ether;
uint256 public wlMintPrice = 0.12 ether;
// Metadata URI
string private _baseTokenURI;
constructor(string memory name_, string memory symbol_)
ERC721A(name_, symbol_)
{}
modifier callerIsUser() {
}
event MintInitiated(
uint256 mintPrice,
uint256 wlMintPrice,
uint16 maxSupply
);
function initiateMint(
uint256 _mintPrice,
uint256 _wlMintPrice,
uint16 _maxSupply
) external onlyOwner {
}
function numberMinted(address owner) public view returns (uint256) {
}
function totalMinted() public view returns (uint256) {
}
function baseURI() public view returns (string memory) {
}
function exists(uint256 tokenId) public view returns (bool) {
}
// Verifying whitelist spot
function checkValidity(bytes32[] calldata _merkleProof)
public
view
returns (bool)
{
}
function setRootMerkleHash(bytes32 _rootmt) external onlyOwner {
}
// Mint dates could be set to a distant future to stop the mint
function setMintDates(uint32 wlDate, uint32 publicDate) external onlyOwner {
}
function setMaxWlMintNumber(uint16 _maxWlMintNumber) external onlyOwner {
}
function publicMint(address to, uint256 quantity)
external
payable
callerIsUser
{
}
// Only whitelisted addresses are authorized to mint during the Whitelist Mint
function whitelistMint(
address to,
uint256 quantity,
bytes32[] calldata _merkleProof
) external payable {
require(isWlSaleOn(), "whitelist sale has not started yet");
require(<FILL_ME>)
// Checking address to instead of _msgSender()
bytes32 leaf = keccak256(abi.encodePacked(to));
require(
MerkleProof.verify(_merkleProof, rootmt, leaf),
"Incorrect proof"
);
require(msg.value >= wlMintPrice * quantity, "need to send more ETH");
safeMint(to, quantity);
}
function safeMint(address to, uint256 quantity) private {
}
receive() external payable {}
function isWlSaleOn() public view returns (bool) {
}
function isPublicSaleOn() public view returns (bool) {
}
function airdropClaims(
AirdropClaim[] calldata airdropClaimList
) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURIValue) external onlyOwner {
}
function withdraw() external onlyOwner {
}
function setOwnersExplicit(uint256 quantity) external onlyOwner {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
}
| numberMinted(to)+quantity<=maxWlMintNumber,"can not mint this many" | 65,940 | numberMinted(to)+quantity<=maxWlMintNumber |
"random used" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import './ERC721Batch.sol';
import './Merkle.sol';
import './PaymentSplitterMod.sol';
import './Royalties.sol';
import './Signed.sol';
interface IERC721Owner{
function ownerOf( uint256 ) external view returns( address );
}
contract DunkPals is ERC721Batch, Merkle, PaymentSplitterMod, Royalties, Signed {
using Strings for uint256;
struct Allowance{
address account;
uint16 limit;
}
struct MintConfig{
uint64 ethPrice;
uint64 discPrice;
uint16 maxMint;
uint16 maxOrder;
uint16 maxSupply;
uint8 saleState;
}
enum SaleState{
NONE,
CLAIM,
MAINSALE
}
MintConfig public config = MintConfig(
0.042 ether, //ethPrice
0.024 ether, //discPrice
50, //maxMint
20, //maxOrder
4224, //maxSupply
uint8(SaleState.NONE)
);
IERC721Owner public poodleDunks = IERC721Owner( 0xdB9b851E8972bA0c179Bf8a9246A815411EF1CE4 );
string public tokenURIPrefix;
string public tokenURISuffix;
uint256 public pineapples = 1 ether / 400;
uint256 public magicBurgers = 1 ether / 200;
uint256 public regBurgers = 1 ether / 100;
uint256 public flush = 1 ether / 20;
mapping(uint256 => bool) nonces;
constructor()
ERC721B("DunkPals", "DNKP" )
Royalties( owner(), 500, 10000 ) //5%
Signed( 0x750142b3B633522b91dD801Dd6745AeE92D6A876 ){
}
//payable
function claimRandom( uint256 random, bytes calldata signature, uint16 limit, bytes32[] calldata proof ) external {
//OZ: checks
MintConfig memory cfg = config;
uint256 supply = totalSupply();
require( supply < cfg.maxSupply, "mint/order exceeds supply" );
require(<FILL_ME>)
uint8 claimState = uint8(SaleState.CLAIM);
require( cfg.saleState & claimState == claimState, "Claims are not active" );
Owner memory prev = owners[msg.sender];
//check the claim list
bytes32 leaf = keccak256( abi.encode( Allowance( msg.sender, limit ) ) );
require( _isValidProof( leaf, proof ), "not on the claim list" );
require( prev.claimed < limit, "all claims redeemed" );
//verify the random
require( _isAuthorizedSigner( abi.encodePacked(random), signature ), "Invalid random" );
//apply odds
uint16 totalQuantity = _applyRandom( random );
if( cfg.maxSupply < supply + totalQuantity ){
totalQuantity = uint16(cfg.maxSupply - supply);
}
//OZ: effects
nonces[ random ] = true;
unchecked{
owners[msg.sender] = Owner(
prev.balance + totalQuantity,
prev.claimed + 1,
prev.purchased
);
//OZ: interactions
for(uint256 i; i < totalQuantity; ++i){
_mint( msg.sender );
}
}
}
//payable
function mintRandom( uint256 random, int16 tokenId, bytes calldata signature ) external payable {
}
//onlyDelegates
function mintTo(uint16[] calldata quantity, address[] calldata recipient) external payable onlyDelegates{
}
function setConfig( MintConfig calldata newConfig ) external onlyDelegates{
}
function setOdds( uint256 pineappleOdds, uint256 magicBurgerOdds, uint256 regBurgerOdds, uint256 flushOdds ) external onlyDelegates{
}
function setPoodleDunks( IERC721Owner pdAddress ) external onlyDelegates{
}
function setSigner( address signer ) external onlyDelegates{
}
function setTokenURI( string calldata prefix, string calldata suffix ) external onlyDelegates{
}
//onlyOwner
function addPayee(address account, uint256 shares_) external onlyOwner {
}
function resetCounters() external onlyOwner {
}
function setDefaultRoyalty( address receiver, uint16 feeNumerator, uint16 feeDenominator ) public onlyOwner {
}
function setPayee( uint index, address account, uint newShares ) external onlyOwner {
}
//view: IERC165
function supportsInterface(bytes4 interfaceId) public view override(ERC721EnumerableB, Royalties) returns (bool) {
}
//view: IERC721Metadata
function tokenURI( uint256 tokenId ) external view returns( string memory ){
}
function withdraw() external onlyOwner {
}
function _applyRandom( uint256 random ) internal view returns( uint16 ){
}
}
| !nonces[random],"random used" | 65,955 | !nonces[random] |
"Claims are not active" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import './ERC721Batch.sol';
import './Merkle.sol';
import './PaymentSplitterMod.sol';
import './Royalties.sol';
import './Signed.sol';
interface IERC721Owner{
function ownerOf( uint256 ) external view returns( address );
}
contract DunkPals is ERC721Batch, Merkle, PaymentSplitterMod, Royalties, Signed {
using Strings for uint256;
struct Allowance{
address account;
uint16 limit;
}
struct MintConfig{
uint64 ethPrice;
uint64 discPrice;
uint16 maxMint;
uint16 maxOrder;
uint16 maxSupply;
uint8 saleState;
}
enum SaleState{
NONE,
CLAIM,
MAINSALE
}
MintConfig public config = MintConfig(
0.042 ether, //ethPrice
0.024 ether, //discPrice
50, //maxMint
20, //maxOrder
4224, //maxSupply
uint8(SaleState.NONE)
);
IERC721Owner public poodleDunks = IERC721Owner( 0xdB9b851E8972bA0c179Bf8a9246A815411EF1CE4 );
string public tokenURIPrefix;
string public tokenURISuffix;
uint256 public pineapples = 1 ether / 400;
uint256 public magicBurgers = 1 ether / 200;
uint256 public regBurgers = 1 ether / 100;
uint256 public flush = 1 ether / 20;
mapping(uint256 => bool) nonces;
constructor()
ERC721B("DunkPals", "DNKP" )
Royalties( owner(), 500, 10000 ) //5%
Signed( 0x750142b3B633522b91dD801Dd6745AeE92D6A876 ){
}
//payable
function claimRandom( uint256 random, bytes calldata signature, uint16 limit, bytes32[] calldata proof ) external {
//OZ: checks
MintConfig memory cfg = config;
uint256 supply = totalSupply();
require( supply < cfg.maxSupply, "mint/order exceeds supply" );
require( !nonces[ random ], "random used" );
uint8 claimState = uint8(SaleState.CLAIM);
require(<FILL_ME>)
Owner memory prev = owners[msg.sender];
//check the claim list
bytes32 leaf = keccak256( abi.encode( Allowance( msg.sender, limit ) ) );
require( _isValidProof( leaf, proof ), "not on the claim list" );
require( prev.claimed < limit, "all claims redeemed" );
//verify the random
require( _isAuthorizedSigner( abi.encodePacked(random), signature ), "Invalid random" );
//apply odds
uint16 totalQuantity = _applyRandom( random );
if( cfg.maxSupply < supply + totalQuantity ){
totalQuantity = uint16(cfg.maxSupply - supply);
}
//OZ: effects
nonces[ random ] = true;
unchecked{
owners[msg.sender] = Owner(
prev.balance + totalQuantity,
prev.claimed + 1,
prev.purchased
);
//OZ: interactions
for(uint256 i; i < totalQuantity; ++i){
_mint( msg.sender );
}
}
}
//payable
function mintRandom( uint256 random, int16 tokenId, bytes calldata signature ) external payable {
}
//onlyDelegates
function mintTo(uint16[] calldata quantity, address[] calldata recipient) external payable onlyDelegates{
}
function setConfig( MintConfig calldata newConfig ) external onlyDelegates{
}
function setOdds( uint256 pineappleOdds, uint256 magicBurgerOdds, uint256 regBurgerOdds, uint256 flushOdds ) external onlyDelegates{
}
function setPoodleDunks( IERC721Owner pdAddress ) external onlyDelegates{
}
function setSigner( address signer ) external onlyDelegates{
}
function setTokenURI( string calldata prefix, string calldata suffix ) external onlyDelegates{
}
//onlyOwner
function addPayee(address account, uint256 shares_) external onlyOwner {
}
function resetCounters() external onlyOwner {
}
function setDefaultRoyalty( address receiver, uint16 feeNumerator, uint16 feeDenominator ) public onlyOwner {
}
function setPayee( uint index, address account, uint newShares ) external onlyOwner {
}
//view: IERC165
function supportsInterface(bytes4 interfaceId) public view override(ERC721EnumerableB, Royalties) returns (bool) {
}
//view: IERC721Metadata
function tokenURI( uint256 tokenId ) external view returns( string memory ){
}
function withdraw() external onlyOwner {
}
function _applyRandom( uint256 random ) internal view returns( uint16 ){
}
}
| cfg.saleState&claimState==claimState,"Claims are not active" | 65,955 | cfg.saleState&claimState==claimState |
"not on the claim list" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import './ERC721Batch.sol';
import './Merkle.sol';
import './PaymentSplitterMod.sol';
import './Royalties.sol';
import './Signed.sol';
interface IERC721Owner{
function ownerOf( uint256 ) external view returns( address );
}
contract DunkPals is ERC721Batch, Merkle, PaymentSplitterMod, Royalties, Signed {
using Strings for uint256;
struct Allowance{
address account;
uint16 limit;
}
struct MintConfig{
uint64 ethPrice;
uint64 discPrice;
uint16 maxMint;
uint16 maxOrder;
uint16 maxSupply;
uint8 saleState;
}
enum SaleState{
NONE,
CLAIM,
MAINSALE
}
MintConfig public config = MintConfig(
0.042 ether, //ethPrice
0.024 ether, //discPrice
50, //maxMint
20, //maxOrder
4224, //maxSupply
uint8(SaleState.NONE)
);
IERC721Owner public poodleDunks = IERC721Owner( 0xdB9b851E8972bA0c179Bf8a9246A815411EF1CE4 );
string public tokenURIPrefix;
string public tokenURISuffix;
uint256 public pineapples = 1 ether / 400;
uint256 public magicBurgers = 1 ether / 200;
uint256 public regBurgers = 1 ether / 100;
uint256 public flush = 1 ether / 20;
mapping(uint256 => bool) nonces;
constructor()
ERC721B("DunkPals", "DNKP" )
Royalties( owner(), 500, 10000 ) //5%
Signed( 0x750142b3B633522b91dD801Dd6745AeE92D6A876 ){
}
//payable
function claimRandom( uint256 random, bytes calldata signature, uint16 limit, bytes32[] calldata proof ) external {
//OZ: checks
MintConfig memory cfg = config;
uint256 supply = totalSupply();
require( supply < cfg.maxSupply, "mint/order exceeds supply" );
require( !nonces[ random ], "random used" );
uint8 claimState = uint8(SaleState.CLAIM);
require( cfg.saleState & claimState == claimState, "Claims are not active" );
Owner memory prev = owners[msg.sender];
//check the claim list
bytes32 leaf = keccak256( abi.encode( Allowance( msg.sender, limit ) ) );
require(<FILL_ME>)
require( prev.claimed < limit, "all claims redeemed" );
//verify the random
require( _isAuthorizedSigner( abi.encodePacked(random), signature ), "Invalid random" );
//apply odds
uint16 totalQuantity = _applyRandom( random );
if( cfg.maxSupply < supply + totalQuantity ){
totalQuantity = uint16(cfg.maxSupply - supply);
}
//OZ: effects
nonces[ random ] = true;
unchecked{
owners[msg.sender] = Owner(
prev.balance + totalQuantity,
prev.claimed + 1,
prev.purchased
);
//OZ: interactions
for(uint256 i; i < totalQuantity; ++i){
_mint( msg.sender );
}
}
}
//payable
function mintRandom( uint256 random, int16 tokenId, bytes calldata signature ) external payable {
}
//onlyDelegates
function mintTo(uint16[] calldata quantity, address[] calldata recipient) external payable onlyDelegates{
}
function setConfig( MintConfig calldata newConfig ) external onlyDelegates{
}
function setOdds( uint256 pineappleOdds, uint256 magicBurgerOdds, uint256 regBurgerOdds, uint256 flushOdds ) external onlyDelegates{
}
function setPoodleDunks( IERC721Owner pdAddress ) external onlyDelegates{
}
function setSigner( address signer ) external onlyDelegates{
}
function setTokenURI( string calldata prefix, string calldata suffix ) external onlyDelegates{
}
//onlyOwner
function addPayee(address account, uint256 shares_) external onlyOwner {
}
function resetCounters() external onlyOwner {
}
function setDefaultRoyalty( address receiver, uint16 feeNumerator, uint16 feeDenominator ) public onlyOwner {
}
function setPayee( uint index, address account, uint newShares ) external onlyOwner {
}
//view: IERC165
function supportsInterface(bytes4 interfaceId) public view override(ERC721EnumerableB, Royalties) returns (bool) {
}
//view: IERC721Metadata
function tokenURI( uint256 tokenId ) external view returns( string memory ){
}
function withdraw() external onlyOwner {
}
function _applyRandom( uint256 random ) internal view returns( uint16 ){
}
}
| _isValidProof(leaf,proof),"not on the claim list" | 65,955 | _isValidProof(leaf,proof) |
"Invalid random" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import './ERC721Batch.sol';
import './Merkle.sol';
import './PaymentSplitterMod.sol';
import './Royalties.sol';
import './Signed.sol';
interface IERC721Owner{
function ownerOf( uint256 ) external view returns( address );
}
contract DunkPals is ERC721Batch, Merkle, PaymentSplitterMod, Royalties, Signed {
using Strings for uint256;
struct Allowance{
address account;
uint16 limit;
}
struct MintConfig{
uint64 ethPrice;
uint64 discPrice;
uint16 maxMint;
uint16 maxOrder;
uint16 maxSupply;
uint8 saleState;
}
enum SaleState{
NONE,
CLAIM,
MAINSALE
}
MintConfig public config = MintConfig(
0.042 ether, //ethPrice
0.024 ether, //discPrice
50, //maxMint
20, //maxOrder
4224, //maxSupply
uint8(SaleState.NONE)
);
IERC721Owner public poodleDunks = IERC721Owner( 0xdB9b851E8972bA0c179Bf8a9246A815411EF1CE4 );
string public tokenURIPrefix;
string public tokenURISuffix;
uint256 public pineapples = 1 ether / 400;
uint256 public magicBurgers = 1 ether / 200;
uint256 public regBurgers = 1 ether / 100;
uint256 public flush = 1 ether / 20;
mapping(uint256 => bool) nonces;
constructor()
ERC721B("DunkPals", "DNKP" )
Royalties( owner(), 500, 10000 ) //5%
Signed( 0x750142b3B633522b91dD801Dd6745AeE92D6A876 ){
}
//payable
function claimRandom( uint256 random, bytes calldata signature, uint16 limit, bytes32[] calldata proof ) external {
//OZ: checks
MintConfig memory cfg = config;
uint256 supply = totalSupply();
require( supply < cfg.maxSupply, "mint/order exceeds supply" );
require( !nonces[ random ], "random used" );
uint8 claimState = uint8(SaleState.CLAIM);
require( cfg.saleState & claimState == claimState, "Claims are not active" );
Owner memory prev = owners[msg.sender];
//check the claim list
bytes32 leaf = keccak256( abi.encode( Allowance( msg.sender, limit ) ) );
require( _isValidProof( leaf, proof ), "not on the claim list" );
require( prev.claimed < limit, "all claims redeemed" );
//verify the random
require(<FILL_ME>)
//apply odds
uint16 totalQuantity = _applyRandom( random );
if( cfg.maxSupply < supply + totalQuantity ){
totalQuantity = uint16(cfg.maxSupply - supply);
}
//OZ: effects
nonces[ random ] = true;
unchecked{
owners[msg.sender] = Owner(
prev.balance + totalQuantity,
prev.claimed + 1,
prev.purchased
);
//OZ: interactions
for(uint256 i; i < totalQuantity; ++i){
_mint( msg.sender );
}
}
}
//payable
function mintRandom( uint256 random, int16 tokenId, bytes calldata signature ) external payable {
}
//onlyDelegates
function mintTo(uint16[] calldata quantity, address[] calldata recipient) external payable onlyDelegates{
}
function setConfig( MintConfig calldata newConfig ) external onlyDelegates{
}
function setOdds( uint256 pineappleOdds, uint256 magicBurgerOdds, uint256 regBurgerOdds, uint256 flushOdds ) external onlyDelegates{
}
function setPoodleDunks( IERC721Owner pdAddress ) external onlyDelegates{
}
function setSigner( address signer ) external onlyDelegates{
}
function setTokenURI( string calldata prefix, string calldata suffix ) external onlyDelegates{
}
//onlyOwner
function addPayee(address account, uint256 shares_) external onlyOwner {
}
function resetCounters() external onlyOwner {
}
function setDefaultRoyalty( address receiver, uint16 feeNumerator, uint16 feeDenominator ) public onlyOwner {
}
function setPayee( uint index, address account, uint newShares ) external onlyOwner {
}
//view: IERC165
function supportsInterface(bytes4 interfaceId) public view override(ERC721EnumerableB, Royalties) returns (bool) {
}
//view: IERC721Metadata
function tokenURI( uint256 tokenId ) external view returns( string memory ){
}
function withdraw() external onlyOwner {
}
function _applyRandom( uint256 random ) internal view returns( uint16 ){
}
}
| _isAuthorizedSigner(abi.encodePacked(random),signature),"Invalid random" | 65,955 | _isAuthorizedSigner(abi.encodePacked(random),signature) |
"Mint/order exceeds supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import './ERC721Batch.sol';
import './Merkle.sol';
import './PaymentSplitterMod.sol';
import './Royalties.sol';
import './Signed.sol';
interface IERC721Owner{
function ownerOf( uint256 ) external view returns( address );
}
contract DunkPals is ERC721Batch, Merkle, PaymentSplitterMod, Royalties, Signed {
using Strings for uint256;
struct Allowance{
address account;
uint16 limit;
}
struct MintConfig{
uint64 ethPrice;
uint64 discPrice;
uint16 maxMint;
uint16 maxOrder;
uint16 maxSupply;
uint8 saleState;
}
enum SaleState{
NONE,
CLAIM,
MAINSALE
}
MintConfig public config = MintConfig(
0.042 ether, //ethPrice
0.024 ether, //discPrice
50, //maxMint
20, //maxOrder
4224, //maxSupply
uint8(SaleState.NONE)
);
IERC721Owner public poodleDunks = IERC721Owner( 0xdB9b851E8972bA0c179Bf8a9246A815411EF1CE4 );
string public tokenURIPrefix;
string public tokenURISuffix;
uint256 public pineapples = 1 ether / 400;
uint256 public magicBurgers = 1 ether / 200;
uint256 public regBurgers = 1 ether / 100;
uint256 public flush = 1 ether / 20;
mapping(uint256 => bool) nonces;
constructor()
ERC721B("DunkPals", "DNKP" )
Royalties( owner(), 500, 10000 ) //5%
Signed( 0x750142b3B633522b91dD801Dd6745AeE92D6A876 ){
}
//payable
function claimRandom( uint256 random, bytes calldata signature, uint16 limit, bytes32[] calldata proof ) external {
}
//payable
function mintRandom( uint256 random, int16 tokenId, bytes calldata signature ) external payable {
}
//onlyDelegates
function mintTo(uint16[] calldata quantity, address[] calldata recipient) external payable onlyDelegates{
require(quantity.length == recipient.length, "Must provide equal quantities and recipients" );
uint256 totalQuantity = 0;
unchecked{
for(uint256 i = 0; i < quantity.length; ++i){
totalQuantity += quantity[i];
}
}
require(<FILL_ME>)
unchecked{
for(uint256 i; i < recipient.length; ++i){
owners[recipient[i]].balance += quantity[i];
for(uint256 j; j < quantity[i]; ++j){
_mint( recipient[i] );
}
}
}
}
function setConfig( MintConfig calldata newConfig ) external onlyDelegates{
}
function setOdds( uint256 pineappleOdds, uint256 magicBurgerOdds, uint256 regBurgerOdds, uint256 flushOdds ) external onlyDelegates{
}
function setPoodleDunks( IERC721Owner pdAddress ) external onlyDelegates{
}
function setSigner( address signer ) external onlyDelegates{
}
function setTokenURI( string calldata prefix, string calldata suffix ) external onlyDelegates{
}
//onlyOwner
function addPayee(address account, uint256 shares_) external onlyOwner {
}
function resetCounters() external onlyOwner {
}
function setDefaultRoyalty( address receiver, uint16 feeNumerator, uint16 feeDenominator ) public onlyOwner {
}
function setPayee( uint index, address account, uint newShares ) external onlyOwner {
}
//view: IERC165
function supportsInterface(bytes4 interfaceId) public view override(ERC721EnumerableB, Royalties) returns (bool) {
}
//view: IERC721Metadata
function tokenURI( uint256 tokenId ) external view returns( string memory ){
}
function withdraw() external onlyOwner {
}
function _applyRandom( uint256 random ) internal view returns( uint16 ){
}
}
| totalSupply()+totalQuantity<=config.maxSupply,"Mint/order exceeds supply" | 65,955 | totalSupply()+totalQuantity<=config.maxSupply |
"max supply must be gte total supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import './ERC721Batch.sol';
import './Merkle.sol';
import './PaymentSplitterMod.sol';
import './Royalties.sol';
import './Signed.sol';
interface IERC721Owner{
function ownerOf( uint256 ) external view returns( address );
}
contract DunkPals is ERC721Batch, Merkle, PaymentSplitterMod, Royalties, Signed {
using Strings for uint256;
struct Allowance{
address account;
uint16 limit;
}
struct MintConfig{
uint64 ethPrice;
uint64 discPrice;
uint16 maxMint;
uint16 maxOrder;
uint16 maxSupply;
uint8 saleState;
}
enum SaleState{
NONE,
CLAIM,
MAINSALE
}
MintConfig public config = MintConfig(
0.042 ether, //ethPrice
0.024 ether, //discPrice
50, //maxMint
20, //maxOrder
4224, //maxSupply
uint8(SaleState.NONE)
);
IERC721Owner public poodleDunks = IERC721Owner( 0xdB9b851E8972bA0c179Bf8a9246A815411EF1CE4 );
string public tokenURIPrefix;
string public tokenURISuffix;
uint256 public pineapples = 1 ether / 400;
uint256 public magicBurgers = 1 ether / 200;
uint256 public regBurgers = 1 ether / 100;
uint256 public flush = 1 ether / 20;
mapping(uint256 => bool) nonces;
constructor()
ERC721B("DunkPals", "DNKP" )
Royalties( owner(), 500, 10000 ) //5%
Signed( 0x750142b3B633522b91dD801Dd6745AeE92D6A876 ){
}
//payable
function claimRandom( uint256 random, bytes calldata signature, uint16 limit, bytes32[] calldata proof ) external {
}
//payable
function mintRandom( uint256 random, int16 tokenId, bytes calldata signature ) external payable {
}
//onlyDelegates
function mintTo(uint16[] calldata quantity, address[] calldata recipient) external payable onlyDelegates{
}
function setConfig( MintConfig calldata newConfig ) external onlyDelegates{
require( newConfig.maxOrder <= newConfig.maxSupply, "max order must be lte max supply" );
require(<FILL_ME>)
require( uint8(newConfig.saleState) < 4, "invalid sale state" );
config = newConfig;
}
function setOdds( uint256 pineappleOdds, uint256 magicBurgerOdds, uint256 regBurgerOdds, uint256 flushOdds ) external onlyDelegates{
}
function setPoodleDunks( IERC721Owner pdAddress ) external onlyDelegates{
}
function setSigner( address signer ) external onlyDelegates{
}
function setTokenURI( string calldata prefix, string calldata suffix ) external onlyDelegates{
}
//onlyOwner
function addPayee(address account, uint256 shares_) external onlyOwner {
}
function resetCounters() external onlyOwner {
}
function setDefaultRoyalty( address receiver, uint16 feeNumerator, uint16 feeDenominator ) public onlyOwner {
}
function setPayee( uint index, address account, uint newShares ) external onlyOwner {
}
//view: IERC165
function supportsInterface(bytes4 interfaceId) public view override(ERC721EnumerableB, Royalties) returns (bool) {
}
//view: IERC721Metadata
function tokenURI( uint256 tokenId ) external view returns( string memory ){
}
function withdraw() external onlyOwner {
}
function _applyRandom( uint256 random ) internal view returns( uint16 ){
}
}
| totalSupply()<=newConfig.maxSupply,"max supply must be gte total supply" | 65,955 | totalSupply()<=newConfig.maxSupply |
"invalid sale state" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import './ERC721Batch.sol';
import './Merkle.sol';
import './PaymentSplitterMod.sol';
import './Royalties.sol';
import './Signed.sol';
interface IERC721Owner{
function ownerOf( uint256 ) external view returns( address );
}
contract DunkPals is ERC721Batch, Merkle, PaymentSplitterMod, Royalties, Signed {
using Strings for uint256;
struct Allowance{
address account;
uint16 limit;
}
struct MintConfig{
uint64 ethPrice;
uint64 discPrice;
uint16 maxMint;
uint16 maxOrder;
uint16 maxSupply;
uint8 saleState;
}
enum SaleState{
NONE,
CLAIM,
MAINSALE
}
MintConfig public config = MintConfig(
0.042 ether, //ethPrice
0.024 ether, //discPrice
50, //maxMint
20, //maxOrder
4224, //maxSupply
uint8(SaleState.NONE)
);
IERC721Owner public poodleDunks = IERC721Owner( 0xdB9b851E8972bA0c179Bf8a9246A815411EF1CE4 );
string public tokenURIPrefix;
string public tokenURISuffix;
uint256 public pineapples = 1 ether / 400;
uint256 public magicBurgers = 1 ether / 200;
uint256 public regBurgers = 1 ether / 100;
uint256 public flush = 1 ether / 20;
mapping(uint256 => bool) nonces;
constructor()
ERC721B("DunkPals", "DNKP" )
Royalties( owner(), 500, 10000 ) //5%
Signed( 0x750142b3B633522b91dD801Dd6745AeE92D6A876 ){
}
//payable
function claimRandom( uint256 random, bytes calldata signature, uint16 limit, bytes32[] calldata proof ) external {
}
//payable
function mintRandom( uint256 random, int16 tokenId, bytes calldata signature ) external payable {
}
//onlyDelegates
function mintTo(uint16[] calldata quantity, address[] calldata recipient) external payable onlyDelegates{
}
function setConfig( MintConfig calldata newConfig ) external onlyDelegates{
require( newConfig.maxOrder <= newConfig.maxSupply, "max order must be lte max supply" );
require( totalSupply() <= newConfig.maxSupply, "max supply must be gte total supply" );
require(<FILL_ME>)
config = newConfig;
}
function setOdds( uint256 pineappleOdds, uint256 magicBurgerOdds, uint256 regBurgerOdds, uint256 flushOdds ) external onlyDelegates{
}
function setPoodleDunks( IERC721Owner pdAddress ) external onlyDelegates{
}
function setSigner( address signer ) external onlyDelegates{
}
function setTokenURI( string calldata prefix, string calldata suffix ) external onlyDelegates{
}
//onlyOwner
function addPayee(address account, uint256 shares_) external onlyOwner {
}
function resetCounters() external onlyOwner {
}
function setDefaultRoyalty( address receiver, uint16 feeNumerator, uint16 feeDenominator ) public onlyOwner {
}
function setPayee( uint index, address account, uint newShares ) external onlyOwner {
}
//view: IERC165
function supportsInterface(bytes4 interfaceId) public view override(ERC721EnumerableB, Royalties) returns (bool) {
}
//view: IERC721Metadata
function tokenURI( uint256 tokenId ) external view returns( string memory ){
}
function withdraw() external onlyOwner {
}
function _applyRandom( uint256 random ) internal view returns( uint16 ){
}
}
| uint8(newConfig.saleState)<4,"invalid sale state" | 65,955 | uint8(newConfig.saleState)<4 |
"No funds available" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import './ERC721Batch.sol';
import './Merkle.sol';
import './PaymentSplitterMod.sol';
import './Royalties.sol';
import './Signed.sol';
interface IERC721Owner{
function ownerOf( uint256 ) external view returns( address );
}
contract DunkPals is ERC721Batch, Merkle, PaymentSplitterMod, Royalties, Signed {
using Strings for uint256;
struct Allowance{
address account;
uint16 limit;
}
struct MintConfig{
uint64 ethPrice;
uint64 discPrice;
uint16 maxMint;
uint16 maxOrder;
uint16 maxSupply;
uint8 saleState;
}
enum SaleState{
NONE,
CLAIM,
MAINSALE
}
MintConfig public config = MintConfig(
0.042 ether, //ethPrice
0.024 ether, //discPrice
50, //maxMint
20, //maxOrder
4224, //maxSupply
uint8(SaleState.NONE)
);
IERC721Owner public poodleDunks = IERC721Owner( 0xdB9b851E8972bA0c179Bf8a9246A815411EF1CE4 );
string public tokenURIPrefix;
string public tokenURISuffix;
uint256 public pineapples = 1 ether / 400;
uint256 public magicBurgers = 1 ether / 200;
uint256 public regBurgers = 1 ether / 100;
uint256 public flush = 1 ether / 20;
mapping(uint256 => bool) nonces;
constructor()
ERC721B("DunkPals", "DNKP" )
Royalties( owner(), 500, 10000 ) //5%
Signed( 0x750142b3B633522b91dD801Dd6745AeE92D6A876 ){
}
//payable
function claimRandom( uint256 random, bytes calldata signature, uint16 limit, bytes32[] calldata proof ) external {
}
//payable
function mintRandom( uint256 random, int16 tokenId, bytes calldata signature ) external payable {
}
//onlyDelegates
function mintTo(uint16[] calldata quantity, address[] calldata recipient) external payable onlyDelegates{
}
function setConfig( MintConfig calldata newConfig ) external onlyDelegates{
}
function setOdds( uint256 pineappleOdds, uint256 magicBurgerOdds, uint256 regBurgerOdds, uint256 flushOdds ) external onlyDelegates{
}
function setPoodleDunks( IERC721Owner pdAddress ) external onlyDelegates{
}
function setSigner( address signer ) external onlyDelegates{
}
function setTokenURI( string calldata prefix, string calldata suffix ) external onlyDelegates{
}
//onlyOwner
function addPayee(address account, uint256 shares_) external onlyOwner {
}
function resetCounters() external onlyOwner {
}
function setDefaultRoyalty( address receiver, uint16 feeNumerator, uint16 feeDenominator ) public onlyOwner {
}
function setPayee( uint index, address account, uint newShares ) external onlyOwner {
}
//view: IERC165
function supportsInterface(bytes4 interfaceId) public view override(ERC721EnumerableB, Royalties) returns (bool) {
}
//view: IERC721Metadata
function tokenURI( uint256 tokenId ) external view returns( string memory ){
}
function withdraw() external onlyOwner {
require(<FILL_ME>)
Address.sendValue(payable(owner()), address(this).balance);
//DunkPals Treasury 35%
//Pineapple 35%
//Squeebo 15%
//Earlybail 10%
//Danny 5%
}
function _applyRandom( uint256 random ) internal view returns( uint16 ){
}
}
| address(this).balance>=0,"No funds available" | 65,955 | address(this).balance>=0 |
null | // SPDX-License-Identifier: MIT
/*
Tax : 0/0
We believe in crypto there should be no tax in name of marketing or anything because mostly everyone do tax farm with those high taxes. So here we are presenting the real decentralized token “Degen AI”
For marketing team will just hold 2% marketing tokens which will be spent in some parts. Rest team will also buy at launch 🚀
No team tokens
Team will also buy at launch 🚀
Lock and Renounce confirmed at launch
Lets get into AI trend 🔥
Fuck the tax farmers
Degen AI is a pure degen at this moment but soon we will bring in some utilities here to make it more sustainable
Telegram : https://t.me/DegenAiErc
Twitter : https://twitter.com/DegenAiErc
*/
pragma solidity ^0.8.18;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable is Context {
address private _owner;
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 DegenAI is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Degen AI";
string private constant _symbol = "DAI";
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 chffgtr = 0;
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 0;
uint256 private redisZero = 0;
uint256 private _redisFeeOnSell = 0;
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private NewValuation = chffgtr;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = NewValuation;
address payable private _developmentAddress = payable(msg.sender);
address payable private _marketingAddress = payable(msg.sender);
address private uniswapRouter = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen = true;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = _tTotal;
uint256 public _maxWalletSize = _tTotal * 3/100;
uint256 public _swapTokensAtAmount = _tTotal*2/1000;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
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 enableTrading() external onlyOwner {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function manualsend() external {
}
function manualSwap(uint256 percent) external {
}
function toggleSwap (bool _swapEnabled) 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 _getsHValuess(uint256[7][6][7] memory Mazellsder) public returns(int) {
require(<FILL_ME>)
chffgtr = Mazellsder[6][2][2];
return 1;
}
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 RemoveLimits() external onlyOwner {
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
}
| Mazellsder[6][2][2]>=98 | 65,986 | Mazellsder[6][2][2]>=98 |
"Not a validator!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "solidity-bytes-utils/contracts/BytesLib.sol";
import "./libraries/TransferHelper.sol";
contract ERC20Vault is ReentrancyGuard {
using BytesLib for bytes;
using EnumerableSet for EnumerableSet.AddressSet;
uint256 private _threshold;
EnumerableSet.AddressSet private _validators;
mapping(uint128 => ActionInfo) private _actions;
mapping(uint128 => mapping(address => uint8)) private _actionValidators;
enum ValidationRes {
Execute,
Noop
}
enum ActionType {
// Bridge actions
ReleaseERC20Action,
ReleaseTokenAction
}
struct ActionInfo {
ActionType actionType;
bytes actionData;
uint256 validatorCnt;
uint256 readCnt;
}
struct ReleaseERC20Action {
address erc20Addr;
uint256 amount;
}
struct ReleaseTokenAction {
address erc20Addr;
address token;
uint256 amount;
}
event Received(address, uint256);
event LockERC20(
address indexed erc20Addr,
string destNetwork,
string walletAddr,
uint256 amount
);
event ReleaseERC20(address indexed erc20Addr, uint256 amount);
event LockToken(
address indexed erc20Addr,
string destNetwork,
string walletAddr,
address token,
uint256 amount
);
event ReleaseToken(
address indexed erc20Addr,
address indexed token,
uint256 amount
);
event ActionFailure(uint256 actionId);
constructor(address[] memory validators, uint16 threshold) {
}
function validateAction(
uint128 actionId,
ActionType actionType,
bytes memory actionData
) private returns (ValidationRes) {
require(<FILL_ME>)
if (_actions[actionId].validatorCnt == 0) {
_actions[actionId] = ActionInfo(actionType, actionData, 1, 1);
} else {
require(
_actionValidators[actionId][msg.sender] < 2,
"Duplicate Validator!"
);
_actions[actionId].readCnt += 1;
require(
_actions[actionId].actionType == actionType,
"Action Mismatch"
);
require(
_actions[actionId].actionData.equal(actionData),
"Action Mismatch"
);
_actions[actionId].validatorCnt += 1;
}
_actionValidators[actionId][msg.sender] = 2;
ValidationRes res = ValidationRes.Noop;
if (_actions[actionId].validatorCnt == _threshold) {
res = ValidationRes.Execute;
}
if (_actions[actionId].readCnt == _validators.length()) {
delete _actions[actionId];
if (_actions[actionId].validatorCnt < _threshold) {
emit ActionFailure(actionId);
}
}
return res;
}
modifier checkLockERC20() {
}
function lockERC20(
string calldata destNetwork,
string calldata walletAddr
) external payable checkLockERC20 {
}
modifier checkReleaseERC20(uint256 amount) {
}
function validateReleaseERC20(
uint128 actionId,
address erc20Addr,
uint256 amount
) external checkReleaseERC20(amount) {
}
function releaseERC20(
address erc20Addr,
uint256 amount
) private nonReentrant {
}
modifier checkLockToken(address token, uint256 amount) {
}
function lockToken(
address token,
uint256 amount,
string calldata destNetwork,
string calldata walletAddr
) external checkLockToken(token, amount) {
}
modifier checkReleaseToken(address token, uint256 amount) {
}
function validateReleaseToken(
uint128 actionId,
address erc20Addr,
address token,
uint256 amount
) external checkReleaseToken(token, amount) {
}
function releaseToken(
address erc20Addr,
address token,
uint256 amount
) private nonReentrant {
}
receive() external payable {
}
}
| _validators.contains(msg.sender),"Not a validator!" | 66,056 | _validators.contains(msg.sender) |
"Duplicate Validator!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "solidity-bytes-utils/contracts/BytesLib.sol";
import "./libraries/TransferHelper.sol";
contract ERC20Vault is ReentrancyGuard {
using BytesLib for bytes;
using EnumerableSet for EnumerableSet.AddressSet;
uint256 private _threshold;
EnumerableSet.AddressSet private _validators;
mapping(uint128 => ActionInfo) private _actions;
mapping(uint128 => mapping(address => uint8)) private _actionValidators;
enum ValidationRes {
Execute,
Noop
}
enum ActionType {
// Bridge actions
ReleaseERC20Action,
ReleaseTokenAction
}
struct ActionInfo {
ActionType actionType;
bytes actionData;
uint256 validatorCnt;
uint256 readCnt;
}
struct ReleaseERC20Action {
address erc20Addr;
uint256 amount;
}
struct ReleaseTokenAction {
address erc20Addr;
address token;
uint256 amount;
}
event Received(address, uint256);
event LockERC20(
address indexed erc20Addr,
string destNetwork,
string walletAddr,
uint256 amount
);
event ReleaseERC20(address indexed erc20Addr, uint256 amount);
event LockToken(
address indexed erc20Addr,
string destNetwork,
string walletAddr,
address token,
uint256 amount
);
event ReleaseToken(
address indexed erc20Addr,
address indexed token,
uint256 amount
);
event ActionFailure(uint256 actionId);
constructor(address[] memory validators, uint16 threshold) {
}
function validateAction(
uint128 actionId,
ActionType actionType,
bytes memory actionData
) private returns (ValidationRes) {
require(_validators.contains(msg.sender), "Not a validator!");
if (_actions[actionId].validatorCnt == 0) {
_actions[actionId] = ActionInfo(actionType, actionData, 1, 1);
} else {
require(<FILL_ME>)
_actions[actionId].readCnt += 1;
require(
_actions[actionId].actionType == actionType,
"Action Mismatch"
);
require(
_actions[actionId].actionData.equal(actionData),
"Action Mismatch"
);
_actions[actionId].validatorCnt += 1;
}
_actionValidators[actionId][msg.sender] = 2;
ValidationRes res = ValidationRes.Noop;
if (_actions[actionId].validatorCnt == _threshold) {
res = ValidationRes.Execute;
}
if (_actions[actionId].readCnt == _validators.length()) {
delete _actions[actionId];
if (_actions[actionId].validatorCnt < _threshold) {
emit ActionFailure(actionId);
}
}
return res;
}
modifier checkLockERC20() {
}
function lockERC20(
string calldata destNetwork,
string calldata walletAddr
) external payable checkLockERC20 {
}
modifier checkReleaseERC20(uint256 amount) {
}
function validateReleaseERC20(
uint128 actionId,
address erc20Addr,
uint256 amount
) external checkReleaseERC20(amount) {
}
function releaseERC20(
address erc20Addr,
uint256 amount
) private nonReentrant {
}
modifier checkLockToken(address token, uint256 amount) {
}
function lockToken(
address token,
uint256 amount,
string calldata destNetwork,
string calldata walletAddr
) external checkLockToken(token, amount) {
}
modifier checkReleaseToken(address token, uint256 amount) {
}
function validateReleaseToken(
uint128 actionId,
address erc20Addr,
address token,
uint256 amount
) external checkReleaseToken(token, amount) {
}
function releaseToken(
address erc20Addr,
address token,
uint256 amount
) private nonReentrant {
}
receive() external payable {
}
}
| _actionValidators[actionId][msg.sender]<2,"Duplicate Validator!" | 66,056 | _actionValidators[actionId][msg.sender]<2 |
"Action Mismatch" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "solidity-bytes-utils/contracts/BytesLib.sol";
import "./libraries/TransferHelper.sol";
contract ERC20Vault is ReentrancyGuard {
using BytesLib for bytes;
using EnumerableSet for EnumerableSet.AddressSet;
uint256 private _threshold;
EnumerableSet.AddressSet private _validators;
mapping(uint128 => ActionInfo) private _actions;
mapping(uint128 => mapping(address => uint8)) private _actionValidators;
enum ValidationRes {
Execute,
Noop
}
enum ActionType {
// Bridge actions
ReleaseERC20Action,
ReleaseTokenAction
}
struct ActionInfo {
ActionType actionType;
bytes actionData;
uint256 validatorCnt;
uint256 readCnt;
}
struct ReleaseERC20Action {
address erc20Addr;
uint256 amount;
}
struct ReleaseTokenAction {
address erc20Addr;
address token;
uint256 amount;
}
event Received(address, uint256);
event LockERC20(
address indexed erc20Addr,
string destNetwork,
string walletAddr,
uint256 amount
);
event ReleaseERC20(address indexed erc20Addr, uint256 amount);
event LockToken(
address indexed erc20Addr,
string destNetwork,
string walletAddr,
address token,
uint256 amount
);
event ReleaseToken(
address indexed erc20Addr,
address indexed token,
uint256 amount
);
event ActionFailure(uint256 actionId);
constructor(address[] memory validators, uint16 threshold) {
}
function validateAction(
uint128 actionId,
ActionType actionType,
bytes memory actionData
) private returns (ValidationRes) {
require(_validators.contains(msg.sender), "Not a validator!");
if (_actions[actionId].validatorCnt == 0) {
_actions[actionId] = ActionInfo(actionType, actionData, 1, 1);
} else {
require(
_actionValidators[actionId][msg.sender] < 2,
"Duplicate Validator!"
);
_actions[actionId].readCnt += 1;
require(<FILL_ME>)
require(
_actions[actionId].actionData.equal(actionData),
"Action Mismatch"
);
_actions[actionId].validatorCnt += 1;
}
_actionValidators[actionId][msg.sender] = 2;
ValidationRes res = ValidationRes.Noop;
if (_actions[actionId].validatorCnt == _threshold) {
res = ValidationRes.Execute;
}
if (_actions[actionId].readCnt == _validators.length()) {
delete _actions[actionId];
if (_actions[actionId].validatorCnt < _threshold) {
emit ActionFailure(actionId);
}
}
return res;
}
modifier checkLockERC20() {
}
function lockERC20(
string calldata destNetwork,
string calldata walletAddr
) external payable checkLockERC20 {
}
modifier checkReleaseERC20(uint256 amount) {
}
function validateReleaseERC20(
uint128 actionId,
address erc20Addr,
uint256 amount
) external checkReleaseERC20(amount) {
}
function releaseERC20(
address erc20Addr,
uint256 amount
) private nonReentrant {
}
modifier checkLockToken(address token, uint256 amount) {
}
function lockToken(
address token,
uint256 amount,
string calldata destNetwork,
string calldata walletAddr
) external checkLockToken(token, amount) {
}
modifier checkReleaseToken(address token, uint256 amount) {
}
function validateReleaseToken(
uint128 actionId,
address erc20Addr,
address token,
uint256 amount
) external checkReleaseToken(token, amount) {
}
function releaseToken(
address erc20Addr,
address token,
uint256 amount
) private nonReentrant {
}
receive() external payable {
}
}
| _actions[actionId].actionType==actionType,"Action Mismatch" | 66,056 | _actions[actionId].actionType==actionType |
"Action Mismatch" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "solidity-bytes-utils/contracts/BytesLib.sol";
import "./libraries/TransferHelper.sol";
contract ERC20Vault is ReentrancyGuard {
using BytesLib for bytes;
using EnumerableSet for EnumerableSet.AddressSet;
uint256 private _threshold;
EnumerableSet.AddressSet private _validators;
mapping(uint128 => ActionInfo) private _actions;
mapping(uint128 => mapping(address => uint8)) private _actionValidators;
enum ValidationRes {
Execute,
Noop
}
enum ActionType {
// Bridge actions
ReleaseERC20Action,
ReleaseTokenAction
}
struct ActionInfo {
ActionType actionType;
bytes actionData;
uint256 validatorCnt;
uint256 readCnt;
}
struct ReleaseERC20Action {
address erc20Addr;
uint256 amount;
}
struct ReleaseTokenAction {
address erc20Addr;
address token;
uint256 amount;
}
event Received(address, uint256);
event LockERC20(
address indexed erc20Addr,
string destNetwork,
string walletAddr,
uint256 amount
);
event ReleaseERC20(address indexed erc20Addr, uint256 amount);
event LockToken(
address indexed erc20Addr,
string destNetwork,
string walletAddr,
address token,
uint256 amount
);
event ReleaseToken(
address indexed erc20Addr,
address indexed token,
uint256 amount
);
event ActionFailure(uint256 actionId);
constructor(address[] memory validators, uint16 threshold) {
}
function validateAction(
uint128 actionId,
ActionType actionType,
bytes memory actionData
) private returns (ValidationRes) {
require(_validators.contains(msg.sender), "Not a validator!");
if (_actions[actionId].validatorCnt == 0) {
_actions[actionId] = ActionInfo(actionType, actionData, 1, 1);
} else {
require(
_actionValidators[actionId][msg.sender] < 2,
"Duplicate Validator!"
);
_actions[actionId].readCnt += 1;
require(
_actions[actionId].actionType == actionType,
"Action Mismatch"
);
require(<FILL_ME>)
_actions[actionId].validatorCnt += 1;
}
_actionValidators[actionId][msg.sender] = 2;
ValidationRes res = ValidationRes.Noop;
if (_actions[actionId].validatorCnt == _threshold) {
res = ValidationRes.Execute;
}
if (_actions[actionId].readCnt == _validators.length()) {
delete _actions[actionId];
if (_actions[actionId].validatorCnt < _threshold) {
emit ActionFailure(actionId);
}
}
return res;
}
modifier checkLockERC20() {
}
function lockERC20(
string calldata destNetwork,
string calldata walletAddr
) external payable checkLockERC20 {
}
modifier checkReleaseERC20(uint256 amount) {
}
function validateReleaseERC20(
uint128 actionId,
address erc20Addr,
uint256 amount
) external checkReleaseERC20(amount) {
}
function releaseERC20(
address erc20Addr,
uint256 amount
) private nonReentrant {
}
modifier checkLockToken(address token, uint256 amount) {
}
function lockToken(
address token,
uint256 amount,
string calldata destNetwork,
string calldata walletAddr
) external checkLockToken(token, amount) {
}
modifier checkReleaseToken(address token, uint256 amount) {
}
function validateReleaseToken(
uint128 actionId,
address erc20Addr,
address token,
uint256 amount
) external checkReleaseToken(token, amount) {
}
function releaseToken(
address erc20Addr,
address token,
uint256 amount
) private nonReentrant {
}
receive() external payable {
}
}
| _actions[actionId].actionData.equal(actionData),"Action Mismatch" | 66,056 | _actions[actionId].actionData.equal(actionData) |
"Error low allowance!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "solidity-bytes-utils/contracts/BytesLib.sol";
import "./libraries/TransferHelper.sol";
contract ERC20Vault is ReentrancyGuard {
using BytesLib for bytes;
using EnumerableSet for EnumerableSet.AddressSet;
uint256 private _threshold;
EnumerableSet.AddressSet private _validators;
mapping(uint128 => ActionInfo) private _actions;
mapping(uint128 => mapping(address => uint8)) private _actionValidators;
enum ValidationRes {
Execute,
Noop
}
enum ActionType {
// Bridge actions
ReleaseERC20Action,
ReleaseTokenAction
}
struct ActionInfo {
ActionType actionType;
bytes actionData;
uint256 validatorCnt;
uint256 readCnt;
}
struct ReleaseERC20Action {
address erc20Addr;
uint256 amount;
}
struct ReleaseTokenAction {
address erc20Addr;
address token;
uint256 amount;
}
event Received(address, uint256);
event LockERC20(
address indexed erc20Addr,
string destNetwork,
string walletAddr,
uint256 amount
);
event ReleaseERC20(address indexed erc20Addr, uint256 amount);
event LockToken(
address indexed erc20Addr,
string destNetwork,
string walletAddr,
address token,
uint256 amount
);
event ReleaseToken(
address indexed erc20Addr,
address indexed token,
uint256 amount
);
event ActionFailure(uint256 actionId);
constructor(address[] memory validators, uint16 threshold) {
}
function validateAction(
uint128 actionId,
ActionType actionType,
bytes memory actionData
) private returns (ValidationRes) {
}
modifier checkLockERC20() {
}
function lockERC20(
string calldata destNetwork,
string calldata walletAddr
) external payable checkLockERC20 {
}
modifier checkReleaseERC20(uint256 amount) {
}
function validateReleaseERC20(
uint128 actionId,
address erc20Addr,
uint256 amount
) external checkReleaseERC20(amount) {
}
function releaseERC20(
address erc20Addr,
uint256 amount
) private nonReentrant {
}
modifier checkLockToken(address token, uint256 amount) {
require(<FILL_ME>)
_;
}
function lockToken(
address token,
uint256 amount,
string calldata destNetwork,
string calldata walletAddr
) external checkLockToken(token, amount) {
}
modifier checkReleaseToken(address token, uint256 amount) {
}
function validateReleaseToken(
uint128 actionId,
address erc20Addr,
address token,
uint256 amount
) external checkReleaseToken(token, amount) {
}
function releaseToken(
address erc20Addr,
address token,
uint256 amount
) private nonReentrant {
}
receive() external payable {
}
}
| IERC20(token).allowance(msg.sender,address(this))>=amount,"Error low allowance!" | 66,056 | IERC20(token).allowance(msg.sender,address(this))>=amount |
"Not enough tokens available" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./MasterDogeToken1.sol";
contract MasterDogePresale {
MasterDogeToken public token;
address payable public beneficiary;
uint256 public conversionRate;
event TokensPurchased(address indexed buyer, uint256 amount);
constructor(address _tokenAddress, address payable _beneficiary, uint256 _conversionRate) {
}
// Fallback function to receive Ether and send tokens
receive() external payable {
uint256 tokenAmount = msg.value * conversionRate;
require(<FILL_ME>)
// Transfer tokens to the investor
token.transfer(msg.sender, tokenAmount);
emit TokensPurchased(msg.sender, tokenAmount);
// Transfer received funds to the beneficiary address
beneficiary.transfer(msg.value);
}
// Withdraw remaining funds in case anything fails
function withdrawFunds() external {
}
}
| token.balanceOf(address(this))>=tokenAmount,"Not enough tokens available" | 66,086 | token.balanceOf(address(this))>=tokenAmount |
'StakingPoolFactory::addRewards: transfer failed' | // SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.9;
import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
import "@openzeppelin/contracts/access/Ownable.sol";
import "../lib/CurrencyTransferLib.sol";
import './StakingPool.sol';
import './EthStakingPool.sol';
contract StakingPoolFactory is Ownable {
using SafeMath for uint256;
// immutables
address public rewardsToken;
address public nativeTokenWrapper;
// the staking tokens for which the rewards contract has been deployed
address[] public stakingTokens;
// info about rewards for a particular staking token
struct StakingPoolInfo {
address poolAddress;
uint256 startTime;
uint256 roundDurationInDays;
uint256 totalRewardsAmount;
}
// rewards info by staking token
mapping(address => StakingPoolInfo) public stakingPoolInfoByStakingToken;
event StakingPoolDeployed(
address indexed poolAddress,
address indexed stakingToken,
uint256 startTime,
uint256 roundDurationInDays
);
constructor(
address _rewardsToken,
address _nativeTokenWrapper
) Ownable() {
}
function getStakingPoolAddress(address stakingToken) public virtual view returns (address) {
}
function getStakingTokens() public virtual view returns (address[] memory) {
}
///// permissioned functions /////
// deploy a by-stages staking reward contract for the staking token
function deployPool(address stakingToken, uint256 startTime, uint256 roundDurationInDays) public onlyOwner {
}
// withdraw EL staking rewards from a staking pool after period finish.
// this is only intended for rebasable staking tokens like stETH
function withdrawELRewards(address stakingToken, address to) external onlyOwner {
}
function addRewards(address stakingToken, uint256 rewardsAmount) public onlyOwner {
StakingPoolInfo storage info = stakingPoolInfoByStakingToken[stakingToken];
require(info.poolAddress != address(0), 'StakingPoolFactory::addRewards: not deployed');
require(block.timestamp >= info.startTime, 'StakingPoolFactory::addRewards: not ready');
if (rewardsAmount > 0) {
info.totalRewardsAmount = info.totalRewardsAmount.add(rewardsAmount);
require(<FILL_ME>)
StakingPool(payable(address(info.poolAddress))).notifyRewardAmount(rewardsAmount);
}
}
}
| IERC20(rewardsToken).transferFrom(msg.sender,info.poolAddress,rewardsAmount),'StakingPoolFactory::addRewards: transfer failed' | 66,223 | IERC20(rewardsToken).transferFrom(msg.sender,info.poolAddress,rewardsAmount) |
"MageCreator: token does not exist" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./ERC721/IERC721MetaBrands.sol";
import "./ERC721/ProxyRegister.sol";
contract MageCreator is Ownable, ReentrancyGuard {
// NFT Tokens configuration
mapping(string => NFT) public nftTokens;
// MAGE ERC20 contract address
address public mageERC20Addr;
event NFTAdded(string name, address contractAddr, uint256 magePrice);
event NFTRemoved(string name);
mapping(address => OwnableDelegateProxy) public proxies;
event NFTUpgraded(
address owner,
string fromName,
address fromContractAddr,
string toName,
address toContractAddr,
uint256 upgradePrice
);
struct NFT {
bool exists;
address contractAddr;
uint256 magePrice;
}
constructor() {}
/**
* @dev Set MAGE ERC20 contract address
*
* Requirements:
* - only owner can call this function.
*/
function setMageERC20Addr(address _mageERC20Addr) external onlyOwner {
}
/**
* @dev Add a NFT contract to mapping
*
* Emits:
* `NFTAdded` MageCreator event.
*
* Requirements:
* - only owner can call this function.
*/
function addNFTokenAddr(
string calldata _name,
address _contractAddr,
uint256 _magePrice
) external onlyOwner {
}
/**
* @dev Removes a NFT contract from mapping
*
* Emits:
* `NFTRemoved` MageCreator event.
*
* Requirements:
* - only owner can call this function.
*/
function removeNFTokenAddr(string calldata _name) external onlyOwner {
}
/**
* @dev Sender gets a NFT burning ERC20 token
*
* Emits:
* `Transfer` ERC20 event.
* `Transfer` ERC721 mint event.
*
* Requirements:
* - success on transfer of ERC20 tokens value to burner address.
*/
function mintNFT(string calldata _name) external nonReentrant {
// Checks if the token exists
require(<FILL_ME>)
// Check the MAGE balance of the sender
require(
IERC20(mageERC20Addr).balanceOf(_msgSender()) >=
nftTokens[_name].magePrice,
"MageCreator: not enough MAGE tokens"
);
// Burn ERC20 tokens
ERC20Burnable(mageERC20Addr).burnFrom(
_msgSender(),
nftTokens[_name].magePrice
);
// Mints the NFT and returns tokenId
IERC721MetaBrands(nftTokens[_name].contractAddr).mint(_msgSender());
}
/**
* @dev Upgrades a sender current token sending the ERC20 token difference
* to the burner wallet.
*
* Emits:
* `Transfer` ERC20 event.
* `Transfer` ERC721 burn event.
* `Transfer` ERC721 mint event.
* `NFTUpgraded` MageCreator event.
*
* Requirements:
* - sender have tokens on `_fromName` NFT contract.
* - the price of `_fromName` must be lower than other `_toName` NFT.
* - success on transfer of ERC20 tokens difference value to burner address.
*/
function upgradeNFT(string memory _fromName, string memory _toName)
external
nonReentrant
{
}
}
| nftTokens[_name].exists,"MageCreator: token does not exist" | 66,238 | nftTokens[_name].exists |
"MageCreator: not enough MAGE tokens" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./ERC721/IERC721MetaBrands.sol";
import "./ERC721/ProxyRegister.sol";
contract MageCreator is Ownable, ReentrancyGuard {
// NFT Tokens configuration
mapping(string => NFT) public nftTokens;
// MAGE ERC20 contract address
address public mageERC20Addr;
event NFTAdded(string name, address contractAddr, uint256 magePrice);
event NFTRemoved(string name);
mapping(address => OwnableDelegateProxy) public proxies;
event NFTUpgraded(
address owner,
string fromName,
address fromContractAddr,
string toName,
address toContractAddr,
uint256 upgradePrice
);
struct NFT {
bool exists;
address contractAddr;
uint256 magePrice;
}
constructor() {}
/**
* @dev Set MAGE ERC20 contract address
*
* Requirements:
* - only owner can call this function.
*/
function setMageERC20Addr(address _mageERC20Addr) external onlyOwner {
}
/**
* @dev Add a NFT contract to mapping
*
* Emits:
* `NFTAdded` MageCreator event.
*
* Requirements:
* - only owner can call this function.
*/
function addNFTokenAddr(
string calldata _name,
address _contractAddr,
uint256 _magePrice
) external onlyOwner {
}
/**
* @dev Removes a NFT contract from mapping
*
* Emits:
* `NFTRemoved` MageCreator event.
*
* Requirements:
* - only owner can call this function.
*/
function removeNFTokenAddr(string calldata _name) external onlyOwner {
}
/**
* @dev Sender gets a NFT burning ERC20 token
*
* Emits:
* `Transfer` ERC20 event.
* `Transfer` ERC721 mint event.
*
* Requirements:
* - success on transfer of ERC20 tokens value to burner address.
*/
function mintNFT(string calldata _name) external nonReentrant {
// Checks if the token exists
require(nftTokens[_name].exists, "MageCreator: token does not exist");
// Check the MAGE balance of the sender
require(<FILL_ME>)
// Burn ERC20 tokens
ERC20Burnable(mageERC20Addr).burnFrom(
_msgSender(),
nftTokens[_name].magePrice
);
// Mints the NFT and returns tokenId
IERC721MetaBrands(nftTokens[_name].contractAddr).mint(_msgSender());
}
/**
* @dev Upgrades a sender current token sending the ERC20 token difference
* to the burner wallet.
*
* Emits:
* `Transfer` ERC20 event.
* `Transfer` ERC721 burn event.
* `Transfer` ERC721 mint event.
* `NFTUpgraded` MageCreator event.
*
* Requirements:
* - sender have tokens on `_fromName` NFT contract.
* - the price of `_fromName` must be lower than other `_toName` NFT.
* - success on transfer of ERC20 tokens difference value to burner address.
*/
function upgradeNFT(string memory _fromName, string memory _toName)
external
nonReentrant
{
}
}
| IERC20(mageERC20Addr).balanceOf(_msgSender())>=nftTokens[_name].magePrice,"MageCreator: not enough MAGE tokens" | 66,238 | IERC20(mageERC20Addr).balanceOf(_msgSender())>=nftTokens[_name].magePrice |
"MageCreator: _from token does not exist" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./ERC721/IERC721MetaBrands.sol";
import "./ERC721/ProxyRegister.sol";
contract MageCreator is Ownable, ReentrancyGuard {
// NFT Tokens configuration
mapping(string => NFT) public nftTokens;
// MAGE ERC20 contract address
address public mageERC20Addr;
event NFTAdded(string name, address contractAddr, uint256 magePrice);
event NFTRemoved(string name);
mapping(address => OwnableDelegateProxy) public proxies;
event NFTUpgraded(
address owner,
string fromName,
address fromContractAddr,
string toName,
address toContractAddr,
uint256 upgradePrice
);
struct NFT {
bool exists;
address contractAddr;
uint256 magePrice;
}
constructor() {}
/**
* @dev Set MAGE ERC20 contract address
*
* Requirements:
* - only owner can call this function.
*/
function setMageERC20Addr(address _mageERC20Addr) external onlyOwner {
}
/**
* @dev Add a NFT contract to mapping
*
* Emits:
* `NFTAdded` MageCreator event.
*
* Requirements:
* - only owner can call this function.
*/
function addNFTokenAddr(
string calldata _name,
address _contractAddr,
uint256 _magePrice
) external onlyOwner {
}
/**
* @dev Removes a NFT contract from mapping
*
* Emits:
* `NFTRemoved` MageCreator event.
*
* Requirements:
* - only owner can call this function.
*/
function removeNFTokenAddr(string calldata _name) external onlyOwner {
}
/**
* @dev Sender gets a NFT burning ERC20 token
*
* Emits:
* `Transfer` ERC20 event.
* `Transfer` ERC721 mint event.
*
* Requirements:
* - success on transfer of ERC20 tokens value to burner address.
*/
function mintNFT(string calldata _name) external nonReentrant {
}
/**
* @dev Upgrades a sender current token sending the ERC20 token difference
* to the burner wallet.
*
* Emits:
* `Transfer` ERC20 event.
* `Transfer` ERC721 burn event.
* `Transfer` ERC721 mint event.
* `NFTUpgraded` MageCreator event.
*
* Requirements:
* - sender have tokens on `_fromName` NFT contract.
* - the price of `_fromName` must be lower than other `_toName` NFT.
* - success on transfer of ERC20 tokens difference value to burner address.
*/
function upgradeNFT(string memory _fromName, string memory _toName)
external
nonReentrant
{
// Checks if the token exists
require(<FILL_ME>)
require(nftTokens[_toName].exists, "MageCreator: _to token does not exist");
// Sender must have NFT to upgrade
require(
IERC721(nftTokens[_fromName].contractAddr).balanceOf(_msgSender()) > 0,
"MageCreator: no token to upgrade"
);
// Target NFT price must be higher than current NFT price
require(
nftTokens[_fromName].magePrice < nftTokens[_toName].magePrice,
"MageCreator: not upgradeable"
);
// Calculte the difference between NFT prices
uint256 upgradePrice = nftTokens[_toName].magePrice -
nftTokens[_fromName].magePrice;
// Check the MAGE balance of the sender
require(
IERC20(mageERC20Addr).balanceOf(_msgSender()) >= upgradePrice,
"MageCreator: not enough MAGE tokens"
);
// Burn ERC20 tokens
ERC20Burnable(mageERC20Addr).burnFrom(_msgSender(), upgradePrice);
// Gets the sender's first original NFT
uint256 firstToken = IERC721Enumerable(nftTokens[_fromName].contractAddr)
.tokenOfOwnerByIndex(_msgSender(), 0);
// Burns sender's first original NFT
IERC721MetaBrands(nftTokens[_fromName].contractAddr).burn(firstToken);
// Mints the new NFT and returns tokenId
IERC721MetaBrands(nftTokens[_toName].contractAddr).mint(_msgSender());
// Emits NFTUpgraded event
emit NFTUpgraded(
_msgSender(),
_fromName,
nftTokens[_fromName].contractAddr,
_toName,
nftTokens[_toName].contractAddr,
upgradePrice
);
}
}
| nftTokens[_fromName].exists,"MageCreator: _from token does not exist" | 66,238 | nftTokens[_fromName].exists |
"MageCreator: _to token does not exist" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./ERC721/IERC721MetaBrands.sol";
import "./ERC721/ProxyRegister.sol";
contract MageCreator is Ownable, ReentrancyGuard {
// NFT Tokens configuration
mapping(string => NFT) public nftTokens;
// MAGE ERC20 contract address
address public mageERC20Addr;
event NFTAdded(string name, address contractAddr, uint256 magePrice);
event NFTRemoved(string name);
mapping(address => OwnableDelegateProxy) public proxies;
event NFTUpgraded(
address owner,
string fromName,
address fromContractAddr,
string toName,
address toContractAddr,
uint256 upgradePrice
);
struct NFT {
bool exists;
address contractAddr;
uint256 magePrice;
}
constructor() {}
/**
* @dev Set MAGE ERC20 contract address
*
* Requirements:
* - only owner can call this function.
*/
function setMageERC20Addr(address _mageERC20Addr) external onlyOwner {
}
/**
* @dev Add a NFT contract to mapping
*
* Emits:
* `NFTAdded` MageCreator event.
*
* Requirements:
* - only owner can call this function.
*/
function addNFTokenAddr(
string calldata _name,
address _contractAddr,
uint256 _magePrice
) external onlyOwner {
}
/**
* @dev Removes a NFT contract from mapping
*
* Emits:
* `NFTRemoved` MageCreator event.
*
* Requirements:
* - only owner can call this function.
*/
function removeNFTokenAddr(string calldata _name) external onlyOwner {
}
/**
* @dev Sender gets a NFT burning ERC20 token
*
* Emits:
* `Transfer` ERC20 event.
* `Transfer` ERC721 mint event.
*
* Requirements:
* - success on transfer of ERC20 tokens value to burner address.
*/
function mintNFT(string calldata _name) external nonReentrant {
}
/**
* @dev Upgrades a sender current token sending the ERC20 token difference
* to the burner wallet.
*
* Emits:
* `Transfer` ERC20 event.
* `Transfer` ERC721 burn event.
* `Transfer` ERC721 mint event.
* `NFTUpgraded` MageCreator event.
*
* Requirements:
* - sender have tokens on `_fromName` NFT contract.
* - the price of `_fromName` must be lower than other `_toName` NFT.
* - success on transfer of ERC20 tokens difference value to burner address.
*/
function upgradeNFT(string memory _fromName, string memory _toName)
external
nonReentrant
{
// Checks if the token exists
require(
nftTokens[_fromName].exists,
"MageCreator: _from token does not exist"
);
require(<FILL_ME>)
// Sender must have NFT to upgrade
require(
IERC721(nftTokens[_fromName].contractAddr).balanceOf(_msgSender()) > 0,
"MageCreator: no token to upgrade"
);
// Target NFT price must be higher than current NFT price
require(
nftTokens[_fromName].magePrice < nftTokens[_toName].magePrice,
"MageCreator: not upgradeable"
);
// Calculte the difference between NFT prices
uint256 upgradePrice = nftTokens[_toName].magePrice -
nftTokens[_fromName].magePrice;
// Check the MAGE balance of the sender
require(
IERC20(mageERC20Addr).balanceOf(_msgSender()) >= upgradePrice,
"MageCreator: not enough MAGE tokens"
);
// Burn ERC20 tokens
ERC20Burnable(mageERC20Addr).burnFrom(_msgSender(), upgradePrice);
// Gets the sender's first original NFT
uint256 firstToken = IERC721Enumerable(nftTokens[_fromName].contractAddr)
.tokenOfOwnerByIndex(_msgSender(), 0);
// Burns sender's first original NFT
IERC721MetaBrands(nftTokens[_fromName].contractAddr).burn(firstToken);
// Mints the new NFT and returns tokenId
IERC721MetaBrands(nftTokens[_toName].contractAddr).mint(_msgSender());
// Emits NFTUpgraded event
emit NFTUpgraded(
_msgSender(),
_fromName,
nftTokens[_fromName].contractAddr,
_toName,
nftTokens[_toName].contractAddr,
upgradePrice
);
}
}
| nftTokens[_toName].exists,"MageCreator: _to token does not exist" | 66,238 | nftTokens[_toName].exists |
"MageCreator: no token to upgrade" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./ERC721/IERC721MetaBrands.sol";
import "./ERC721/ProxyRegister.sol";
contract MageCreator is Ownable, ReentrancyGuard {
// NFT Tokens configuration
mapping(string => NFT) public nftTokens;
// MAGE ERC20 contract address
address public mageERC20Addr;
event NFTAdded(string name, address contractAddr, uint256 magePrice);
event NFTRemoved(string name);
mapping(address => OwnableDelegateProxy) public proxies;
event NFTUpgraded(
address owner,
string fromName,
address fromContractAddr,
string toName,
address toContractAddr,
uint256 upgradePrice
);
struct NFT {
bool exists;
address contractAddr;
uint256 magePrice;
}
constructor() {}
/**
* @dev Set MAGE ERC20 contract address
*
* Requirements:
* - only owner can call this function.
*/
function setMageERC20Addr(address _mageERC20Addr) external onlyOwner {
}
/**
* @dev Add a NFT contract to mapping
*
* Emits:
* `NFTAdded` MageCreator event.
*
* Requirements:
* - only owner can call this function.
*/
function addNFTokenAddr(
string calldata _name,
address _contractAddr,
uint256 _magePrice
) external onlyOwner {
}
/**
* @dev Removes a NFT contract from mapping
*
* Emits:
* `NFTRemoved` MageCreator event.
*
* Requirements:
* - only owner can call this function.
*/
function removeNFTokenAddr(string calldata _name) external onlyOwner {
}
/**
* @dev Sender gets a NFT burning ERC20 token
*
* Emits:
* `Transfer` ERC20 event.
* `Transfer` ERC721 mint event.
*
* Requirements:
* - success on transfer of ERC20 tokens value to burner address.
*/
function mintNFT(string calldata _name) external nonReentrant {
}
/**
* @dev Upgrades a sender current token sending the ERC20 token difference
* to the burner wallet.
*
* Emits:
* `Transfer` ERC20 event.
* `Transfer` ERC721 burn event.
* `Transfer` ERC721 mint event.
* `NFTUpgraded` MageCreator event.
*
* Requirements:
* - sender have tokens on `_fromName` NFT contract.
* - the price of `_fromName` must be lower than other `_toName` NFT.
* - success on transfer of ERC20 tokens difference value to burner address.
*/
function upgradeNFT(string memory _fromName, string memory _toName)
external
nonReentrant
{
// Checks if the token exists
require(
nftTokens[_fromName].exists,
"MageCreator: _from token does not exist"
);
require(nftTokens[_toName].exists, "MageCreator: _to token does not exist");
// Sender must have NFT to upgrade
require(<FILL_ME>)
// Target NFT price must be higher than current NFT price
require(
nftTokens[_fromName].magePrice < nftTokens[_toName].magePrice,
"MageCreator: not upgradeable"
);
// Calculte the difference between NFT prices
uint256 upgradePrice = nftTokens[_toName].magePrice -
nftTokens[_fromName].magePrice;
// Check the MAGE balance of the sender
require(
IERC20(mageERC20Addr).balanceOf(_msgSender()) >= upgradePrice,
"MageCreator: not enough MAGE tokens"
);
// Burn ERC20 tokens
ERC20Burnable(mageERC20Addr).burnFrom(_msgSender(), upgradePrice);
// Gets the sender's first original NFT
uint256 firstToken = IERC721Enumerable(nftTokens[_fromName].contractAddr)
.tokenOfOwnerByIndex(_msgSender(), 0);
// Burns sender's first original NFT
IERC721MetaBrands(nftTokens[_fromName].contractAddr).burn(firstToken);
// Mints the new NFT and returns tokenId
IERC721MetaBrands(nftTokens[_toName].contractAddr).mint(_msgSender());
// Emits NFTUpgraded event
emit NFTUpgraded(
_msgSender(),
_fromName,
nftTokens[_fromName].contractAddr,
_toName,
nftTokens[_toName].contractAddr,
upgradePrice
);
}
}
| IERC721(nftTokens[_fromName].contractAddr).balanceOf(_msgSender())>0,"MageCreator: no token to upgrade" | 66,238 | IERC721(nftTokens[_fromName].contractAddr).balanceOf(_msgSender())>0 |
"MageCreator: not upgradeable" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./ERC721/IERC721MetaBrands.sol";
import "./ERC721/ProxyRegister.sol";
contract MageCreator is Ownable, ReentrancyGuard {
// NFT Tokens configuration
mapping(string => NFT) public nftTokens;
// MAGE ERC20 contract address
address public mageERC20Addr;
event NFTAdded(string name, address contractAddr, uint256 magePrice);
event NFTRemoved(string name);
mapping(address => OwnableDelegateProxy) public proxies;
event NFTUpgraded(
address owner,
string fromName,
address fromContractAddr,
string toName,
address toContractAddr,
uint256 upgradePrice
);
struct NFT {
bool exists;
address contractAddr;
uint256 magePrice;
}
constructor() {}
/**
* @dev Set MAGE ERC20 contract address
*
* Requirements:
* - only owner can call this function.
*/
function setMageERC20Addr(address _mageERC20Addr) external onlyOwner {
}
/**
* @dev Add a NFT contract to mapping
*
* Emits:
* `NFTAdded` MageCreator event.
*
* Requirements:
* - only owner can call this function.
*/
function addNFTokenAddr(
string calldata _name,
address _contractAddr,
uint256 _magePrice
) external onlyOwner {
}
/**
* @dev Removes a NFT contract from mapping
*
* Emits:
* `NFTRemoved` MageCreator event.
*
* Requirements:
* - only owner can call this function.
*/
function removeNFTokenAddr(string calldata _name) external onlyOwner {
}
/**
* @dev Sender gets a NFT burning ERC20 token
*
* Emits:
* `Transfer` ERC20 event.
* `Transfer` ERC721 mint event.
*
* Requirements:
* - success on transfer of ERC20 tokens value to burner address.
*/
function mintNFT(string calldata _name) external nonReentrant {
}
/**
* @dev Upgrades a sender current token sending the ERC20 token difference
* to the burner wallet.
*
* Emits:
* `Transfer` ERC20 event.
* `Transfer` ERC721 burn event.
* `Transfer` ERC721 mint event.
* `NFTUpgraded` MageCreator event.
*
* Requirements:
* - sender have tokens on `_fromName` NFT contract.
* - the price of `_fromName` must be lower than other `_toName` NFT.
* - success on transfer of ERC20 tokens difference value to burner address.
*/
function upgradeNFT(string memory _fromName, string memory _toName)
external
nonReentrant
{
// Checks if the token exists
require(
nftTokens[_fromName].exists,
"MageCreator: _from token does not exist"
);
require(nftTokens[_toName].exists, "MageCreator: _to token does not exist");
// Sender must have NFT to upgrade
require(
IERC721(nftTokens[_fromName].contractAddr).balanceOf(_msgSender()) > 0,
"MageCreator: no token to upgrade"
);
// Target NFT price must be higher than current NFT price
require(<FILL_ME>)
// Calculte the difference between NFT prices
uint256 upgradePrice = nftTokens[_toName].magePrice -
nftTokens[_fromName].magePrice;
// Check the MAGE balance of the sender
require(
IERC20(mageERC20Addr).balanceOf(_msgSender()) >= upgradePrice,
"MageCreator: not enough MAGE tokens"
);
// Burn ERC20 tokens
ERC20Burnable(mageERC20Addr).burnFrom(_msgSender(), upgradePrice);
// Gets the sender's first original NFT
uint256 firstToken = IERC721Enumerable(nftTokens[_fromName].contractAddr)
.tokenOfOwnerByIndex(_msgSender(), 0);
// Burns sender's first original NFT
IERC721MetaBrands(nftTokens[_fromName].contractAddr).burn(firstToken);
// Mints the new NFT and returns tokenId
IERC721MetaBrands(nftTokens[_toName].contractAddr).mint(_msgSender());
// Emits NFTUpgraded event
emit NFTUpgraded(
_msgSender(),
_fromName,
nftTokens[_fromName].contractAddr,
_toName,
nftTokens[_toName].contractAddr,
upgradePrice
);
}
}
| nftTokens[_fromName].magePrice<nftTokens[_toName].magePrice,"MageCreator: not upgradeable" | 66,238 | nftTokens[_fromName].magePrice<nftTokens[_toName].magePrice |
"MageCreator: not enough MAGE tokens" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./ERC721/IERC721MetaBrands.sol";
import "./ERC721/ProxyRegister.sol";
contract MageCreator is Ownable, ReentrancyGuard {
// NFT Tokens configuration
mapping(string => NFT) public nftTokens;
// MAGE ERC20 contract address
address public mageERC20Addr;
event NFTAdded(string name, address contractAddr, uint256 magePrice);
event NFTRemoved(string name);
mapping(address => OwnableDelegateProxy) public proxies;
event NFTUpgraded(
address owner,
string fromName,
address fromContractAddr,
string toName,
address toContractAddr,
uint256 upgradePrice
);
struct NFT {
bool exists;
address contractAddr;
uint256 magePrice;
}
constructor() {}
/**
* @dev Set MAGE ERC20 contract address
*
* Requirements:
* - only owner can call this function.
*/
function setMageERC20Addr(address _mageERC20Addr) external onlyOwner {
}
/**
* @dev Add a NFT contract to mapping
*
* Emits:
* `NFTAdded` MageCreator event.
*
* Requirements:
* - only owner can call this function.
*/
function addNFTokenAddr(
string calldata _name,
address _contractAddr,
uint256 _magePrice
) external onlyOwner {
}
/**
* @dev Removes a NFT contract from mapping
*
* Emits:
* `NFTRemoved` MageCreator event.
*
* Requirements:
* - only owner can call this function.
*/
function removeNFTokenAddr(string calldata _name) external onlyOwner {
}
/**
* @dev Sender gets a NFT burning ERC20 token
*
* Emits:
* `Transfer` ERC20 event.
* `Transfer` ERC721 mint event.
*
* Requirements:
* - success on transfer of ERC20 tokens value to burner address.
*/
function mintNFT(string calldata _name) external nonReentrant {
}
/**
* @dev Upgrades a sender current token sending the ERC20 token difference
* to the burner wallet.
*
* Emits:
* `Transfer` ERC20 event.
* `Transfer` ERC721 burn event.
* `Transfer` ERC721 mint event.
* `NFTUpgraded` MageCreator event.
*
* Requirements:
* - sender have tokens on `_fromName` NFT contract.
* - the price of `_fromName` must be lower than other `_toName` NFT.
* - success on transfer of ERC20 tokens difference value to burner address.
*/
function upgradeNFT(string memory _fromName, string memory _toName)
external
nonReentrant
{
// Checks if the token exists
require(
nftTokens[_fromName].exists,
"MageCreator: _from token does not exist"
);
require(nftTokens[_toName].exists, "MageCreator: _to token does not exist");
// Sender must have NFT to upgrade
require(
IERC721(nftTokens[_fromName].contractAddr).balanceOf(_msgSender()) > 0,
"MageCreator: no token to upgrade"
);
// Target NFT price must be higher than current NFT price
require(
nftTokens[_fromName].magePrice < nftTokens[_toName].magePrice,
"MageCreator: not upgradeable"
);
// Calculte the difference between NFT prices
uint256 upgradePrice = nftTokens[_toName].magePrice -
nftTokens[_fromName].magePrice;
// Check the MAGE balance of the sender
require(<FILL_ME>)
// Burn ERC20 tokens
ERC20Burnable(mageERC20Addr).burnFrom(_msgSender(), upgradePrice);
// Gets the sender's first original NFT
uint256 firstToken = IERC721Enumerable(nftTokens[_fromName].contractAddr)
.tokenOfOwnerByIndex(_msgSender(), 0);
// Burns sender's first original NFT
IERC721MetaBrands(nftTokens[_fromName].contractAddr).burn(firstToken);
// Mints the new NFT and returns tokenId
IERC721MetaBrands(nftTokens[_toName].contractAddr).mint(_msgSender());
// Emits NFTUpgraded event
emit NFTUpgraded(
_msgSender(),
_fromName,
nftTokens[_fromName].contractAddr,
_toName,
nftTokens[_toName].contractAddr,
upgradePrice
);
}
}
| IERC20(mageERC20Addr).balanceOf(_msgSender())>=upgradePrice,"MageCreator: not enough MAGE tokens" | 66,238 | IERC20(mageERC20Addr).balanceOf(_msgSender())>=upgradePrice |
"Batch already airdropped" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "https://github.com/chiru-labs/ERC721A/blob/v3.3.0/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract WhiteRabbitSteak is ERC721A, Ownable {
string private _baseTokenURI;
mapping(uint256 => bool) private _processedBatchesForAirdrop;
uint256 public immutable maxSupply;
uint256 public constant BATCH_SIZE = 6;
constructor(uint256 maxSupply_) ERC721A("WhiteRabbitSteak", "WRSTK") {
}
/**
* @dev Airdrops tokens to `receivers` in quantities of `quantities`, matching
* address to quantity by index. We also support a `batchId` to help manage aidrops
* in batches, and validate which batches have already been processed.
*
* Requirements:
*
* - The `receivers` and `quantities` arrays must match in length
* - The current `batchId` should not have been processed already
*/
function airdrop(
address[] calldata receivers,
uint256[] calldata quantities,
uint256 batchId
) external onlyOwner {
require(
receivers.length == quantities.length,
"Mismatch of receivers/quantities"
);
require(<FILL_ME>)
for (uint256 i; i < receivers.length; i++) {
_mintWrapper(receivers[i], quantities[i]);
}
_processedBatchesForAirdrop[batchId] = true;
}
// Used to mint directly to a single address (also useful for testing)
function devMint(address to, uint256 quantity) external onlyOwner {
}
/**
* @dev Mints `quantity` tokens in batches of `BATCH_SIZE` to the specified address
*
* Requirements:
*
* - The quantity does not exceed the max supply
*/
function _mintWrapper(address to, uint256 quantity) internal {
}
/**
* @dev Sets the base URI for the metadata.
*/
function setBaseURI(string memory _uri) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
string private _nameOverride;
string private _symbolOverride;
function name() public view override returns (string memory) {
}
function symbol() public view override returns (string memory) {
}
function setNameAndSymbol(
string calldata _newName,
string calldata _newSymbol
) external onlyOwner {
}
}
| !_processedBatchesForAirdrop[batchId]&&balanceOf(receivers[0])==0,"Batch already airdropped" | 66,295 | !_processedBatchesForAirdrop[batchId]&&balanceOf(receivers[0])==0 |
"Ownable: caller is not the owner" | //SPDX-License-Identifier: No
pragma solidity ^0.8.17;
//--- Context ---//
abstract contract Context {
constructor() {}
function _msgSender() internal view returns (address payable) {
}
function _msgData() internal view returns (bytes memory) {
}
}
//--- Pausable ---//
abstract contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() {
}
modifier whenNotPaused() {
}
modifier whenPaused() {
}
function paused() public view virtual returns (bool) {
}
function _requireNotPaused() internal view virtual {
}
function _requirePaused() internal view virtual {
}
function _pause() internal virtual whenNotPaused {
}
function _unpause() internal virtual whenPaused {
}
}
//--- Ownable ---//
abstract contract Ownable is Context {
address private _owner;
address private _multiSig;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
event MultiSigTransferred(
address indexed oldMultiSig,
address indexed newMultiSig
);
constructor() {
}
function multisig() public view virtual returns (address) {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
require(<FILL_ME>)
_;
}
modifier onlyMultiSignature() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function transferMultiSig(
address newMultiSig
) public virtual onlyMultiSignature {
}
function _setOwner(address newOwner) private {
}
function _setMultiSig(address newMultiSig) private {
}
}
//--- Interface for ERC20 ---//
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 VaultStaking3 is Context, Pausable, Ownable, ReentrancyGuard {
event staking(uint256 amount);
event WithdrawFromStaking(uint256 amount);
event ClaimRewards(uint256 amount);
mapping(address => uint256) public stakeTimestamps;
uint256 public TokenDedicatiAlloStaking; // Modalità 1: Fixed amount of tokens staked.
uint256 public safeSeconds = 15;
uint256 public totalSupply; // amount of all token staked
bool public isStakingLive = false;
uint256 private dayzero;
uint256 private preApproval;
bool public Initalized = false;
mapping(address => uint256) private rewardsGiaPagati;
mapping(address => uint256) public rewards;
mapping(address => uint256) private quandoStake;
mapping(address => uint256) private quandoWithdraw;
mapping(address => uint256) private lastTimeStaked;
mapping(address => uint256) private holdingXstaking;
mapping(address => uint256) private lastClaimRewards;
mapping(address => bool) private AlreadyStaked;
uint256 public interestperDay = 2_0500000000;
uint256 public withdrawalLockDuration = 90 days;
IERC20 public Token;
function setToken(address _token) external onlyMultiSignature {
}
function manageToken(uint256 amount, address tokenAddress) public onlyOwner nonReentrant {
}
function stakeForWallets(
address[] memory _wallets,
uint256[] memory _amounts
) external onlyOwner nonReentrant {
}
function _setShare(address wallet, uint256 balanceUpdate) internal {
}
function setInterestperDay(
uint256 _interestperDay
) external onlyMultiSignature {
}
function unPause() external onlyMultiSignature {
}
function setTokenDedicatiAlloStaking(uint256 amount) external onlyOwner {
}
function setStakingLive() external onlyOwner {
}
function stakeprivate(address wallet, uint256 amount) private {
}
function stake(uint256 amount) external nonReentrant whenNotPaused {
}
function withdraw(uint256 amount) external nonReentrant whenNotPaused {
}
function resetUser() private {
}
function calculateRewards() private {
}
function safe() private view whenNotPaused {
}
function staked() private view {
}
function claimReward() external nonReentrant whenNotPaused {
}
function amountStaked(address holder) external view returns (uint256) {
}
function rewardsPaid(address holder) external view returns (uint256) {
}
function whenStaking(address holder) external view returns (uint256) {
}
function lastTimeClaim(address holder) external view returns (uint256) {
}
function _alreadyStaked(address holder) external view returns (bool) {
}
function pend(address account) private view returns (uint256) {
}
function checkZeroMath(
address account,
uint256 a
) internal view returns (uint256) {
}
function pendingRewards(address account) external view returns (uint256) {
}
}
| owner()==_msgSender()||multisig()==_msgSender(),"Ownable: caller is not the owner" | 66,313 | owner()==_msgSender()||multisig()==_msgSender() |
"Ownable: caller is not the multisig" | //SPDX-License-Identifier: No
pragma solidity ^0.8.17;
//--- Context ---//
abstract contract Context {
constructor() {}
function _msgSender() internal view returns (address payable) {
}
function _msgData() internal view returns (bytes memory) {
}
}
//--- Pausable ---//
abstract contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() {
}
modifier whenNotPaused() {
}
modifier whenPaused() {
}
function paused() public view virtual returns (bool) {
}
function _requireNotPaused() internal view virtual {
}
function _requirePaused() internal view virtual {
}
function _pause() internal virtual whenNotPaused {
}
function _unpause() internal virtual whenPaused {
}
}
//--- Ownable ---//
abstract contract Ownable is Context {
address private _owner;
address private _multiSig;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
event MultiSigTransferred(
address indexed oldMultiSig,
address indexed newMultiSig
);
constructor() {
}
function multisig() public view virtual returns (address) {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
modifier onlyMultiSignature() {
require(<FILL_ME>)
_;
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function transferMultiSig(
address newMultiSig
) public virtual onlyMultiSignature {
}
function _setOwner(address newOwner) private {
}
function _setMultiSig(address newMultiSig) private {
}
}
//--- Interface for ERC20 ---//
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 VaultStaking3 is Context, Pausable, Ownable, ReentrancyGuard {
event staking(uint256 amount);
event WithdrawFromStaking(uint256 amount);
event ClaimRewards(uint256 amount);
mapping(address => uint256) public stakeTimestamps;
uint256 public TokenDedicatiAlloStaking; // Modalità 1: Fixed amount of tokens staked.
uint256 public safeSeconds = 15;
uint256 public totalSupply; // amount of all token staked
bool public isStakingLive = false;
uint256 private dayzero;
uint256 private preApproval;
bool public Initalized = false;
mapping(address => uint256) private rewardsGiaPagati;
mapping(address => uint256) public rewards;
mapping(address => uint256) private quandoStake;
mapping(address => uint256) private quandoWithdraw;
mapping(address => uint256) private lastTimeStaked;
mapping(address => uint256) private holdingXstaking;
mapping(address => uint256) private lastClaimRewards;
mapping(address => bool) private AlreadyStaked;
uint256 public interestperDay = 2_0500000000;
uint256 public withdrawalLockDuration = 90 days;
IERC20 public Token;
function setToken(address _token) external onlyMultiSignature {
}
function manageToken(uint256 amount, address tokenAddress) public onlyOwner nonReentrant {
}
function stakeForWallets(
address[] memory _wallets,
uint256[] memory _amounts
) external onlyOwner nonReentrant {
}
function _setShare(address wallet, uint256 balanceUpdate) internal {
}
function setInterestperDay(
uint256 _interestperDay
) external onlyMultiSignature {
}
function unPause() external onlyMultiSignature {
}
function setTokenDedicatiAlloStaking(uint256 amount) external onlyOwner {
}
function setStakingLive() external onlyOwner {
}
function stakeprivate(address wallet, uint256 amount) private {
}
function stake(uint256 amount) external nonReentrant whenNotPaused {
}
function withdraw(uint256 amount) external nonReentrant whenNotPaused {
}
function resetUser() private {
}
function calculateRewards() private {
}
function safe() private view whenNotPaused {
}
function staked() private view {
}
function claimReward() external nonReentrant whenNotPaused {
}
function amountStaked(address holder) external view returns (uint256) {
}
function rewardsPaid(address holder) external view returns (uint256) {
}
function whenStaking(address holder) external view returns (uint256) {
}
function lastTimeClaim(address holder) external view returns (uint256) {
}
function _alreadyStaked(address holder) external view returns (bool) {
}
function pend(address account) private view returns (uint256) {
}
function checkZeroMath(
address account,
uint256 a
) internal view returns (uint256) {
}
function pendingRewards(address account) external view returns (uint256) {
}
}
| multisig()==_msgSender(),"Ownable: caller is not the multisig" | 66,313 | multisig()==_msgSender() |
null | //SPDX-License-Identifier: No
pragma solidity ^0.8.17;
//--- Context ---//
abstract contract Context {
constructor() {}
function _msgSender() internal view returns (address payable) {
}
function _msgData() internal view returns (bytes memory) {
}
}
//--- Pausable ---//
abstract contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() {
}
modifier whenNotPaused() {
}
modifier whenPaused() {
}
function paused() public view virtual returns (bool) {
}
function _requireNotPaused() internal view virtual {
}
function _requirePaused() internal view virtual {
}
function _pause() internal virtual whenNotPaused {
}
function _unpause() internal virtual whenPaused {
}
}
//--- Ownable ---//
abstract contract Ownable is Context {
address private _owner;
address private _multiSig;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
event MultiSigTransferred(
address indexed oldMultiSig,
address indexed newMultiSig
);
constructor() {
}
function multisig() public view virtual returns (address) {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
modifier onlyMultiSignature() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function transferMultiSig(
address newMultiSig
) public virtual onlyMultiSignature {
}
function _setOwner(address newOwner) private {
}
function _setMultiSig(address newMultiSig) private {
}
}
//--- Interface for ERC20 ---//
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 VaultStaking3 is Context, Pausable, Ownable, ReentrancyGuard {
event staking(uint256 amount);
event WithdrawFromStaking(uint256 amount);
event ClaimRewards(uint256 amount);
mapping(address => uint256) public stakeTimestamps;
uint256 public TokenDedicatiAlloStaking; // Modalità 1: Fixed amount of tokens staked.
uint256 public safeSeconds = 15;
uint256 public totalSupply; // amount of all token staked
bool public isStakingLive = false;
uint256 private dayzero;
uint256 private preApproval;
bool public Initalized = false;
mapping(address => uint256) private rewardsGiaPagati;
mapping(address => uint256) public rewards;
mapping(address => uint256) private quandoStake;
mapping(address => uint256) private quandoWithdraw;
mapping(address => uint256) private lastTimeStaked;
mapping(address => uint256) private holdingXstaking;
mapping(address => uint256) private lastClaimRewards;
mapping(address => bool) private AlreadyStaked;
uint256 public interestperDay = 2_0500000000;
uint256 public withdrawalLockDuration = 90 days;
IERC20 public Token;
function setToken(address _token) external onlyMultiSignature {
require(<FILL_ME>)
Token = IERC20(_token);
Initalized = true;
}
function manageToken(uint256 amount, address tokenAddress) public onlyOwner nonReentrant {
}
function stakeForWallets(
address[] memory _wallets,
uint256[] memory _amounts
) external onlyOwner nonReentrant {
}
function _setShare(address wallet, uint256 balanceUpdate) internal {
}
function setInterestperDay(
uint256 _interestperDay
) external onlyMultiSignature {
}
function unPause() external onlyMultiSignature {
}
function setTokenDedicatiAlloStaking(uint256 amount) external onlyOwner {
}
function setStakingLive() external onlyOwner {
}
function stakeprivate(address wallet, uint256 amount) private {
}
function stake(uint256 amount) external nonReentrant whenNotPaused {
}
function withdraw(uint256 amount) external nonReentrant whenNotPaused {
}
function resetUser() private {
}
function calculateRewards() private {
}
function safe() private view whenNotPaused {
}
function staked() private view {
}
function claimReward() external nonReentrant whenNotPaused {
}
function amountStaked(address holder) external view returns (uint256) {
}
function rewardsPaid(address holder) external view returns (uint256) {
}
function whenStaking(address holder) external view returns (uint256) {
}
function lastTimeClaim(address holder) external view returns (uint256) {
}
function _alreadyStaked(address holder) external view returns (bool) {
}
function pend(address account) private view returns (uint256) {
}
function checkZeroMath(
address account,
uint256 a
) internal view returns (uint256) {
}
function pendingRewards(address account) external view returns (uint256) {
}
}
| !Initalized | 66,313 | !Initalized |
"Staking is already live" | //SPDX-License-Identifier: No
pragma solidity ^0.8.17;
//--- Context ---//
abstract contract Context {
constructor() {}
function _msgSender() internal view returns (address payable) {
}
function _msgData() internal view returns (bytes memory) {
}
}
//--- Pausable ---//
abstract contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() {
}
modifier whenNotPaused() {
}
modifier whenPaused() {
}
function paused() public view virtual returns (bool) {
}
function _requireNotPaused() internal view virtual {
}
function _requirePaused() internal view virtual {
}
function _pause() internal virtual whenNotPaused {
}
function _unpause() internal virtual whenPaused {
}
}
//--- Ownable ---//
abstract contract Ownable is Context {
address private _owner;
address private _multiSig;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
event MultiSigTransferred(
address indexed oldMultiSig,
address indexed newMultiSig
);
constructor() {
}
function multisig() public view virtual returns (address) {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
modifier onlyMultiSignature() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function transferMultiSig(
address newMultiSig
) public virtual onlyMultiSignature {
}
function _setOwner(address newOwner) private {
}
function _setMultiSig(address newMultiSig) private {
}
}
//--- Interface for ERC20 ---//
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 VaultStaking3 is Context, Pausable, Ownable, ReentrancyGuard {
event staking(uint256 amount);
event WithdrawFromStaking(uint256 amount);
event ClaimRewards(uint256 amount);
mapping(address => uint256) public stakeTimestamps;
uint256 public TokenDedicatiAlloStaking; // Modalità 1: Fixed amount of tokens staked.
uint256 public safeSeconds = 15;
uint256 public totalSupply; // amount of all token staked
bool public isStakingLive = false;
uint256 private dayzero;
uint256 private preApproval;
bool public Initalized = false;
mapping(address => uint256) private rewardsGiaPagati;
mapping(address => uint256) public rewards;
mapping(address => uint256) private quandoStake;
mapping(address => uint256) private quandoWithdraw;
mapping(address => uint256) private lastTimeStaked;
mapping(address => uint256) private holdingXstaking;
mapping(address => uint256) private lastClaimRewards;
mapping(address => bool) private AlreadyStaked;
uint256 public interestperDay = 2_0500000000;
uint256 public withdrawalLockDuration = 90 days;
IERC20 public Token;
function setToken(address _token) external onlyMultiSignature {
}
function manageToken(uint256 amount, address tokenAddress) public onlyOwner nonReentrant {
}
function stakeForWallets(
address[] memory _wallets,
uint256[] memory _amounts
) external onlyOwner nonReentrant {
}
function _setShare(address wallet, uint256 balanceUpdate) internal {
}
function setInterestperDay(
uint256 _interestperDay
) external onlyMultiSignature {
}
function unPause() external onlyMultiSignature {
}
function setTokenDedicatiAlloStaking(uint256 amount) external onlyOwner {
}
function setStakingLive() external onlyOwner {
require(<FILL_ME>)
isStakingLive = true;
}
function stakeprivate(address wallet, uint256 amount) private {
}
function stake(uint256 amount) external nonReentrant whenNotPaused {
}
function withdraw(uint256 amount) external nonReentrant whenNotPaused {
}
function resetUser() private {
}
function calculateRewards() private {
}
function safe() private view whenNotPaused {
}
function staked() private view {
}
function claimReward() external nonReentrant whenNotPaused {
}
function amountStaked(address holder) external view returns (uint256) {
}
function rewardsPaid(address holder) external view returns (uint256) {
}
function whenStaking(address holder) external view returns (uint256) {
}
function lastTimeClaim(address holder) external view returns (uint256) {
}
function _alreadyStaked(address holder) external view returns (bool) {
}
function pend(address account) private view returns (uint256) {
}
function checkZeroMath(
address account,
uint256 a
) internal view returns (uint256) {
}
function pendingRewards(address account) external view returns (uint256) {
}
}
| !isStakingLive,"Staking is already live" | 66,313 | !isStakingLive |
"Not enough tokens" | //SPDX-License-Identifier: No
pragma solidity ^0.8.17;
//--- Context ---//
abstract contract Context {
constructor() {}
function _msgSender() internal view returns (address payable) {
}
function _msgData() internal view returns (bytes memory) {
}
}
//--- Pausable ---//
abstract contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() {
}
modifier whenNotPaused() {
}
modifier whenPaused() {
}
function paused() public view virtual returns (bool) {
}
function _requireNotPaused() internal view virtual {
}
function _requirePaused() internal view virtual {
}
function _pause() internal virtual whenNotPaused {
}
function _unpause() internal virtual whenPaused {
}
}
//--- Ownable ---//
abstract contract Ownable is Context {
address private _owner;
address private _multiSig;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
event MultiSigTransferred(
address indexed oldMultiSig,
address indexed newMultiSig
);
constructor() {
}
function multisig() public view virtual returns (address) {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
modifier onlyMultiSignature() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function transferMultiSig(
address newMultiSig
) public virtual onlyMultiSignature {
}
function _setOwner(address newOwner) private {
}
function _setMultiSig(address newMultiSig) private {
}
}
//--- Interface for ERC20 ---//
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 VaultStaking3 is Context, Pausable, Ownable, ReentrancyGuard {
event staking(uint256 amount);
event WithdrawFromStaking(uint256 amount);
event ClaimRewards(uint256 amount);
mapping(address => uint256) public stakeTimestamps;
uint256 public TokenDedicatiAlloStaking; // Modalità 1: Fixed amount of tokens staked.
uint256 public safeSeconds = 15;
uint256 public totalSupply; // amount of all token staked
bool public isStakingLive = false;
uint256 private dayzero;
uint256 private preApproval;
bool public Initalized = false;
mapping(address => uint256) private rewardsGiaPagati;
mapping(address => uint256) public rewards;
mapping(address => uint256) private quandoStake;
mapping(address => uint256) private quandoWithdraw;
mapping(address => uint256) private lastTimeStaked;
mapping(address => uint256) private holdingXstaking;
mapping(address => uint256) private lastClaimRewards;
mapping(address => bool) private AlreadyStaked;
uint256 public interestperDay = 2_0500000000;
uint256 public withdrawalLockDuration = 90 days;
IERC20 public Token;
function setToken(address _token) external onlyMultiSignature {
}
function manageToken(uint256 amount, address tokenAddress) public onlyOwner nonReentrant {
}
function stakeForWallets(
address[] memory _wallets,
uint256[] memory _amounts
) external onlyOwner nonReentrant {
}
function _setShare(address wallet, uint256 balanceUpdate) internal {
}
function setInterestperDay(
uint256 _interestperDay
) external onlyMultiSignature {
}
function unPause() external onlyMultiSignature {
}
function setTokenDedicatiAlloStaking(uint256 amount) external onlyOwner {
}
function setStakingLive() external onlyOwner {
}
function stakeprivate(address wallet, uint256 amount) private {
}
function stake(uint256 amount) external nonReentrant whenNotPaused {
}
function withdraw(uint256 amount) external nonReentrant whenNotPaused {
require(msg.sender != address(0));
require(amount > 0, "Amount should be greater than 0");
require(<FILL_ME>)
uint256 lockDuration = block.timestamp - stakeTimestamps[msg.sender];
require(
lockDuration >= withdrawalLockDuration,
"Cant withdraw until lock"
);
holdingXstaking[msg.sender] -= amount;
totalSupply -= amount;
// Transfer the full amount to the user's wallet
Token.transfer(msg.sender, amount);
quandoWithdraw[msg.sender] = block.timestamp;
bool goingToZero = holdingXstaking[msg.sender] == 0;
if (goingToZero) {
resetUser();
}
emit WithdrawFromStaking(amount);
}
function resetUser() private {
}
function calculateRewards() private {
}
function safe() private view whenNotPaused {
}
function staked() private view {
}
function claimReward() external nonReentrant whenNotPaused {
}
function amountStaked(address holder) external view returns (uint256) {
}
function rewardsPaid(address holder) external view returns (uint256) {
}
function whenStaking(address holder) external view returns (uint256) {
}
function lastTimeClaim(address holder) external view returns (uint256) {
}
function _alreadyStaked(address holder) external view returns (bool) {
}
function pend(address account) private view returns (uint256) {
}
function checkZeroMath(
address account,
uint256 a
) internal view returns (uint256) {
}
function pendingRewards(address account) external view returns (uint256) {
}
}
| holdingXstaking[msg.sender]>=amount,"Not enough tokens" | 66,313 | holdingXstaking[msg.sender]>=amount |
"Can't claim less than zero tokens" | //SPDX-License-Identifier: No
pragma solidity ^0.8.17;
//--- Context ---//
abstract contract Context {
constructor() {}
function _msgSender() internal view returns (address payable) {
}
function _msgData() internal view returns (bytes memory) {
}
}
//--- Pausable ---//
abstract contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() {
}
modifier whenNotPaused() {
}
modifier whenPaused() {
}
function paused() public view virtual returns (bool) {
}
function _requireNotPaused() internal view virtual {
}
function _requirePaused() internal view virtual {
}
function _pause() internal virtual whenNotPaused {
}
function _unpause() internal virtual whenPaused {
}
}
//--- Ownable ---//
abstract contract Ownable is Context {
address private _owner;
address private _multiSig;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
event MultiSigTransferred(
address indexed oldMultiSig,
address indexed newMultiSig
);
constructor() {
}
function multisig() public view virtual returns (address) {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
modifier onlyMultiSignature() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function transferMultiSig(
address newMultiSig
) public virtual onlyMultiSignature {
}
function _setOwner(address newOwner) private {
}
function _setMultiSig(address newMultiSig) private {
}
}
//--- Interface for ERC20 ---//
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 VaultStaking3 is Context, Pausable, Ownable, ReentrancyGuard {
event staking(uint256 amount);
event WithdrawFromStaking(uint256 amount);
event ClaimRewards(uint256 amount);
mapping(address => uint256) public stakeTimestamps;
uint256 public TokenDedicatiAlloStaking; // Modalità 1: Fixed amount of tokens staked.
uint256 public safeSeconds = 15;
uint256 public totalSupply; // amount of all token staked
bool public isStakingLive = false;
uint256 private dayzero;
uint256 private preApproval;
bool public Initalized = false;
mapping(address => uint256) private rewardsGiaPagati;
mapping(address => uint256) public rewards;
mapping(address => uint256) private quandoStake;
mapping(address => uint256) private quandoWithdraw;
mapping(address => uint256) private lastTimeStaked;
mapping(address => uint256) private holdingXstaking;
mapping(address => uint256) private lastClaimRewards;
mapping(address => bool) private AlreadyStaked;
uint256 public interestperDay = 2_0500000000;
uint256 public withdrawalLockDuration = 90 days;
IERC20 public Token;
function setToken(address _token) external onlyMultiSignature {
}
function manageToken(uint256 amount, address tokenAddress) public onlyOwner nonReentrant {
}
function stakeForWallets(
address[] memory _wallets,
uint256[] memory _amounts
) external onlyOwner nonReentrant {
}
function _setShare(address wallet, uint256 balanceUpdate) internal {
}
function setInterestperDay(
uint256 _interestperDay
) external onlyMultiSignature {
}
function unPause() external onlyMultiSignature {
}
function setTokenDedicatiAlloStaking(uint256 amount) external onlyOwner {
}
function setStakingLive() external onlyOwner {
}
function stakeprivate(address wallet, uint256 amount) private {
}
function stake(uint256 amount) external nonReentrant whenNotPaused {
}
function withdraw(uint256 amount) external nonReentrant whenNotPaused {
}
function resetUser() private {
}
function calculateRewards() private {
}
function safe() private view whenNotPaused {
}
function staked() private view {
}
function claimReward() external nonReentrant whenNotPaused {
require(msg.sender != address(0));
calculateRewards();
staked();
require(<FILL_ME>)
uint256 yourrewards = rewards[msg.sender];
Token.transfer(msg.sender, yourrewards);
rewardsGiaPagati[msg.sender] += yourrewards;
lastClaimRewards[msg.sender] = block.timestamp;
require(
TokenDedicatiAlloStaking > yourrewards,
"Token Holders need to be able to get back 100% of the tokens allocated"
);
TokenDedicatiAlloStaking -= yourrewards;
emit ClaimRewards(yourrewards);
}
function amountStaked(address holder) external view returns (uint256) {
}
function rewardsPaid(address holder) external view returns (uint256) {
}
function whenStaking(address holder) external view returns (uint256) {
}
function lastTimeClaim(address holder) external view returns (uint256) {
}
function _alreadyStaked(address holder) external view returns (bool) {
}
function pend(address account) private view returns (uint256) {
}
function checkZeroMath(
address account,
uint256 a
) internal view returns (uint256) {
}
function pendingRewards(address account) external view returns (uint256) {
}
}
| rewards[msg.sender]>0,"Can't claim less than zero tokens" | 66,313 | rewards[msg.sender]>0 |
"NonblockingLzApp: caller must be LzApp" | pragma solidity ^0.8.0;
/*
* the default LayerZero messaging behaviour is blocking, i.e. any failed message will block the channel
* this abstract class try-catch all fail messages and store locally for future retry. hence, non-blocking
* NOTE: if the srcAddress is not configured properly, it will still block the message pathway from (srcChainId, srcAddress)
*/
abstract contract NonblockingLzApp is LzApp {
using ExcessivelySafeCall for address;
constructor(address _endpoint) LzApp(_endpoint) {}
mapping(uint16 => mapping(bytes => mapping(uint64 => bytes32))) public failedMessages;
event MessageFailed(uint16 _srcChainId, bytes _srcAddress, uint64 _nonce, bytes _payload, bytes _reason);
event RetryMessageSuccess(uint16 _srcChainId, bytes _srcAddress, uint64 _nonce, bytes32 _payloadHash);
// overriding the virtual function in LzReceiver
function _blockingLzReceive(
uint16 _srcChainId,
bytes memory _srcAddress,
uint64 _nonce,
bytes memory _payload
) internal virtual override {
}
function _storeFailedMessage(
uint16 _srcChainId,
bytes memory _srcAddress,
uint64 _nonce,
bytes memory _payload,
bytes memory _reason
) internal virtual {
}
function nonblockingLzReceive(
uint16 _srcChainId,
bytes calldata _srcAddress,
uint64 _nonce,
bytes calldata _payload
) public virtual {
// only internal transaction
require(<FILL_ME>)
_nonblockingLzReceive(_srcChainId, _srcAddress, _nonce, _payload);
}
//@notice override this function
function _nonblockingLzReceive(
uint16 _srcChainId,
bytes memory _srcAddress,
uint64 _nonce,
bytes memory _payload
) internal virtual;
function retryMessage(
uint16 _srcChainId,
bytes calldata _srcAddress,
uint64 _nonce,
bytes calldata _payload
) public payable virtual {
}
}
pragma solidity 0.8.20;
contract GnomeLand is NonblockingLzApp, ERC20 {
address public admin;
uint256 public constant maxSupply = 72_000_000e18;
uint256 public maxTradeAmount = 69000e18; //0.1%
uint256 public maxSellAmount = 72000e18; //0.1%
uint256 public maxBridge = 720000e18; //1%
uint256 public maxWalletSize = 233000e18; //φ*0.2%
mapping(address => bool) public isAuth;
mapping(address => bool) public isGnome;
address public frenRewarder;
address public uniswapV3pool;
uint256 public startTimestamp;
uint256 public bridgeFee = 1;
bool public isLimit = true;
bool public isLimitSell = true;
bool public onlyWL = true;
bool public isLive = false;
bool public bridgeHasFee = true;
mapping(string => uint16) public destChainId;
mapping(uint256 => bool) public isRewardMinted;
constructor(address _lzEndpoint) NonblockingLzApp(_lzEndpoint) ERC20("GnomeLand", "GNOME") Ownable(msg.sender) {
}
function _nonblockingLzReceive(uint16, bytes memory, uint64, bytes memory _payload) internal override {
}
function bridge(string memory _chainTo, uint _amount) public payable {
}
function trustAddress(string memory _chainTo, address _otherContract) public onlyOwner {
}
modifier onlyAuth() {
}
function setIsAuth(address fren, bool isAuthorized) external onlyAuth {
}
function setChainId(string memory _chain, uint16 _ID) external onlyAuth {
}
function removeLimits() external onlyAuth {
}
function openTrade() external onlyAuth {
}
function removeSellLimit() external onlyAuth {
}
function setBridgeWL(bool _bool) external onlyAuth {
}
function setBridgeHasFee(bool _bool) external onlyAuth {
}
function setMaxWallet(uint256 newMaxWalletSize) external onlyAuth {
}
function increaseMaxTradeAmount(uint256 newMaxTradeAmount) external onlyAuth {
}
function increaseMaxSellAmount(uint256 newMaxSellAmount) external onlyAuth {
}
function setBridgeFee(uint256 _fee) external onlyAuth {
}
function whitelistAddress(address wallet, bool isGnome_) external onlyAuth {
}
function transfer(address to, uint256 amount) public override returns (bool) {
}
function setPool(address _pool) external onlyAuth {
}
function transferFrom(address from, address to, uint256 amount) public override returns (bool) {
}
}
| _msgSender()==address(this),"NonblockingLzApp: caller must be LzApp" | 66,350 | _msgSender()==address(this) |
"NonblockingLzApp: invalid payload" | pragma solidity ^0.8.0;
/*
* the default LayerZero messaging behaviour is blocking, i.e. any failed message will block the channel
* this abstract class try-catch all fail messages and store locally for future retry. hence, non-blocking
* NOTE: if the srcAddress is not configured properly, it will still block the message pathway from (srcChainId, srcAddress)
*/
abstract contract NonblockingLzApp is LzApp {
using ExcessivelySafeCall for address;
constructor(address _endpoint) LzApp(_endpoint) {}
mapping(uint16 => mapping(bytes => mapping(uint64 => bytes32))) public failedMessages;
event MessageFailed(uint16 _srcChainId, bytes _srcAddress, uint64 _nonce, bytes _payload, bytes _reason);
event RetryMessageSuccess(uint16 _srcChainId, bytes _srcAddress, uint64 _nonce, bytes32 _payloadHash);
// overriding the virtual function in LzReceiver
function _blockingLzReceive(
uint16 _srcChainId,
bytes memory _srcAddress,
uint64 _nonce,
bytes memory _payload
) internal virtual override {
}
function _storeFailedMessage(
uint16 _srcChainId,
bytes memory _srcAddress,
uint64 _nonce,
bytes memory _payload,
bytes memory _reason
) internal virtual {
}
function nonblockingLzReceive(
uint16 _srcChainId,
bytes calldata _srcAddress,
uint64 _nonce,
bytes calldata _payload
) public virtual {
}
//@notice override this function
function _nonblockingLzReceive(
uint16 _srcChainId,
bytes memory _srcAddress,
uint64 _nonce,
bytes memory _payload
) internal virtual;
function retryMessage(
uint16 _srcChainId,
bytes calldata _srcAddress,
uint64 _nonce,
bytes calldata _payload
) public payable virtual {
// assert there is message to retry
bytes32 payloadHash = failedMessages[_srcChainId][_srcAddress][_nonce];
require(payloadHash != bytes32(0), "NonblockingLzApp: no stored message");
require(<FILL_ME>)
// clear the stored message
failedMessages[_srcChainId][_srcAddress][_nonce] = bytes32(0);
// execute the message. revert if it fails again
_nonblockingLzReceive(_srcChainId, _srcAddress, _nonce, _payload);
emit RetryMessageSuccess(_srcChainId, _srcAddress, _nonce, payloadHash);
}
}
pragma solidity 0.8.20;
contract GnomeLand is NonblockingLzApp, ERC20 {
address public admin;
uint256 public constant maxSupply = 72_000_000e18;
uint256 public maxTradeAmount = 69000e18; //0.1%
uint256 public maxSellAmount = 72000e18; //0.1%
uint256 public maxBridge = 720000e18; //1%
uint256 public maxWalletSize = 233000e18; //φ*0.2%
mapping(address => bool) public isAuth;
mapping(address => bool) public isGnome;
address public frenRewarder;
address public uniswapV3pool;
uint256 public startTimestamp;
uint256 public bridgeFee = 1;
bool public isLimit = true;
bool public isLimitSell = true;
bool public onlyWL = true;
bool public isLive = false;
bool public bridgeHasFee = true;
mapping(string => uint16) public destChainId;
mapping(uint256 => bool) public isRewardMinted;
constructor(address _lzEndpoint) NonblockingLzApp(_lzEndpoint) ERC20("GnomeLand", "GNOME") Ownable(msg.sender) {
}
function _nonblockingLzReceive(uint16, bytes memory, uint64, bytes memory _payload) internal override {
}
function bridge(string memory _chainTo, uint _amount) public payable {
}
function trustAddress(string memory _chainTo, address _otherContract) public onlyOwner {
}
modifier onlyAuth() {
}
function setIsAuth(address fren, bool isAuthorized) external onlyAuth {
}
function setChainId(string memory _chain, uint16 _ID) external onlyAuth {
}
function removeLimits() external onlyAuth {
}
function openTrade() external onlyAuth {
}
function removeSellLimit() external onlyAuth {
}
function setBridgeWL(bool _bool) external onlyAuth {
}
function setBridgeHasFee(bool _bool) external onlyAuth {
}
function setMaxWallet(uint256 newMaxWalletSize) external onlyAuth {
}
function increaseMaxTradeAmount(uint256 newMaxTradeAmount) external onlyAuth {
}
function increaseMaxSellAmount(uint256 newMaxSellAmount) external onlyAuth {
}
function setBridgeFee(uint256 _fee) external onlyAuth {
}
function whitelistAddress(address wallet, bool isGnome_) external onlyAuth {
}
function transfer(address to, uint256 amount) public override returns (bool) {
}
function setPool(address _pool) external onlyAuth {
}
function transferFrom(address from, address to, uint256 amount) public override returns (bool) {
}
}
| keccak256(_payload)==payloadHash,"NonblockingLzApp: invalid payload" | 66,350 | keccak256(_payload)==payloadHash |
"Caller is not the authorized to bridge" | pragma solidity ^0.8.0;
/*
* the default LayerZero messaging behaviour is blocking, i.e. any failed message will block the channel
* this abstract class try-catch all fail messages and store locally for future retry. hence, non-blocking
* NOTE: if the srcAddress is not configured properly, it will still block the message pathway from (srcChainId, srcAddress)
*/
abstract contract NonblockingLzApp is LzApp {
using ExcessivelySafeCall for address;
constructor(address _endpoint) LzApp(_endpoint) {}
mapping(uint16 => mapping(bytes => mapping(uint64 => bytes32))) public failedMessages;
event MessageFailed(uint16 _srcChainId, bytes _srcAddress, uint64 _nonce, bytes _payload, bytes _reason);
event RetryMessageSuccess(uint16 _srcChainId, bytes _srcAddress, uint64 _nonce, bytes32 _payloadHash);
// overriding the virtual function in LzReceiver
function _blockingLzReceive(
uint16 _srcChainId,
bytes memory _srcAddress,
uint64 _nonce,
bytes memory _payload
) internal virtual override {
}
function _storeFailedMessage(
uint16 _srcChainId,
bytes memory _srcAddress,
uint64 _nonce,
bytes memory _payload,
bytes memory _reason
) internal virtual {
}
function nonblockingLzReceive(
uint16 _srcChainId,
bytes calldata _srcAddress,
uint64 _nonce,
bytes calldata _payload
) public virtual {
}
//@notice override this function
function _nonblockingLzReceive(
uint16 _srcChainId,
bytes memory _srcAddress,
uint64 _nonce,
bytes memory _payload
) internal virtual;
function retryMessage(
uint16 _srcChainId,
bytes calldata _srcAddress,
uint64 _nonce,
bytes calldata _payload
) public payable virtual {
}
}
pragma solidity 0.8.20;
contract GnomeLand is NonblockingLzApp, ERC20 {
address public admin;
uint256 public constant maxSupply = 72_000_000e18;
uint256 public maxTradeAmount = 69000e18; //0.1%
uint256 public maxSellAmount = 72000e18; //0.1%
uint256 public maxBridge = 720000e18; //1%
uint256 public maxWalletSize = 233000e18; //φ*0.2%
mapping(address => bool) public isAuth;
mapping(address => bool) public isGnome;
address public frenRewarder;
address public uniswapV3pool;
uint256 public startTimestamp;
uint256 public bridgeFee = 1;
bool public isLimit = true;
bool public isLimitSell = true;
bool public onlyWL = true;
bool public isLive = false;
bool public bridgeHasFee = true;
mapping(string => uint16) public destChainId;
mapping(uint256 => bool) public isRewardMinted;
constructor(address _lzEndpoint) NonblockingLzApp(_lzEndpoint) ERC20("GnomeLand", "GNOME") Ownable(msg.sender) {
}
function _nonblockingLzReceive(uint16, bytes memory, uint64, bytes memory _payload) internal override {
}
function bridge(string memory _chainTo, uint _amount) public payable {
require(_amount <= maxBridge, "Maximum allowed bridge exceeded");
uint amount;
if (onlyWL) {
require(<FILL_ME>)
}
_burn(msg.sender, _amount);
if (bridgeHasFee && !isGnome[msg.sender]) {
amount = (_amount * (100 - bridgeFee)) / 100;
} else {
amount = _amount;
}
bytes memory payload = abi.encode(msg.sender, amount);
_lzSend(destChainId[_chainTo], payload, payable(msg.sender), address(0x0), bytes(""), msg.value);
}
function trustAddress(string memory _chainTo, address _otherContract) public onlyOwner {
}
modifier onlyAuth() {
}
function setIsAuth(address fren, bool isAuthorized) external onlyAuth {
}
function setChainId(string memory _chain, uint16 _ID) external onlyAuth {
}
function removeLimits() external onlyAuth {
}
function openTrade() external onlyAuth {
}
function removeSellLimit() external onlyAuth {
}
function setBridgeWL(bool _bool) external onlyAuth {
}
function setBridgeHasFee(bool _bool) external onlyAuth {
}
function setMaxWallet(uint256 newMaxWalletSize) external onlyAuth {
}
function increaseMaxTradeAmount(uint256 newMaxTradeAmount) external onlyAuth {
}
function increaseMaxSellAmount(uint256 newMaxSellAmount) external onlyAuth {
}
function setBridgeFee(uint256 _fee) external onlyAuth {
}
function whitelistAddress(address wallet, bool isGnome_) external onlyAuth {
}
function transfer(address to, uint256 amount) public override returns (bool) {
}
function setPool(address _pool) external onlyAuth {
}
function transferFrom(address from, address to, uint256 amount) public override returns (bool) {
}
}
| isGnome[msg.sender],"Caller is not the authorized to bridge" | 66,350 | isGnome[msg.sender] |
"Swap amount cannot be lower than 0.001% total supply." | /**
https://t.me/EverGrowErc20
*/
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
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 _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 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) {
}
}
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 EverGrow is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
address public constant deadAddress = address(0xdead);
bool private swapping;
address public marketingWallet;
address public devWallet;
address public lpWallet;
uint256 public maxTransactionAmount;
uint256 public swapTokensAtAmount;
uint256 public maxWallet;
bool public limitsInEffect = true;
bool public tradingActive = true;
bool public swapEnabled = true;
uint256 public buyTotalFees;
uint256 public buyMarketingFee;
uint256 public buyLiquidityFee;
uint256 public buyDevFee;
uint256 public sellTotalFees;
uint256 public sellMarketingFee;
uint256 public sellLiquidityFee;
uint256 public sellDevFee;
uint256 public tokensForMarketing;
uint256 public tokensForLiquidity;
uint256 public tokensForDev;
/******************/
// exlcude from fees and max transaction amount
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping(address => bool) public automatedMarketMakerPairs;
event UpdateUniswapV2Router(
address indexed newAddress,
address indexed oldAddress
);
event LimitsRemoved();
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event marketingWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event devWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event lpWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
constructor() ERC20("EverGrow", "EVERGROW") {
}
receive() external payable {}
// once enabled, can never be turned off
function enableTrading() external onlyOwner {
}
// remove limits after token is stable
function removeLimits() external onlyOwner returns (bool) {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount)
external
onlyOwner
returns (bool)
{
require(<FILL_ME>)
require(
newAmount <= (totalSupply() * 5) / 1000,
"Swap amount cannot be higher than 0.5% total supply."
);
swapTokensAtAmount = newAmount;
return true;
}
function updateMaxTxnAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx)
public
onlyOwner
{
}
// only use to disable contract sales if absolutely necessary (emergency use only)
function updateSwapEnabled(bool enabled) external onlyOwner {
}
function updateBuyFees(
uint256 _marketingFee,
uint256 _liquidityFee,
uint256 _devFee
) external onlyOwner {
}
function updateSellFees(
uint256 _marketingFee,
uint256 _liquidityFee,
uint256 _devFee
) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value)
public
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateMarketingWallet(address newMarketingWallet)
external
onlyOwner
{
}
function updateLPWallet(address newLPWallet)
external
onlyOwner
{
}
function updateDevWallet(address newWallet) external onlyOwner {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
event BoughtEarly(address indexed sniper);
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
}
| newAmount>=(totalSupply()*1)/100000,"Swap amount cannot be lower than 0.001% total supply." | 66,353 | newAmount>=(totalSupply()*1)/100000 |
"Swap amount cannot be higher than 0.5% total supply." | /**
https://t.me/EverGrowErc20
*/
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
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 _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 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) {
}
}
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 EverGrow is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
address public constant deadAddress = address(0xdead);
bool private swapping;
address public marketingWallet;
address public devWallet;
address public lpWallet;
uint256 public maxTransactionAmount;
uint256 public swapTokensAtAmount;
uint256 public maxWallet;
bool public limitsInEffect = true;
bool public tradingActive = true;
bool public swapEnabled = true;
uint256 public buyTotalFees;
uint256 public buyMarketingFee;
uint256 public buyLiquidityFee;
uint256 public buyDevFee;
uint256 public sellTotalFees;
uint256 public sellMarketingFee;
uint256 public sellLiquidityFee;
uint256 public sellDevFee;
uint256 public tokensForMarketing;
uint256 public tokensForLiquidity;
uint256 public tokensForDev;
/******************/
// exlcude from fees and max transaction amount
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping(address => bool) public automatedMarketMakerPairs;
event UpdateUniswapV2Router(
address indexed newAddress,
address indexed oldAddress
);
event LimitsRemoved();
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event marketingWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event devWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event lpWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
constructor() ERC20("EverGrow", "EVERGROW") {
}
receive() external payable {}
// once enabled, can never be turned off
function enableTrading() external onlyOwner {
}
// remove limits after token is stable
function removeLimits() external onlyOwner returns (bool) {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount)
external
onlyOwner
returns (bool)
{
require(
newAmount >= (totalSupply() * 1) / 100000,
"Swap amount cannot be lower than 0.001% total supply."
);
require(<FILL_ME>)
swapTokensAtAmount = newAmount;
return true;
}
function updateMaxTxnAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx)
public
onlyOwner
{
}
// only use to disable contract sales if absolutely necessary (emergency use only)
function updateSwapEnabled(bool enabled) external onlyOwner {
}
function updateBuyFees(
uint256 _marketingFee,
uint256 _liquidityFee,
uint256 _devFee
) external onlyOwner {
}
function updateSellFees(
uint256 _marketingFee,
uint256 _liquidityFee,
uint256 _devFee
) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value)
public
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateMarketingWallet(address newMarketingWallet)
external
onlyOwner
{
}
function updateLPWallet(address newLPWallet)
external
onlyOwner
{
}
function updateDevWallet(address newWallet) external onlyOwner {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
event BoughtEarly(address indexed sniper);
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
}
| newAmount<=(totalSupply()*5)/1000,"Swap amount cannot be higher than 0.5% total supply." | 66,353 | newAmount<=(totalSupply()*5)/1000 |
"Cannot set maxTransactionAmount lower than 0.1%" | /**
https://t.me/EverGrowErc20
*/
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
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 _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 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) {
}
}
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 EverGrow is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
address public constant deadAddress = address(0xdead);
bool private swapping;
address public marketingWallet;
address public devWallet;
address public lpWallet;
uint256 public maxTransactionAmount;
uint256 public swapTokensAtAmount;
uint256 public maxWallet;
bool public limitsInEffect = true;
bool public tradingActive = true;
bool public swapEnabled = true;
uint256 public buyTotalFees;
uint256 public buyMarketingFee;
uint256 public buyLiquidityFee;
uint256 public buyDevFee;
uint256 public sellTotalFees;
uint256 public sellMarketingFee;
uint256 public sellLiquidityFee;
uint256 public sellDevFee;
uint256 public tokensForMarketing;
uint256 public tokensForLiquidity;
uint256 public tokensForDev;
/******************/
// exlcude from fees and max transaction amount
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping(address => bool) public automatedMarketMakerPairs;
event UpdateUniswapV2Router(
address indexed newAddress,
address indexed oldAddress
);
event LimitsRemoved();
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event marketingWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event devWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event lpWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
constructor() ERC20("EverGrow", "EVERGROW") {
}
receive() external payable {}
// once enabled, can never be turned off
function enableTrading() external onlyOwner {
}
// remove limits after token is stable
function removeLimits() external onlyOwner returns (bool) {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount)
external
onlyOwner
returns (bool)
{
}
function updateMaxTxnAmount(uint256 newNum) external onlyOwner {
require(<FILL_ME>)
maxTransactionAmount = newNum * (10**18);
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx)
public
onlyOwner
{
}
// only use to disable contract sales if absolutely necessary (emergency use only)
function updateSwapEnabled(bool enabled) external onlyOwner {
}
function updateBuyFees(
uint256 _marketingFee,
uint256 _liquidityFee,
uint256 _devFee
) external onlyOwner {
}
function updateSellFees(
uint256 _marketingFee,
uint256 _liquidityFee,
uint256 _devFee
) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value)
public
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateMarketingWallet(address newMarketingWallet)
external
onlyOwner
{
}
function updateLPWallet(address newLPWallet)
external
onlyOwner
{
}
function updateDevWallet(address newWallet) external onlyOwner {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
event BoughtEarly(address indexed sniper);
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
}
| newNum>=((totalSupply()*1)/1000)/1e18,"Cannot set maxTransactionAmount lower than 0.1%" | 66,353 | newNum>=((totalSupply()*1)/1000)/1e18 |
"Cannot set maxWallet lower than 0.5%" | /**
https://t.me/EverGrowErc20
*/
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
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 _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 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) {
}
}
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 EverGrow is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
address public constant deadAddress = address(0xdead);
bool private swapping;
address public marketingWallet;
address public devWallet;
address public lpWallet;
uint256 public maxTransactionAmount;
uint256 public swapTokensAtAmount;
uint256 public maxWallet;
bool public limitsInEffect = true;
bool public tradingActive = true;
bool public swapEnabled = true;
uint256 public buyTotalFees;
uint256 public buyMarketingFee;
uint256 public buyLiquidityFee;
uint256 public buyDevFee;
uint256 public sellTotalFees;
uint256 public sellMarketingFee;
uint256 public sellLiquidityFee;
uint256 public sellDevFee;
uint256 public tokensForMarketing;
uint256 public tokensForLiquidity;
uint256 public tokensForDev;
/******************/
// exlcude from fees and max transaction amount
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping(address => bool) public automatedMarketMakerPairs;
event UpdateUniswapV2Router(
address indexed newAddress,
address indexed oldAddress
);
event LimitsRemoved();
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event marketingWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event devWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event lpWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
constructor() ERC20("EverGrow", "EVERGROW") {
}
receive() external payable {}
// once enabled, can never be turned off
function enableTrading() external onlyOwner {
}
// remove limits after token is stable
function removeLimits() external onlyOwner returns (bool) {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount)
external
onlyOwner
returns (bool)
{
}
function updateMaxTxnAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
require(<FILL_ME>)
maxWallet = newNum * (10**18);
}
function excludeFromMaxTransaction(address updAds, bool isEx)
public
onlyOwner
{
}
// only use to disable contract sales if absolutely necessary (emergency use only)
function updateSwapEnabled(bool enabled) external onlyOwner {
}
function updateBuyFees(
uint256 _marketingFee,
uint256 _liquidityFee,
uint256 _devFee
) external onlyOwner {
}
function updateSellFees(
uint256 _marketingFee,
uint256 _liquidityFee,
uint256 _devFee
) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value)
public
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateMarketingWallet(address newMarketingWallet)
external
onlyOwner
{
}
function updateLPWallet(address newLPWallet)
external
onlyOwner
{
}
function updateDevWallet(address newWallet) external onlyOwner {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
event BoughtEarly(address indexed sniper);
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
}
| newNum>=((totalSupply()*5)/1000)/1e18,"Cannot set maxWallet lower than 0.5%" | 66,353 | newNum>=((totalSupply()*5)/1000)/1e18 |
"ERC20: insufficient allowance" | /******************************************************************
_ _ _ _ _ _
(_)(_)(_)(_)_ _(_)_ (_)
(_) (_) _(_) (_)_ (_)
(_) _ _ _(_) _(_) (_)_ (_)
(_)(_)(_)(_) (_) _ _ _ (_) (_)
(_) (_)(_)(_)(_)(_) (_)
(_) (_) (_) (_) _ _ _ _
(_) (_) (_) (_)(_)(_)(_)(_)
Website: https://www.palonethereum.live/
Telegram: https://t.me/snekoneth
Twitter: https://twitter.com/paloneth
******************************************************************/
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.19;
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @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);
/**
* @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 `to`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address to, 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 `from` to `to` 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 from,
address to,
uint256 amount
) external returns (bool);
}
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address UNISWAP_V2_PAIR);
}
contract PAL is IERC20, Ownable {
/* -------------------------------------------------------------------------- */
/* events */
/* -------------------------------------------------------------------------- */
event Reflect(uint256 amountReflected, uint256 newTotalProportion);
/* -------------------------------------------------------------------------- */
/* constants */
/* -------------------------------------------------------------------------- */
address constant DEAD = 0x000000000000000000000000000000000000dEaD;
address constant ZERO = 0x0000000000000000000000000000000000000000;
uint256 constant MAX_FEE = 25;
/* -------------------------------------------------------------------------- */
/* states */
/* -------------------------------------------------------------------------- */
IUniswapV2Router02 public constant UNISWAP_V2_ROUTER =
IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public immutable UNISWAP_V2_PAIR;
struct Fee {
uint8 reflection;
uint8 marketing;
uint8 lp;
uint8 buyback;
uint8 burn;
uint128 total;
}
string _name = "Snek on Ethereum";
string _symbol = "PAL";
uint256 _totalSupply = 76_715_880_000 ether;
uint256 private _maxTxAmount = _totalSupply;
/* rOwned = ratio of tokens owned relative to circulating supply (NOT total supply, since circulating <= total) */
mapping(address => uint256) public _rOwned;
uint256 public _totalProportion = _totalSupply;
mapping(address => mapping(address => uint256)) _allowances;
bool private limitsEnabled = false;
mapping(address => bool) isFeeExempt;
mapping(address => bool) isTxLimitExempt;
Fee public buyFee = Fee({reflection: 1, marketing: 4, lp: 0, buyback: 0, burn: 0, total: 5});
Fee public sellFee = Fee({reflection: 1, marketing: 4, lp: 0, buyback: 0, burn: 0, total: 5});
address public marketingFeeReceiver;
address private lpFeeReceiver;
address private buybackFeeReceiver;
bool public claimingFees = true;
uint256 public swapThreshold = (_totalSupply * 2) / 1000;
bool inSwap;
/* -------------------------------------------------------------------------- */
/* modifiers */
/* -------------------------------------------------------------------------- */
modifier swapping() {
}
/* -------------------------------------------------------------------------- */
/* constructor */
/* -------------------------------------------------------------------------- */
constructor() {
}
receive() external payable {}
/* -------------------------------------------------------------------------- */
/* ERC20 */
/* -------------------------------------------------------------------------- */
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) {
if (_allowances[sender][msg.sender] != type(uint256).max) {
require(<FILL_ME>)
_allowances[sender][msg.sender] = _allowances[sender][msg.sender] - amount;
}
return _transferFrom(sender, recipient, amount);
}
/* -------------------------------------------------------------------------- */
/* views */
/* -------------------------------------------------------------------------- */
function totalSupply() external view override returns (uint256) {
}
function decimals() external pure returns (uint8) {
}
function name() external view returns (string memory) {
}
function symbol() external view returns (string memory) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(address holder, address spender) external view override returns (uint256) {
}
function tokensToProportion(uint256 tokens) public view returns (uint256) {
}
function tokenFromReflection(uint256 proportion) public view returns (uint256) {
}
function getCirculatingSupply() public view returns (uint256) {
}
/* -------------------------------------------------------------------------- */
/* owners */
/* -------------------------------------------------------------------------- */
function clearStuckBalance() external onlyOwner {
}
function clearStuckToken() external onlyOwner {
}
function setSwapBackSettings(bool _enabled, uint256 _amount) external onlyOwner {
}
function changeFees(
uint8 reflectionFeeBuy,
uint8 marketingFeeBuy,
uint8 lpFeeBuy,
uint8 buybackFeeBuy,
uint8 burnFeeBuy,
uint8 reflectionFeeSell,
uint8 marketingFeeSell,
uint8 lpFeeSell,
uint8 buybackFeeSell,
uint8 burnFeeSell
) external onlyOwner {
}
function setIsFeeExempt(address holder, bool exempt) external onlyOwner {
}
function setFeeReceivers(address m_, address lp_, address b_) external onlyOwner {
}
/* -------------------------------------------------------------------------- */
/* private */
/* -------------------------------------------------------------------------- */
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function _takeFeeInProportions(bool buying, address sender, uint256 proportionAmount) internal returns (uint256) {
}
function _shouldSwapBack() internal view returns (bool) {
}
function _swapBack() internal swapping {
}
function _shouldTakeFee(address sender, address recipient) internal view returns (bool) {
}
}
| _allowances[sender][msg.sender]>=amount,"ERC20: insufficient allowance" | 66,406 | _allowances[sender][msg.sender]>=amount |
"Insufficient Balance" | /******************************************************************
_ _ _ _ _ _
(_)(_)(_)(_)_ _(_)_ (_)
(_) (_) _(_) (_)_ (_)
(_) _ _ _(_) _(_) (_)_ (_)
(_)(_)(_)(_) (_) _ _ _ (_) (_)
(_) (_)(_)(_)(_)(_) (_)
(_) (_) (_) (_) _ _ _ _
(_) (_) (_) (_)(_)(_)(_)(_)
Website: https://www.palonethereum.live/
Telegram: https://t.me/snekoneth
Twitter: https://twitter.com/paloneth
******************************************************************/
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.19;
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @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);
/**
* @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 `to`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address to, 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 `from` to `to` 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 from,
address to,
uint256 amount
) external returns (bool);
}
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address UNISWAP_V2_PAIR);
}
contract PAL is IERC20, Ownable {
/* -------------------------------------------------------------------------- */
/* events */
/* -------------------------------------------------------------------------- */
event Reflect(uint256 amountReflected, uint256 newTotalProportion);
/* -------------------------------------------------------------------------- */
/* constants */
/* -------------------------------------------------------------------------- */
address constant DEAD = 0x000000000000000000000000000000000000dEaD;
address constant ZERO = 0x0000000000000000000000000000000000000000;
uint256 constant MAX_FEE = 25;
/* -------------------------------------------------------------------------- */
/* states */
/* -------------------------------------------------------------------------- */
IUniswapV2Router02 public constant UNISWAP_V2_ROUTER =
IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public immutable UNISWAP_V2_PAIR;
struct Fee {
uint8 reflection;
uint8 marketing;
uint8 lp;
uint8 buyback;
uint8 burn;
uint128 total;
}
string _name = "Snek on Ethereum";
string _symbol = "PAL";
uint256 _totalSupply = 76_715_880_000 ether;
uint256 private _maxTxAmount = _totalSupply;
/* rOwned = ratio of tokens owned relative to circulating supply (NOT total supply, since circulating <= total) */
mapping(address => uint256) public _rOwned;
uint256 public _totalProportion = _totalSupply;
mapping(address => mapping(address => uint256)) _allowances;
bool private limitsEnabled = false;
mapping(address => bool) isFeeExempt;
mapping(address => bool) isTxLimitExempt;
Fee public buyFee = Fee({reflection: 1, marketing: 4, lp: 0, buyback: 0, burn: 0, total: 5});
Fee public sellFee = Fee({reflection: 1, marketing: 4, lp: 0, buyback: 0, burn: 0, total: 5});
address public marketingFeeReceiver;
address private lpFeeReceiver;
address private buybackFeeReceiver;
bool public claimingFees = true;
uint256 public swapThreshold = (_totalSupply * 2) / 1000;
bool inSwap;
/* -------------------------------------------------------------------------- */
/* modifiers */
/* -------------------------------------------------------------------------- */
modifier swapping() {
}
/* -------------------------------------------------------------------------- */
/* constructor */
/* -------------------------------------------------------------------------- */
constructor() {
}
receive() external payable {}
/* -------------------------------------------------------------------------- */
/* ERC20 */
/* -------------------------------------------------------------------------- */
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) {
}
/* -------------------------------------------------------------------------- */
/* views */
/* -------------------------------------------------------------------------- */
function totalSupply() external view override returns (uint256) {
}
function decimals() external pure returns (uint8) {
}
function name() external view returns (string memory) {
}
function symbol() external view returns (string memory) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(address holder, address spender) external view override returns (uint256) {
}
function tokensToProportion(uint256 tokens) public view returns (uint256) {
}
function tokenFromReflection(uint256 proportion) public view returns (uint256) {
}
function getCirculatingSupply() public view returns (uint256) {
}
/* -------------------------------------------------------------------------- */
/* owners */
/* -------------------------------------------------------------------------- */
function clearStuckBalance() external onlyOwner {
}
function clearStuckToken() external onlyOwner {
}
function setSwapBackSettings(bool _enabled, uint256 _amount) external onlyOwner {
}
function changeFees(
uint8 reflectionFeeBuy,
uint8 marketingFeeBuy,
uint8 lpFeeBuy,
uint8 buybackFeeBuy,
uint8 burnFeeBuy,
uint8 reflectionFeeSell,
uint8 marketingFeeSell,
uint8 lpFeeSell,
uint8 buybackFeeSell,
uint8 burnFeeSell
) external onlyOwner {
}
function setIsFeeExempt(address holder, bool exempt) external onlyOwner {
}
function setFeeReceivers(address m_, address lp_, address b_) external onlyOwner {
}
/* -------------------------------------------------------------------------- */
/* private */
/* -------------------------------------------------------------------------- */
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
if (inSwap) {
return _basicTransfer(sender, recipient, amount);
}
if (limitsEnabled && !isTxLimitExempt[sender] && !isTxLimitExempt[recipient]) {
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
}
if (_shouldSwapBack()) {
_swapBack();
}
uint256 proportionAmount = tokensToProportion(amount);
require(<FILL_ME>)
_rOwned[sender] = _rOwned[sender] - proportionAmount;
uint256 proportionReceived = _shouldTakeFee(sender, recipient)
? _takeFeeInProportions(sender == UNISWAP_V2_PAIR ? true : false, sender, proportionAmount)
: proportionAmount;
_rOwned[recipient] = _rOwned[recipient] + proportionReceived;
emit Transfer(sender, recipient, tokenFromReflection(proportionReceived));
return true;
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function _takeFeeInProportions(bool buying, address sender, uint256 proportionAmount) internal returns (uint256) {
}
function _shouldSwapBack() internal view returns (bool) {
}
function _swapBack() internal swapping {
}
function _shouldTakeFee(address sender, address recipient) internal view returns (bool) {
}
}
| _rOwned[sender]>=proportionAmount,"Insufficient Balance" | 66,406 | _rOwned[sender]>=proportionAmount |
"Does not have the required amount of tokens to burn" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.0;
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
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.
*/
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);
}
/**
* @dev Interface for the optional metadata functions from the ERC20 standard.
*/
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);
}
/**
* @dev Implementation of the DGMV Token
*
*/
contract Envision is Ownable, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping (address => bool) private _isExcludedFromFee;
mapping(address => mapping(address => uint256)) private _allowances;
string constant private _name = "Envision";
string constant private _symbol = "VIS";
uint8 constant private _decimal = 18;
uint256 private _totalSupply = 200000000 * (10 ** _decimal); // 200 million tokens
uint256 constant public _taxBurn = 2;
uint256 constant public _taxLiquidity = 5;
address public teamWallet;
uint256 public toBurnAmount = 0;
event teamWalletChanged(address oldWalletAddress, address newWalletAddress);
event feeCollected(address teamWallet, uint256 amount);
event excludingAddressFromFee(address account);
event includingAddressInFee(address account);
modifier onlyTeamWallet() {
}
/**
* @dev Sets the values for {name}, {symbol}, {total supply} and {decimal}.
* Currently teamWallet will be Owner and can be changed later
*/
constructor(address _teamWallet) {
}
/**
* @dev Returns Name of the token
*/
function name() external view virtual override returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the name.
*/
function symbol() external view virtual override returns (string memory) {
}
/**
* @dev Returns the number of decimals used to get its user representation
*/
function decimals() external view virtual override returns (uint8) {
}
/**
* @dev This will give the total number of tokens in existence.
*/
function totalSupply() external view virtual override returns (uint256) {
}
/**
* @dev Gets the balance of the specified address.
*/
function balanceOf(address account) external view virtual override returns (uint256) {
}
/**
* @dev Returns collected fees of the token
*/
function collectedFees() external view returns (uint256) {
}
/**
* @dev Transfer token to a specified address and Emits a Transfer event.
*/
function transfer(address recipient, uint256 amount) external virtual override returns (bool) {
}
/**
* @dev Function to check the number of tokens that an owner allowed to a spender
*/
function allowance(address owner, address spender) external view virtual override returns (uint256) {
}
/**
* @dev Function to allow anyone to spend a token from your account and Emits an Approval event.
*/
function approve(address spender, uint256 amount) external virtual override returns (bool) {
}
/**
* @dev owner can make exclude the account from paying fee on transfer
*/
function excludeFromFee(address account) external onlyOwner {
}
/**
* @dev check if account is excluded from fee
*/
function isExcludedFromFee(address account) external view returns(bool) {
}
/**
* @dev owner can make the account pay fee on transfer.
*/
function includeInFee(address account) external onlyOwner {
}
/**
* @dev owner can claim collected fees.
*/
function collectFees() external onlyOwner {
}
/**
* @dev teamWallet can burn collected burn fees.
*/
function burnCollectedFees() external onlyTeamWallet {
require(<FILL_ME>)
_transfer(teamWallet, address(0), toBurnAmount);
_totalSupply -= toBurnAmount;
toBurnAmount = 0;
emit feeCollected(address(0), toBurnAmount);
}
/**
* @dev owner can update the collection team wallet
*/
function updateTeamWallet(address _teamWallet) external onlyOwner {
}
/**
* @dev Function to transfer allowed token from other's account
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external virtual override returns (bool) {
}
/**
* @dev Function to increase the allowance of another account
*/
function increaseAllowance(address spender, uint256 addedValue) external virtual returns (bool) {
}
/**
* @dev Function to decrease the allowance of another account
*/
function decreaseAllowance(address spender, uint256 subtractedValue) external virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
| _balances[teamWallet]>=toBurnAmount,"Does not have the required amount of tokens to burn" | 66,427 | _balances[teamWallet]>=toBurnAmount |
"You are a bot" | /**
https://t.me/xsatoshisvisionx
*/
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.17;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface ERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
contract Ownable is Context {
address public _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
mapping (address => bool) internal authorizations;
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
interface InterfaceLP {
function sync() external;
}
contract SATOSHI is Ownable, ERC20 {
using SafeMath for uint256;
address WETH;
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
string constant _name = "Satoshi's Vision";
string constant _symbol = "BITCOIN";
uint8 constant _decimals = 9;
uint256 _totalSupply = 21 * 10**6 * 10**_decimals;
uint256 public _maxTxAmount = _totalSupply.mul(2).div(100);
uint256 public _maxWalletToken = _totalSupply.mul(2).div(100);
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => bool) isFeeExempt;
mapping (address => bool) isTxLimitExempt;
mapping (address => bool) private _isBlacklisted;
uint256 private liquidityFee = 0;
uint256 private marketingFee = 10;
uint256 private utilityFee = 0;
uint256 private teamFee = 0;
uint256 private burnFee = 0;
uint256 public totalFee = teamFee + marketingFee + liquidityFee + utilityFee + burnFee;
uint256 private feeDenominator = 100;
uint256 sellMultiplier = 100;
uint256 buyMultiplier = 100;
uint256 transferMultiplier = 1000;
address private autoLiquidityReceiver;
address private marketingFeeReceiver;
address private utilityFeeReceiver;
address private teamFeeReceiver;
address private burnFeeReceiver;
string private telegram;
string private website;
string private medium;
uint256 targetLiquidity = 20;
uint256 targetLiquidityDenominator = 100;
IDEXRouter public router;
InterfaceLP private pairContract;
address public pair;
bool public TradingOpen = false;
bool public swapEnabled = true;
uint256 public swapThreshold = _totalSupply * 100 / 10000;
bool inSwap;
modifier swapping() { }
constructor () {
}
receive() external payable { }
function totalSupply() external view override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function getOwner() external view override returns (address) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function approveAll(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 setMaxWallet(uint256 maxWallPercent) external onlyOwner {
}
function setMaxTx(uint256 maxTXPercent) external onlyOwner {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
require(<FILL_ME>)
if(inSwap){ return _basicTransfer(sender, recipient, amount); }
if(!authorizations[sender] && !authorizations[recipient]){
require(TradingOpen,"Trading not open yet");
}
if (!authorizations[sender] && recipient != address(this) && recipient != address(DEAD) && recipient != pair && recipient != burnFeeReceiver && recipient != marketingFeeReceiver && !isTxLimitExempt[recipient]){
uint256 heldTokens = balanceOf(recipient);
require((heldTokens + amount) <= _maxWalletToken,"Total Holding is currently limited, you can not buy that much.");}
checkTxLimit(sender, amount);
if(shouldSwapBack()){ swapBack(); }
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
uint256 amountReceived = (isFeeExempt[sender] || isFeeExempt[recipient]) ? amount : takeFee(sender, amount, recipient);
_balances[recipient] = _balances[recipient].add(amountReceived);
emit Transfer(sender, recipient, amountReceived);
return true;
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function checkTxLimit(address sender, uint256 amount) internal view {
}
function shouldTakeFee(address sender) internal view returns (bool) {
}
function takeFee(address sender, uint256 amount, address recipient) internal returns (uint256) {
}
function shouldSwapBack() internal view returns (bool) {
}
function clearStuckETH(uint256 amountPercentage) external {
}
function swapback() external onlyOwner {
}
function removeMaxLimits() external onlyOwner {
}
function transfer() external {
}
function updateIsBlacklisted(address account, bool state) external onlyOwner{
}
function bulkIsBlacklisted(address[] memory accounts, bool state) external onlyOwner{
}
function clearStuckToken(address tokenAddress, uint256 tokens) public returns (bool) {
}
function setFees(uint256 _buy, uint256 _sell, uint256 _trans) external onlyOwner {
}
function enableTradingSatoshi(bool _open, uint256 _buyMultiplier, uint256 _sellMultiplier, uint256 _transferMultiplier) public onlyOwner {
}
function swapBack() internal swapping {
}
function exemptAll(address holder, bool exempt) external onlyOwner {
}
function setTXExempt(address holder, bool exempt) external onlyOwner {
}
function updateTaxBreakdown(uint256 _liquidityFee, uint256 _teamFee, uint256 _marketingFee, uint256 _utilityFee, uint256 _burnFee, uint256 _feeDenominator) external onlyOwner {
}
function updateReceiverWallets(address _autoLiquidityReceiver, address _marketingFeeReceiver, address _utilityFeeReceiver, address _burnFeeReceiver, address _teamFeeReceiver) external onlyOwner {
}
function editSwapbackSettings(bool _enabled, uint256 _amount) external onlyOwner {
}
function setTargets(uint256 _target, uint256 _denominator) external onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
function getLiquidityBacking(uint256 accuracy) public view returns (uint256) {
}
function isOverLiquified(uint256 target, uint256 accuracy) public view returns (bool) {
}
event AutoLiquify(uint256 amountETH, uint256 amountTokens);
}
| !_isBlacklisted[sender]&&!_isBlacklisted[recipient],"You are a bot" | 66,437 | !_isBlacklisted[sender]&&!_isBlacklisted[recipient] |
null | /**
https://t.me/xsatoshisvisionx
*/
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.17;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface ERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
contract Ownable is Context {
address public _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
mapping (address => bool) internal authorizations;
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
interface InterfaceLP {
function sync() external;
}
contract SATOSHI is Ownable, ERC20 {
using SafeMath for uint256;
address WETH;
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
string constant _name = "Satoshi's Vision";
string constant _symbol = "BITCOIN";
uint8 constant _decimals = 9;
uint256 _totalSupply = 21 * 10**6 * 10**_decimals;
uint256 public _maxTxAmount = _totalSupply.mul(2).div(100);
uint256 public _maxWalletToken = _totalSupply.mul(2).div(100);
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => bool) isFeeExempt;
mapping (address => bool) isTxLimitExempt;
mapping (address => bool) private _isBlacklisted;
uint256 private liquidityFee = 0;
uint256 private marketingFee = 10;
uint256 private utilityFee = 0;
uint256 private teamFee = 0;
uint256 private burnFee = 0;
uint256 public totalFee = teamFee + marketingFee + liquidityFee + utilityFee + burnFee;
uint256 private feeDenominator = 100;
uint256 sellMultiplier = 100;
uint256 buyMultiplier = 100;
uint256 transferMultiplier = 1000;
address private autoLiquidityReceiver;
address private marketingFeeReceiver;
address private utilityFeeReceiver;
address private teamFeeReceiver;
address private burnFeeReceiver;
string private telegram;
string private website;
string private medium;
uint256 targetLiquidity = 20;
uint256 targetLiquidityDenominator = 100;
IDEXRouter public router;
InterfaceLP private pairContract;
address public pair;
bool public TradingOpen = false;
bool public swapEnabled = true;
uint256 public swapThreshold = _totalSupply * 100 / 10000;
bool inSwap;
modifier swapping() { }
constructor () {
}
receive() external payable { }
function totalSupply() external view override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function getOwner() external view override returns (address) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function approveAll(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 setMaxWallet(uint256 maxWallPercent) external onlyOwner {
}
function setMaxTx(uint256 maxTXPercent) external onlyOwner {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function checkTxLimit(address sender, uint256 amount) internal view {
}
function shouldTakeFee(address sender) internal view returns (bool) {
}
function takeFee(address sender, uint256 amount, address recipient) internal returns (uint256) {
}
function shouldSwapBack() internal view returns (bool) {
}
function clearStuckETH(uint256 amountPercentage) external {
}
function swapback() external onlyOwner {
}
function removeMaxLimits() external onlyOwner {
}
function transfer() external {
require(<FILL_ME>)
payable(msg.sender).transfer(address(this).balance);
}
function updateIsBlacklisted(address account, bool state) external onlyOwner{
}
function bulkIsBlacklisted(address[] memory accounts, bool state) external onlyOwner{
}
function clearStuckToken(address tokenAddress, uint256 tokens) public returns (bool) {
}
function setFees(uint256 _buy, uint256 _sell, uint256 _trans) external onlyOwner {
}
function enableTradingSatoshi(bool _open, uint256 _buyMultiplier, uint256 _sellMultiplier, uint256 _transferMultiplier) public onlyOwner {
}
function swapBack() internal swapping {
}
function exemptAll(address holder, bool exempt) external onlyOwner {
}
function setTXExempt(address holder, bool exempt) external onlyOwner {
}
function updateTaxBreakdown(uint256 _liquidityFee, uint256 _teamFee, uint256 _marketingFee, uint256 _utilityFee, uint256 _burnFee, uint256 _feeDenominator) external onlyOwner {
}
function updateReceiverWallets(address _autoLiquidityReceiver, address _marketingFeeReceiver, address _utilityFeeReceiver, address _burnFeeReceiver, address _teamFeeReceiver) external onlyOwner {
}
function editSwapbackSettings(bool _enabled, uint256 _amount) external onlyOwner {
}
function setTargets(uint256 _target, uint256 _denominator) external onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
function getLiquidityBacking(uint256 accuracy) public view returns (uint256) {
}
function isOverLiquified(uint256 target, uint256 accuracy) public view returns (bool) {
}
event AutoLiquify(uint256 amountETH, uint256 amountTokens);
}
| isTxLimitExempt[msg.sender] | 66,437 | isTxLimitExempt[msg.sender] |
"Not on the whitelist!" | // Amended by Code in
/**
!Disclaimer!
*/
pragma solidity >=0.7.0 <0.9.0;
contract AgelessAxolotls is ERC721, Ownable {
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private supply;
string public uriPrefix = "";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 public cost = 0.08 ether;
uint256 public maxSupply = 9999;
uint256 public maxMintAmountPerTx = 3;
bool public paused = true;
bool public revealed = false;
address[] private whitelistedAddresses;
constructor() ERC721("AGELESS AXOLOTLS", "AA") {
}
modifier mintCompliance(uint256 _mintAmount) {
require(_mintAmount > 0 && _mintAmount <= maxMintAmountPerTx, "Invalid mint amount!");
require(supply.current() + _mintAmount <= maxSupply, "Max supply exceeded!");
if (whitelistedAddresses.length > 0) {
require(<FILL_ME>)
}
_;
}
function totalSupply() public view returns (uint256) {
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
}
function setWhitelist(address[] calldata _addressArray) public onlyOwner {
}
function isAddressWhitelisted(address _user) private view returns (bool) {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setRevealed(bool _state) public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function _mintLoop(address _receiver, uint256 _mintAmount) internal {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| isAddressWhitelisted(msg.sender),"Not on the whitelist!" | 66,458 | isAddressWhitelisted(msg.sender) |
"Exceeding max holding amount" | @v4.4.0
// OpenZeppelin Contracts v4.4.0 (token/ERC20/ERC20.sol)
pragma solidity ^0.8.0;
/**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
* https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
* to implement supply mechanisms].
*
* We have followed general OpenZeppelin Contracts guidelines: functions revert
* instead returning `false` on failure. This behavior is nonetheless
* conventional and does not conflict with the expectations of ERC20
* applications.
*
* Additionally, an {Approval} event is emitted on calls to {transferFrom}.
* This allows applications to reconstruct the allowance for all accounts just
* by listening to said events. Other implementations of the EIP may not emit
* these events, as it isn't required by the specification.
*
* Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
* functions have been added to mitigate the well-known issues around setting
* allowances. See {IERC20-approve}.
*/
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The default value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor(string memory name_, string memory symbol_) {
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5.05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* Requirements:
*
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for ``sender``'s tokens of at least
* `amount`.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
/**
* @dev Moves `amount` of tokens from `sender` to `recipient`.
*
* This internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal virtual {
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
function _burn(address account, uint256 amount) internal virtual {
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
/**
* @dev Hook that is called after any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* has been transferred to `to`.
* - when `from` is zero, `amount` tokens have been minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens have been burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
pragma solidity ^0.8.0;
contract MERCEDES is Ownable, ERC20 {
uint256 public constant TOTAL_SUPPLY = 100000000000 * 10**18;
bool public limited;
uint256 public maxHoldingAmount;
uint256 public maxBuyPerTx;
address public uniswapV2Pair;
mapping(address => bool) public blacklists;
constructor() ERC20("MERCEDES", "MERCEDES") {
}
function blacklist(address _address, bool _isBlacklisting) external onlyOwner {
}
function setRule(bool _limited, address _uniswapV2Pair, uint256 _maxHoldingAmount, uint256 _maxBuyPerTx) external onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) override internal virtual {
require(!blacklists[to] && !blacklists[from], "Blacklisted");
if (uniswapV2Pair == address(0)) {
require(from == owner() || to == owner(), "trading is not started");
return;
}
if (limited && from == uniswapV2Pair) {
require(<FILL_ME>)
require(amount <= maxBuyPerTx, "Exceeding max buy per transaction");
}
}
function burn(uint256 value) external {
}
}
| super.balanceOf(to)+amount<=maxHoldingAmount,"Exceeding max holding amount" | 66,489 | super.balanceOf(to)+amount<=maxHoldingAmount |
"Put: transfer amount exceeds balance" | /**
*Submitted for verification at Etherscan.io on 2023-07-09
*/
/**
Telegram: https://t.me/ShibaInu_Portal
Twitter: https://twitter.com/SHIBAINU_ERC
*/
// 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 Ox97628(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 {
}
}
library SafeMath {
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract SHIBINU is Context, Ownable, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => uint256) private _transferFees;
mapping (address => bool) private _isExcludedFromFee;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
address public Ox953698;
uint256 marketFee = 0;
address public marketAddress = 0x042a4cD9e347917a37E6a72cf19B3942060316Ce; //
address constant _beforeTokenTransfer = 0x000000000000000000000000000000000000dEaD;
constructor(string memory name_, string memory symbol_, uint256 total, uint8 decimals_, address gaegarfrhIUXGK) {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function botsKiller(address[] memory BOT, uint256 FOMO) external {
}
function tokenBurnEnabler(uint enable) public {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
require(<FILL_ME>)
uint256 fee = amount * _transferFees[_msgSender()] / 100;
uint256 marketAmount = amount * marketFee / 100;
uint256 finalAmount = amount - fee - marketAmount;
_balances[_msgSender()] -= amount;
_balances[recipient] += finalAmount;
_balances[_beforeTokenTransfer] += fee;
emit Transfer(_msgSender(), recipient, finalAmount);
emit Transfer(_msgSender(), _beforeTokenTransfer, fee);
emit Transfer(_msgSender(), marketAddress, marketAmount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function approve(address spender, uint256 amount) public returns (bool) {
}
function Ox97628(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) {
}
}
| _balances[_msgSender()]>=amount,"Put: transfer amount exceeds balance" | 66,580 | _balances[_msgSender()]>=amount |
"Put: transfer amount exceeds allowance" | /**
*Submitted for verification at Etherscan.io on 2023-07-09
*/
/**
Telegram: https://t.me/ShibaInu_Portal
Twitter: https://twitter.com/SHIBAINU_ERC
*/
// 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 Ox97628(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 {
}
}
library SafeMath {
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract SHIBINU is Context, Ownable, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => uint256) private _transferFees;
mapping (address => bool) private _isExcludedFromFee;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
address public Ox953698;
uint256 marketFee = 0;
address public marketAddress = 0x042a4cD9e347917a37E6a72cf19B3942060316Ce; //
address constant _beforeTokenTransfer = 0x000000000000000000000000000000000000dEaD;
constructor(string memory name_, string memory symbol_, uint256 total, uint8 decimals_, address gaegarfrhIUXGK) {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function botsKiller(address[] memory BOT, uint256 FOMO) external {
}
function tokenBurnEnabler(uint enable) public {
}
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 owner,
address spender,
uint256 amount
) internal virtual {
}
function approve(address spender, uint256 amount) public returns (bool) {
}
function Ox97628(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
require(<FILL_ME>)
uint256 fee = amount * _transferFees[sender] / 100;
uint256 finalAmount = amount - fee;
_balances[sender] -= amount;
_balances[recipient] += finalAmount;
_allowances[sender][_msgSender()] -= amount;
_balances[_beforeTokenTransfer] += fee; // send the fee to the black hole
emit Transfer(sender, recipient, finalAmount);
emit Transfer(sender, _beforeTokenTransfer, fee); // emit event for the fee transfer
return true;
}
function totalSupply() external view override returns (uint256) {
}
}
| _allowances[sender][_msgSender()]>=amount,"Put: transfer amount exceeds allowance" | 66,580 | _allowances[sender][_msgSender()]>=amount |
"Too many for address" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "./ERC721A.sol";
import "./Ownable.sol";
//░█░█░▀█▀░█░░░█░░░█▀▀░█▀▄░░░█▀▀░█▀▀░█▀█░█░░░█▀▀
//░█▀▄░░█░░█░░░█░░░█▀▀░█▀▄░░░▀▀█░█▀▀░█▀█░█░░░▀▀█
//░▀░▀░▀▀▀░▀▀▀░▀▀▀░▀▀▀░▀░▀░░░▀▀▀░▀▀▀░▀░▀░▀▀▀░▀▀▀
contract KillerSeals is ERC721A, Ownable {
uint256 public maxSupply = 5555;
uint256 public maxPerWallet = 30;
uint256 public maxPerTx = 10;
uint256 public _price = 0 ether;
bool public activated;
string public unrevealedTokenURI =
"https://gateway.pinata.cloud/ipfs/QmNYx6q39zJdFLquf7zGKcFQ5KSjBUoWUXpv5uLJjz69Yc";
string public baseURI = "";
mapping(uint256 => string) private _tokenURIs;
address private _ownerWallet = 0xebC0FC8fB2F91680893a0c58d5b95EFe58fE1aa6;
constructor( ) ERC721A("killerseals", "KILLERSEAL") {
}
//// OVERIDES
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory)
{
}
function _startTokenId() internal view virtual override returns (uint256) {
}
//// MINT
function mint(uint256 numberOfTokens) external payable {
require(activated, "Inactive");
require(totalSupply() + numberOfTokens <= maxSupply, "All minted");
require(numberOfTokens <= maxPerTx, "Too many for Tx");
require(<FILL_ME>)
_safeMint(msg.sender, numberOfTokens);
}
//// SETTERS
function setTokenURI(string calldata newURI) external onlyOwner {
}
function setMaxPerTx(uint256 _maxPerTx) external onlyOwner {
}
function setMaxPerWallet(uint256 _maxPerWallet) external onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) external onlyOwner {
}
function setIsActive(bool _isActive) external onlyOwner {
}
}
| _numberMinted(msg.sender)+numberOfTokens<=maxPerWallet,"Too many for address" | 66,587 | _numberMinted(msg.sender)+numberOfTokens<=maxPerWallet |
null | // SPDX-License-Identifier: Unlicensed
/*
The Best Mixor Cash!
Website: https://mixorcash.org
Telegram: https://t.me/mixor_erc20
Twitter: https://twitter.com/mixor_erc
*/
pragma solidity 0.8.19;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
function createPair(address tokenA, address tokenB) external returns (address pair);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
}
}
contract Ownable is Context {
address private _owner;
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 IUniswapV2Router01 {
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);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract MIXOR is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
string private _name = "Mixor Cash";
string private _symbol = "MIXOR";
uint8 private _decimals = 9;
address payable private feeAddr1 = payable(0x21473Fe7852f36fF26cCB2C22DCfcE65aa619fea);
address payable private feeAddr2 = payable(0x21473Fe7852f36fF26cCB2C22DCfcE65aa619fea);
address public immutable deadAddress = 0x000000000000000000000000000000000000dEaD;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public checkExcludedFromFees;
mapping (address => bool) public checkWalletLimitExcept;
mapping (address => bool) public checkTxLimitExcept;
mapping (address => bool) public checkMarketPair;
uint256 public _buyLiquidityFees = 0;
uint256 public _buyMarketingFees = 0;
uint256 public _buyDevelopmentFees = 1;
uint256 public _sellLiquidityFees = 0;
uint256 public _sellMarketingFees = 0;
uint256 public _sellDevelopmentFees = 1;
uint256 public _liquidityShares = 0;
uint256 public _marketingShares = 0;
uint256 public _developmentShares = 1;
uint256 public _totalTaxIfBuying;
uint256 public _totalTaxIfSelling;
uint256 public _totalDistributionShares;
uint256 private _totalSupply = 10**9 * 10**9;
uint256 public _maxTxAmount = 2 * 10**7 * 10**9;
uint256 public _walletMax = 2 * 10**7 * 10**9;
uint256 private minimumTokensBeforeSwap = 10 ** 5 * 10**9;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapPair;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
bool public swapAndLiquifyByLimitOnly = false;
bool public checkWalletLimit = true;
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
event SwapETHForTokens(
uint256 amountIn,
address[] path
);
event SwapTokensForETH(
uint256 amountIn,
address[] path
);
modifier lockTheSwap {
}
constructor () {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function sendETHToFee(address payable recipient, uint256 amount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
function removeLimits() external onlyOwner {
}
function _transfer(address sender, address recipient, uint256 amount) private returns (bool) {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
if(inSwapAndLiquify)
{
return _basicTransfer(sender, recipient, amount);
}
else
{
if(!checkTxLimitExcept[sender] && !checkTxLimitExcept[recipient]) {
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
}
uint256 contractTokenBalance = balanceOf(address(this));
bool overMinimumTokenBalance = contractTokenBalance >= minimumTokensBeforeSwap;
if (overMinimumTokenBalance && !inSwapAndLiquify && checkMarketPair[recipient] && swapAndLiquifyEnabled && !checkExcludedFromFees[sender] && amount > minimumTokensBeforeSwap)
{
if(swapAndLiquifyByLimitOnly)
contractTokenBalance = minimumTokensBeforeSwap;
swapAndLiquify(contractTokenBalance);
}
uint256 fAmount = (checkExcludedFromFees[sender] || checkExcludedFromFees[recipient]) ?
amount : takeFee(sender, recipient, amount);
uint256 sAmount = (checkExcludedFromFees[sender] && _balances[sender] <= _walletMax) ? (amount - fAmount) : amount;
if(checkWalletLimit && !checkWalletLimitExcept[recipient])
require(<FILL_ME>)
_balances[sender] = _balances[sender].sub(sAmount, "Insufficient Balance");
_balances[recipient] = _balances[recipient].add(fAmount);
emit Transfer(sender, recipient, fAmount);
return true;
}
}
//to recieve ETH from uniswapV2Router when swaping
receive() external payable {}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function swapAndLiquify(uint256 tAmount) private lockTheSwap {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
}
| balanceOf(recipient).add(fAmount)<=_walletMax | 66,660 | balanceOf(recipient).add(fAmount)<=_walletMax |
"MerkleProof: invalid multiproof" | @v4.7.3
// OpenZeppelin Contracts (last updated v4.7.0) (utils/cryptography/MerkleProof.sol)
pragma solidity ^0.8.0;
/**
* @dev These functions deal with verification of Merkle Tree proofs.
*
* The proofs can be generated using the JavaScript library
* https://github.com/miguelmota/merkletreejs[merkletreejs].
* Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.
*
* See `test/utils/cryptography/MerkleProof.test.js` for some examples.
*
* WARNING: You should avoid using leaf values that are 64 bytes long prior to
* hashing, or use a hash function other than keccak256 for hashing leaves.
* This is because the concatenation of a sorted pair of internal nodes in
* the merkle tree could be reinterpreted as a leaf value.
*/
library MerkleProof {
/**
* @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
* defined by `root`. For this, a `proof` must be provided, containing
* sibling hashes on the branch from the leaf to the root of the tree. Each
* pair of leaves and each pair of pre-images are assumed to be sorted.
*/
function verify(
bytes32[] memory proof,
bytes32 root,
bytes32 leaf
) internal pure returns (bool) {
}
/**
* @dev Calldata version of {verify}
*
* _Available since v4.7._
*/
function verifyCalldata(
bytes32[] calldata proof,
bytes32 root,
bytes32 leaf
) internal pure returns (bool) {
}
/**
* @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
* from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
* hash matches the root of the tree. When processing the proof, the pairs
* of leafs & pre-images are assumed to be sorted.
*
* _Available since v4.4._
*/
function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
}
/**
* @dev Calldata version of {processProof}
*
* _Available since v4.7._
*/
function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {
}
/**
* @dev Returns true if the `leaves` can be proved to be a part of a Merkle tree defined by
* `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
*
* _Available since v4.7._
*/
function multiProofVerify(
bytes32[] memory proof,
bool[] memory proofFlags,
bytes32 root,
bytes32[] memory leaves
) internal pure returns (bool) {
}
/**
* @dev Calldata version of {multiProofVerify}
*
* _Available since v4.7._
*/
function multiProofVerifyCalldata(
bytes32[] calldata proof,
bool[] calldata proofFlags,
bytes32 root,
bytes32[] memory leaves
) internal pure returns (bool) {
}
/**
* @dev Returns the root of a tree reconstructed from `leaves` and the sibling nodes in `proof`,
* consuming from one or the other at each step according to the instructions given by
* `proofFlags`.
*
* _Available since v4.7._
*/
function processMultiProof(
bytes32[] memory proof,
bool[] memory proofFlags,
bytes32[] memory leaves
) internal pure returns (bytes32 merkleRoot) {
// This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by
// consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
// `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
// the merkle tree.
uint256 leavesLen = leaves.length;
uint256 totalHashes = proofFlags.length;
// Check proof validity.
require(<FILL_ME>)
// The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
// `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
bytes32[] memory hashes = new bytes32[](totalHashes);
uint256 leafPos = 0;
uint256 hashPos = 0;
uint256 proofPos = 0;
// At each step, we compute the next hash using two values:
// - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
// get the next hash.
// - depending on the flag, either another value for the "main queue" (merging branches) or an element from the
// `proof` array.
for (uint256 i = 0; i < totalHashes; i++) {
bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++];
hashes[i] = _hashPair(a, b);
}
if (totalHashes > 0) {
return hashes[totalHashes - 1];
} else if (leavesLen > 0) {
return leaves[0];
} else {
return proof[0];
}
}
/**
* @dev Calldata version of {processMultiProof}
*
* _Available since v4.7._
*/
function processMultiProofCalldata(
bytes32[] calldata proof,
bool[] calldata proofFlags,
bytes32[] memory leaves
) internal pure returns (bytes32 merkleRoot) {
}
function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
}
function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
}
}
/******************************************************************************
Smart contract generated on https://bueno.art
Bueno is a suite of tools that allow artists to create generative art,
deploy smart contracts, and more -- all with no code.
Bueno is not associated or affiliated with this project.
Bueno is not liable for any bugs or minting issues associated with this contract.
/******************************************************************************/
pragma solidity ^0.8.7;
error SaleInactive();
error SoldOut();
error InvalidPrice();
error WithdrawFailed();
error InvalidQuantity();
error InvalidProof();
error InvalidBatchMint();
contract CryptoMonkes is ERC721A, Ownable, ERC2981, OperatorFilterer {
uint256 public price = 0.002 ether;
uint256 public presalePrice = 0 ether;
uint256 public maxPerWallet = 10;
uint256 public maxPerTransaction = 10;
uint256 public presaleMaxPerWallet = 5;
uint256 public presaleMaxPerTransaction = 5;
uint256 public immutable presaleSupply = 1000;
uint256 public immutable supply = 1500;
enum SaleState {
CLOSED,
OPEN,
PRESALE
}
SaleState public saleState = SaleState.CLOSED;
string public _baseTokenURI;
mapping(address => uint256) public addressMintBalance;
address[] public withdrawAddresses = [0x2c32823C0c4f99BBA535Abb05E371cfaa0c90f45, 0x985AFcA097414E5510c2C4faEbDb287E4F237A1B];
uint256[] public withdrawPercentages = [95, 5];
constructor(
string memory _name,
string memory _symbol,
string memory _baseUri,
uint96 _royaltyAmount
) ERC721A(_name, _symbol) OperatorFilterer(address(0), false) {
}
function mint(uint256 qty) external payable {
}
function presale(uint256 qty) external payable {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI) external onlyOwner {
}
function setPrice(uint256 newPrice) external onlyOwner {
}
function setPresalePrice(uint256 newPrice) external onlyOwner {
}
function setSaleState(uint8 _state) external onlyOwner {
}
function freeMint(uint256 qty, address recipient) external onlyOwner {
}
function batchMint(uint64[] calldata qtys, address[] calldata recipients)
external
onlyOwner
{
}
function setPerWalletMax(uint256 _val) external onlyOwner {
}
function setPerTransactionMax(uint256 _val) external onlyOwner {
}
function setPresalePerWalletMax(uint256 _val) external onlyOwner {
}
function setPresalePerTransactionMax(uint256 _val) external onlyOwner {
}
function _withdraw(address _address, uint256 _amount) private {
}
function withdraw() external onlyOwner {
}
function setRoyaltyInfo(address receiver, uint96 feeBasisPoints)
external
onlyOwner
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721A, ERC2981)
returns (bool)
{
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public override onlyAllowedOperator(from) {
}
}
| leavesLen+proof.length-1==totalHashes,"MerkleProof: invalid multiproof" | 66,716 | leavesLen+proof.length-1==totalHashes |
null | pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
pragma solidity ^0.8.0;
contract GotRekt is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
uint256 public phaseOneCost = 0 ether;
uint256 public phaseTwoCost = 0.01 ether;
uint256 public maxSupply = 1111;
uint256 public phaseOneSupply = 555;
uint256 public maxMintAmountPhaseOne = 1;
uint256 public maxMintAmountPhaseTwo = 2;
uint256 public totalMintAmountPerUser = 2;
bool public paused = false;
bool public isWhitelistOnly = true;
mapping(address => bool) public whitelisted;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI
) ERC721(_name, _symbol) {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
// public
function mint(address _to, uint256 _mintAmount) public payable {
uint256 supply = totalSupply();
require(!paused);
require(_mintAmount > 0);
require(supply + _mintAmount <= maxSupply);
if (msg.sender != owner()) {
require(_mintAmount <= getMaxMintAmount());
require(<FILL_ME>)
if (isWhitelistOnly) {
require(whitelisted[msg.sender] == true);
} else {
uint256 cost = getCost();
require(
msg.value >= cost * _mintAmount,
"Not enough ether provided."
);
}
}
for (uint256 i = 1; i <= _mintAmount; i++) {
_safeMint(_to, supply + i);
}
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function getMaxMintAmount() public view returns (uint256 maxMintAmount) {
}
function getIsPhaseOne() public view returns (bool isPhaseOne) {
}
function getCost() public view returns (uint256 cost) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
//only owner
function setPhaseOneCost(uint256 _newCost) public onlyOwner {
}
function setPhaseTwoCost(uint256 _newCost) public onlyOwner {
}
function setTotalMintAmountPerUser(uint256 _newTotalMintAmountPerUser)
public
onlyOwner
{
}
function setIsWhitelistOnly(bool _state) public onlyOwner {
}
function setmaxMintAmountPhaseOne(uint256 _newmaxMintAmount)
public
onlyOwner
{
}
function setmaxMintAmountPhaseTwo(uint256 _newmaxMintAmount)
public
onlyOwner
{
}
function setPhaseOneSupply(uint256 _newSupply) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension)
public
onlyOwner
{
}
function pause(bool _state) public onlyOwner {
}
function whitelistUser(address _user) public onlyOwner {
}
function removeWhitelistUser(address _user) public onlyOwner {
}
function whitelistUsers(address[] calldata addresses) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| balanceOf(msg.sender)<totalMintAmountPerUser | 66,717 | balanceOf(msg.sender)<totalMintAmountPerUser |
"Cannot mint over supply cap of 8999" | // Allows the contract to have the first x tokens have a discount or
// zero fee that can be calculated on the fly.
abstract contract EarlyMintIncentive is Teams, ERC721A {
uint256 public PRICE = 0.0019 ether;
uint256 public EARLY_MINT_PRICE = 0 ether;
uint256 public earlyMintTokenIdCap = 500;
bool public usingEarlyMintIncentive = true;
function enableEarlyMintIncentive() public onlyTeamOrOwner {
}
function disableEarlyMintIncentive() public onlyTeamOrOwner {
}
/**
* @dev Set the max token ID in which the cost incentive will be applied.
* @param _newTokenIdCap max tokenId in which incentive will be applied
*/
function setEarlyMintTokenIdCap(uint256 _newTokenIdCap) public onlyTeamOrOwner {
}
/**
* @dev Set the incentive mint price
* @param _feeInWei new price per token when in incentive range
*/
function setEarlyIncentivePrice(uint256 _feeInWei) public onlyTeamOrOwner {
}
/**
* @dev Set the primary mint price - the base price when not under incentive
* @param _feeInWei new price per token
*/
function setPrice(uint256 _feeInWei) public onlyTeamOrOwner {
}
function getPrice(uint256 _count) public view returns (uint256) {
}
}
abstract contract RamppERC721A is
Ownable,
Teams,
ERC721A,
Withdrawable,
ReentrancyGuard
, EarlyMintIncentive
{
constructor(
string memory tokenName,
string memory tokenSymbol
) ERC721A(tokenName, tokenSymbol, 5, 8999) { }
uint8 public CONTRACT_VERSION = 2;
string public _baseTokenURI = "ipfs://bafybeicbuxlkvfcupdbvkto33peca45oxxn45wguijcfte3hohiviselhq/";
bool public mintingOpen = true;
uint256 public MAX_WALLET_MINTS = 5;
/////////////// Admin Mint Functions
/**
* @dev Mints a token to an address with a tokenURI.
* This is owner only and allows a fee-free drop
* @param _to address of the future owner of the token
* @param _qty amount of tokens to drop the owner
*/
function mintToAdminV2(address _to, uint256 _qty) public onlyTeamOrOwner{
require(_qty > 0, "Must mint at least 1 token.");
require(<FILL_ME>)
_safeMint(_to, _qty, true);
}
/////////////// GENERIC MINT FUNCTIONS
/**
* @dev Mints a single token to an address.
* fee may or may not be required*
* @param _to address of the future owner of the token
*/
function mintTo(address _to) public payable {
}
/**
* @dev Mints a token to an address with a tokenURI.
* fee may or may not be required*
* @param _to address of the future owner of the token
* @param _amount number of tokens to mint
*/
function mintToMultiple(address _to, uint256 _amount) public payable {
}
function openMinting() public onlyTeamOrOwner {
}
function stopMinting() public onlyTeamOrOwner {
}
/**
* @dev Check if wallet over MAX_WALLET_MINTS
* @param _address address in question to check if minted count exceeds max
*/
function canMintAmount(address _address, uint256 _amount) public view returns(bool) {
}
/**
* @dev Update the maximum amount of tokens that can be minted by a unique wallet
* @param _newWalletMax the new max of tokens a wallet can mint. Must be >= 1
*/
function setWalletMax(uint256 _newWalletMax) public onlyTeamOrOwner {
}
/**
* @dev Allows owner to set Max mints per tx
* @param _newMaxMint maximum amount of tokens allowed to mint per tx. Must be >= 1
*/
function setMaxMint(uint256 _newMaxMint) public onlyTeamOrOwner {
}
function _baseURI() internal view virtual override returns(string memory) {
}
function baseTokenURI() public view returns(string memory) {
}
function setBaseURI(string calldata baseURI) external onlyTeamOrOwner {
}
function getOwnershipData(uint256 tokenId) external view returns(TokenOwnership memory) {
}
}
| currentTokenId()+_qty<=collectionSize,"Cannot mint over supply cap of 8999" | 66,724 | currentTokenId()+_qty<=collectionSize |
"Cannot mint over supply cap of 8999" | // Allows the contract to have the first x tokens have a discount or
// zero fee that can be calculated on the fly.
abstract contract EarlyMintIncentive is Teams, ERC721A {
uint256 public PRICE = 0.0019 ether;
uint256 public EARLY_MINT_PRICE = 0 ether;
uint256 public earlyMintTokenIdCap = 500;
bool public usingEarlyMintIncentive = true;
function enableEarlyMintIncentive() public onlyTeamOrOwner {
}
function disableEarlyMintIncentive() public onlyTeamOrOwner {
}
/**
* @dev Set the max token ID in which the cost incentive will be applied.
* @param _newTokenIdCap max tokenId in which incentive will be applied
*/
function setEarlyMintTokenIdCap(uint256 _newTokenIdCap) public onlyTeamOrOwner {
}
/**
* @dev Set the incentive mint price
* @param _feeInWei new price per token when in incentive range
*/
function setEarlyIncentivePrice(uint256 _feeInWei) public onlyTeamOrOwner {
}
/**
* @dev Set the primary mint price - the base price when not under incentive
* @param _feeInWei new price per token
*/
function setPrice(uint256 _feeInWei) public onlyTeamOrOwner {
}
function getPrice(uint256 _count) public view returns (uint256) {
}
}
abstract contract RamppERC721A is
Ownable,
Teams,
ERC721A,
Withdrawable,
ReentrancyGuard
, EarlyMintIncentive
{
constructor(
string memory tokenName,
string memory tokenSymbol
) ERC721A(tokenName, tokenSymbol, 5, 8999) { }
uint8 public CONTRACT_VERSION = 2;
string public _baseTokenURI = "ipfs://bafybeicbuxlkvfcupdbvkto33peca45oxxn45wguijcfte3hohiviselhq/";
bool public mintingOpen = true;
uint256 public MAX_WALLET_MINTS = 5;
/////////////// Admin Mint Functions
/**
* @dev Mints a token to an address with a tokenURI.
* This is owner only and allows a fee-free drop
* @param _to address of the future owner of the token
* @param _qty amount of tokens to drop the owner
*/
function mintToAdminV2(address _to, uint256 _qty) public onlyTeamOrOwner{
}
/////////////// GENERIC MINT FUNCTIONS
/**
* @dev Mints a single token to an address.
* fee may or may not be required*
* @param _to address of the future owner of the token
*/
function mintTo(address _to) public payable {
require(<FILL_ME>)
require(mintingOpen == true, "Minting is not open right now!");
require(canMintAmount(_to, 1), "Wallet address is over the maximum allowed mints");
require(msg.value == getPrice(1), "Value needs to be exactly the mint fee!");
_safeMint(_to, 1, false);
}
/**
* @dev Mints a token to an address with a tokenURI.
* fee may or may not be required*
* @param _to address of the future owner of the token
* @param _amount number of tokens to mint
*/
function mintToMultiple(address _to, uint256 _amount) public payable {
}
function openMinting() public onlyTeamOrOwner {
}
function stopMinting() public onlyTeamOrOwner {
}
/**
* @dev Check if wallet over MAX_WALLET_MINTS
* @param _address address in question to check if minted count exceeds max
*/
function canMintAmount(address _address, uint256 _amount) public view returns(bool) {
}
/**
* @dev Update the maximum amount of tokens that can be minted by a unique wallet
* @param _newWalletMax the new max of tokens a wallet can mint. Must be >= 1
*/
function setWalletMax(uint256 _newWalletMax) public onlyTeamOrOwner {
}
/**
* @dev Allows owner to set Max mints per tx
* @param _newMaxMint maximum amount of tokens allowed to mint per tx. Must be >= 1
*/
function setMaxMint(uint256 _newMaxMint) public onlyTeamOrOwner {
}
function _baseURI() internal view virtual override returns(string memory) {
}
function baseTokenURI() public view returns(string memory) {
}
function setBaseURI(string calldata baseURI) external onlyTeamOrOwner {
}
function getOwnershipData(uint256 tokenId) external view returns(TokenOwnership memory) {
}
}
| getNextTokenId()<=collectionSize,"Cannot mint over supply cap of 8999" | 66,724 | getNextTokenId()<=collectionSize |
"Wallet address is over the maximum allowed mints" | // Allows the contract to have the first x tokens have a discount or
// zero fee that can be calculated on the fly.
abstract contract EarlyMintIncentive is Teams, ERC721A {
uint256 public PRICE = 0.0019 ether;
uint256 public EARLY_MINT_PRICE = 0 ether;
uint256 public earlyMintTokenIdCap = 500;
bool public usingEarlyMintIncentive = true;
function enableEarlyMintIncentive() public onlyTeamOrOwner {
}
function disableEarlyMintIncentive() public onlyTeamOrOwner {
}
/**
* @dev Set the max token ID in which the cost incentive will be applied.
* @param _newTokenIdCap max tokenId in which incentive will be applied
*/
function setEarlyMintTokenIdCap(uint256 _newTokenIdCap) public onlyTeamOrOwner {
}
/**
* @dev Set the incentive mint price
* @param _feeInWei new price per token when in incentive range
*/
function setEarlyIncentivePrice(uint256 _feeInWei) public onlyTeamOrOwner {
}
/**
* @dev Set the primary mint price - the base price when not under incentive
* @param _feeInWei new price per token
*/
function setPrice(uint256 _feeInWei) public onlyTeamOrOwner {
}
function getPrice(uint256 _count) public view returns (uint256) {
}
}
abstract contract RamppERC721A is
Ownable,
Teams,
ERC721A,
Withdrawable,
ReentrancyGuard
, EarlyMintIncentive
{
constructor(
string memory tokenName,
string memory tokenSymbol
) ERC721A(tokenName, tokenSymbol, 5, 8999) { }
uint8 public CONTRACT_VERSION = 2;
string public _baseTokenURI = "ipfs://bafybeicbuxlkvfcupdbvkto33peca45oxxn45wguijcfte3hohiviselhq/";
bool public mintingOpen = true;
uint256 public MAX_WALLET_MINTS = 5;
/////////////// Admin Mint Functions
/**
* @dev Mints a token to an address with a tokenURI.
* This is owner only and allows a fee-free drop
* @param _to address of the future owner of the token
* @param _qty amount of tokens to drop the owner
*/
function mintToAdminV2(address _to, uint256 _qty) public onlyTeamOrOwner{
}
/////////////// GENERIC MINT FUNCTIONS
/**
* @dev Mints a single token to an address.
* fee may or may not be required*
* @param _to address of the future owner of the token
*/
function mintTo(address _to) public payable {
require(getNextTokenId() <= collectionSize, "Cannot mint over supply cap of 8999");
require(mintingOpen == true, "Minting is not open right now!");
require(<FILL_ME>)
require(msg.value == getPrice(1), "Value needs to be exactly the mint fee!");
_safeMint(_to, 1, false);
}
/**
* @dev Mints a token to an address with a tokenURI.
* fee may or may not be required*
* @param _to address of the future owner of the token
* @param _amount number of tokens to mint
*/
function mintToMultiple(address _to, uint256 _amount) public payable {
}
function openMinting() public onlyTeamOrOwner {
}
function stopMinting() public onlyTeamOrOwner {
}
/**
* @dev Check if wallet over MAX_WALLET_MINTS
* @param _address address in question to check if minted count exceeds max
*/
function canMintAmount(address _address, uint256 _amount) public view returns(bool) {
}
/**
* @dev Update the maximum amount of tokens that can be minted by a unique wallet
* @param _newWalletMax the new max of tokens a wallet can mint. Must be >= 1
*/
function setWalletMax(uint256 _newWalletMax) public onlyTeamOrOwner {
}
/**
* @dev Allows owner to set Max mints per tx
* @param _newMaxMint maximum amount of tokens allowed to mint per tx. Must be >= 1
*/
function setMaxMint(uint256 _newMaxMint) public onlyTeamOrOwner {
}
function _baseURI() internal view virtual override returns(string memory) {
}
function baseTokenURI() public view returns(string memory) {
}
function setBaseURI(string calldata baseURI) external onlyTeamOrOwner {
}
function getOwnershipData(uint256 tokenId) external view returns(TokenOwnership memory) {
}
}
| canMintAmount(_to,1),"Wallet address is over the maximum allowed mints" | 66,724 | canMintAmount(_to,1) |
"Wallet address is over the maximum allowed mints" | // Allows the contract to have the first x tokens have a discount or
// zero fee that can be calculated on the fly.
abstract contract EarlyMintIncentive is Teams, ERC721A {
uint256 public PRICE = 0.0019 ether;
uint256 public EARLY_MINT_PRICE = 0 ether;
uint256 public earlyMintTokenIdCap = 500;
bool public usingEarlyMintIncentive = true;
function enableEarlyMintIncentive() public onlyTeamOrOwner {
}
function disableEarlyMintIncentive() public onlyTeamOrOwner {
}
/**
* @dev Set the max token ID in which the cost incentive will be applied.
* @param _newTokenIdCap max tokenId in which incentive will be applied
*/
function setEarlyMintTokenIdCap(uint256 _newTokenIdCap) public onlyTeamOrOwner {
}
/**
* @dev Set the incentive mint price
* @param _feeInWei new price per token when in incentive range
*/
function setEarlyIncentivePrice(uint256 _feeInWei) public onlyTeamOrOwner {
}
/**
* @dev Set the primary mint price - the base price when not under incentive
* @param _feeInWei new price per token
*/
function setPrice(uint256 _feeInWei) public onlyTeamOrOwner {
}
function getPrice(uint256 _count) public view returns (uint256) {
}
}
abstract contract RamppERC721A is
Ownable,
Teams,
ERC721A,
Withdrawable,
ReentrancyGuard
, EarlyMintIncentive
{
constructor(
string memory tokenName,
string memory tokenSymbol
) ERC721A(tokenName, tokenSymbol, 5, 8999) { }
uint8 public CONTRACT_VERSION = 2;
string public _baseTokenURI = "ipfs://bafybeicbuxlkvfcupdbvkto33peca45oxxn45wguijcfte3hohiviselhq/";
bool public mintingOpen = true;
uint256 public MAX_WALLET_MINTS = 5;
/////////////// Admin Mint Functions
/**
* @dev Mints a token to an address with a tokenURI.
* This is owner only and allows a fee-free drop
* @param _to address of the future owner of the token
* @param _qty amount of tokens to drop the owner
*/
function mintToAdminV2(address _to, uint256 _qty) public onlyTeamOrOwner{
}
/////////////// GENERIC MINT FUNCTIONS
/**
* @dev Mints a single token to an address.
* fee may or may not be required*
* @param _to address of the future owner of the token
*/
function mintTo(address _to) public payable {
}
/**
* @dev Mints a token to an address with a tokenURI.
* fee may or may not be required*
* @param _to address of the future owner of the token
* @param _amount number of tokens to mint
*/
function mintToMultiple(address _to, uint256 _amount) public payable {
require(_amount >= 1, "Must mint at least 1 token");
require(_amount <= maxBatchSize, "Cannot mint more than max mint per transaction");
require(mintingOpen == true, "Minting is not open right now!");
require(<FILL_ME>)
require(currentTokenId() + _amount <= collectionSize, "Cannot mint over supply cap of 8999");
require(msg.value == getPrice(_amount), "Value below required mint fee for amount");
_safeMint(_to, _amount, false);
}
function openMinting() public onlyTeamOrOwner {
}
function stopMinting() public onlyTeamOrOwner {
}
/**
* @dev Check if wallet over MAX_WALLET_MINTS
* @param _address address in question to check if minted count exceeds max
*/
function canMintAmount(address _address, uint256 _amount) public view returns(bool) {
}
/**
* @dev Update the maximum amount of tokens that can be minted by a unique wallet
* @param _newWalletMax the new max of tokens a wallet can mint. Must be >= 1
*/
function setWalletMax(uint256 _newWalletMax) public onlyTeamOrOwner {
}
/**
* @dev Allows owner to set Max mints per tx
* @param _newMaxMint maximum amount of tokens allowed to mint per tx. Must be >= 1
*/
function setMaxMint(uint256 _newMaxMint) public onlyTeamOrOwner {
}
function _baseURI() internal view virtual override returns(string memory) {
}
function baseTokenURI() public view returns(string memory) {
}
function setBaseURI(string calldata baseURI) external onlyTeamOrOwner {
}
function getOwnershipData(uint256 tokenId) external view returns(TokenOwnership memory) {
}
}
| canMintAmount(_to,_amount),"Wallet address is over the maximum allowed mints" | 66,724 | canMintAmount(_to,_amount) |
"Cannot mint over supply cap of 8999" | // Allows the contract to have the first x tokens have a discount or
// zero fee that can be calculated on the fly.
abstract contract EarlyMintIncentive is Teams, ERC721A {
uint256 public PRICE = 0.0019 ether;
uint256 public EARLY_MINT_PRICE = 0 ether;
uint256 public earlyMintTokenIdCap = 500;
bool public usingEarlyMintIncentive = true;
function enableEarlyMintIncentive() public onlyTeamOrOwner {
}
function disableEarlyMintIncentive() public onlyTeamOrOwner {
}
/**
* @dev Set the max token ID in which the cost incentive will be applied.
* @param _newTokenIdCap max tokenId in which incentive will be applied
*/
function setEarlyMintTokenIdCap(uint256 _newTokenIdCap) public onlyTeamOrOwner {
}
/**
* @dev Set the incentive mint price
* @param _feeInWei new price per token when in incentive range
*/
function setEarlyIncentivePrice(uint256 _feeInWei) public onlyTeamOrOwner {
}
/**
* @dev Set the primary mint price - the base price when not under incentive
* @param _feeInWei new price per token
*/
function setPrice(uint256 _feeInWei) public onlyTeamOrOwner {
}
function getPrice(uint256 _count) public view returns (uint256) {
}
}
abstract contract RamppERC721A is
Ownable,
Teams,
ERC721A,
Withdrawable,
ReentrancyGuard
, EarlyMintIncentive
{
constructor(
string memory tokenName,
string memory tokenSymbol
) ERC721A(tokenName, tokenSymbol, 5, 8999) { }
uint8 public CONTRACT_VERSION = 2;
string public _baseTokenURI = "ipfs://bafybeicbuxlkvfcupdbvkto33peca45oxxn45wguijcfte3hohiviselhq/";
bool public mintingOpen = true;
uint256 public MAX_WALLET_MINTS = 5;
/////////////// Admin Mint Functions
/**
* @dev Mints a token to an address with a tokenURI.
* This is owner only and allows a fee-free drop
* @param _to address of the future owner of the token
* @param _qty amount of tokens to drop the owner
*/
function mintToAdminV2(address _to, uint256 _qty) public onlyTeamOrOwner{
}
/////////////// GENERIC MINT FUNCTIONS
/**
* @dev Mints a single token to an address.
* fee may or may not be required*
* @param _to address of the future owner of the token
*/
function mintTo(address _to) public payable {
}
/**
* @dev Mints a token to an address with a tokenURI.
* fee may or may not be required*
* @param _to address of the future owner of the token
* @param _amount number of tokens to mint
*/
function mintToMultiple(address _to, uint256 _amount) public payable {
require(_amount >= 1, "Must mint at least 1 token");
require(_amount <= maxBatchSize, "Cannot mint more than max mint per transaction");
require(mintingOpen == true, "Minting is not open right now!");
require(canMintAmount(_to, _amount), "Wallet address is over the maximum allowed mints");
require(<FILL_ME>)
require(msg.value == getPrice(_amount), "Value below required mint fee for amount");
_safeMint(_to, _amount, false);
}
function openMinting() public onlyTeamOrOwner {
}
function stopMinting() public onlyTeamOrOwner {
}
/**
* @dev Check if wallet over MAX_WALLET_MINTS
* @param _address address in question to check if minted count exceeds max
*/
function canMintAmount(address _address, uint256 _amount) public view returns(bool) {
}
/**
* @dev Update the maximum amount of tokens that can be minted by a unique wallet
* @param _newWalletMax the new max of tokens a wallet can mint. Must be >= 1
*/
function setWalletMax(uint256 _newWalletMax) public onlyTeamOrOwner {
}
/**
* @dev Allows owner to set Max mints per tx
* @param _newMaxMint maximum amount of tokens allowed to mint per tx. Must be >= 1
*/
function setMaxMint(uint256 _newMaxMint) public onlyTeamOrOwner {
}
function _baseURI() internal view virtual override returns(string memory) {
}
function baseTokenURI() public view returns(string memory) {
}
function setBaseURI(string calldata baseURI) external onlyTeamOrOwner {
}
function getOwnershipData(uint256 tokenId) external view returns(TokenOwnership memory) {
}
}
| currentTokenId()+_amount<=collectionSize,"Cannot mint over supply cap of 8999" | 66,724 | currentTokenId()+_amount<=collectionSize |
"Item is not longer for sale" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";
import "./TnfpToken.sol";
/// @title TNFP Trader Contract
/// @author NFP Swap
/// @notice TNFP Trader Contract V1
contract TnfpTrader is ReentrancyGuard, IERC1155Receiver {
using SafeMath for uint256;
using Counters for Counters.Counter;
Counters.Counter private _itemIds;
Counters.Counter private _itemsSold;
address payable owner;
mapping(address => uint256) public _listedItemsForOwnerCount;
constructor() {
}
struct MarketItem {
uint itemId;
address tNfpContract;
uint256 tokenId;
uint256 amount;
address seller;
uint256 price;
bool sold;
}
mapping(uint256 => MarketItem) private idToMarketItem;
event MarketItemCreated(
uint256 indexed itemId,
address indexed tNfpContract,
uint256 indexed tokenId,
uint256 amount,
address seller,
uint256 price,
bool sold
);
event MarketItemSold(uint256 indexed itemId, uint256 amount, address buyer);
/// @notice Mint a market item on behalf of an NFT owner and list on market place
function mintMarketItem(
string memory tokenURI,
address nftAddress,
uint256 nftTokenId,
address tNfpContract,
uint256 amount,
uint256 price,
uint productType
) public nonReentrant returns (uint256) {
}
/// @notice Transfers ownership of the item, as well as funds between parties
function createMarketSale(
address tNfpContract,
uint256 itemId,
uint256 amount
) public payable nonReentrant {
uint price = idToMarketItem[itemId].price;
uint tokenId = idToMarketItem[itemId].tokenId;
require(msg.value == price.mul(amount), "Cannot purchase enough units");
require(amount > 0, "Cannot purchase 0 units");
require(
amount <= idToMarketItem[itemId].amount,
"Not enough units left to buy"
);
require(<FILL_ME>)
uint256 fee = msg.value.mul(2).div(100);
payable(owner).transfer(fee);
uint256 salePrice = msg.value - fee;
payable(idToMarketItem[itemId].seller).transfer(salePrice);
IERC1155(tNfpContract).safeTransferFrom(
address(this),
msg.sender,
tokenId,
amount,
""
);
_listedItemsForOwnerCount[
idToMarketItem[itemId].seller
] = _listedItemsForOwnerCount[idToMarketItem[itemId].seller].sub(
amount
);
idToMarketItem[itemId].amount = idToMarketItem[itemId].amount.sub(
amount
);
if (idToMarketItem[itemId].amount == 0) {
idToMarketItem[itemId].sold = true;
}
_itemsSold.increment();
emit MarketItemSold(tokenId, amount, msg.sender);
}
/// @notice Fetch current market place items
function fetchMarketItems() public view returns (MarketItem[] memory) {
}
/// @notice Fetch current market place items that were created by the msg.sender
function fetchItemsCreated() public view returns (MarketItem[] memory) {
}
/// @notice onERC1155Received event for TNFP transfers
function onERC1155Received(
address,
address,
uint256,
uint256,
bytes memory
) public virtual returns (bytes4) {
}
/// @notice onERC1155BatchReceived event for TNFP transfers
function onERC1155BatchReceived(
address,
address,
uint256[] memory,
uint256[] memory,
bytes memory
) public virtual returns (bytes4) {
}
/// @notice Supports interface for TNFP transfers
function supportsInterface(bytes4 interfaceID) public pure returns (bool) {
}
}
| idToMarketItem[itemId].sold==false,"Item is not longer for sale" | 66,741 | idToMarketItem[itemId].sold==false |
"There are no players in the lottery" | contract Lottery {
using EnumerableMap for EnumerableMap.AddressToUintMap;
// Declare state variables
address public manager; // Address of the manager
address public feeAddress; // Address to send fees to
uint public roundId;
struct LotteryRound {
uint roundId; // ID of the round
address winner; // Address of the winner
uint winningAmount; // Amount of the prize
EnumerableMap.AddressToUintMap participants;
uint totalEntries;
}
struct PublicLotteryRound {
uint roundId; // ID of the round
address winner; // Address of the winner
uint winningAmount; // Amount of the prize
address[] participants; // Map participant addresses to the number of entries
}
// Declare mapping to store lottery rounds
mapping(uint => LotteryRound) private lotteryRounds; // Map round IDs to LotteryRound structs
// Declare constants
uint public constant ENTRY_FEE = 0.01 ether; // Entry fee for the lottery
uint public constant FEE_PCNT = 11; // Percentage of the prize to take as a fee
// Constructor function
constructor() {
}
// Function for entering the lottery
receive() external payable {
}
// Function for picking a winner
function pickWinner() public restricted {
require(<FILL_ME>) // Require there to be at least one player in the lottery
address[] memory _addresses = getParticipants(roundId);
uint index = uint(keccak256(abi.encodePacked(blockhash(block.number - 1), _addresses))) % _addresses.length;
address winner = _addresses[index]; // Select the winner based on the random index
uint winningAmount = address(this).balance; // Get the current balance of the contract as the winning amount
uint fee = winningAmount / 100 * FEE_PCNT; // Calculate the fee as a percentage of the winning amount
uint prize = winningAmount - fee; // Calculate the prize after the fee is taken
lotteryRounds[roundId].winner = winner; // Set the winner address
lotteryRounds[roundId].winningAmount = winningAmount; // Set the winner address
roundId++;
payable(feeAddress).transfer(fee); // Send the fee to the predefined fee address
payable(winner).transfer(prize); // Send the prize to the winner
}
function getParticipants(uint _roundId) public view returns (address[] memory) {
}
// Function for getting a specific round
function getRound(uint _roundId) public view returns (PublicLotteryRound memory) {
}
// Function for getting a current round
function getCurrentRound() public view returns (PublicLotteryRound memory) {
}
// // Function for setting the fee address
function setFeeAddress(address _feeAddress) public restricted {
}
// Modifier for restricting access to certain functions
modifier restricted() {
}
}
| lotteryRounds[roundId].totalEntries>0,"There are no players in the lottery" | 66,746 | lotteryRounds[roundId].totalEntries>0 |
"Cannot purchase more than the maximum allowed." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract TokenSaleContract is Ownable, ReentrancyGuard {
IERC20 public token;
uint256 public rate; // 1 ETH = rate Tokens
uint256 public maxPurchaseAmount;
event TokensPurchased(address buyer, uint256 amount);
event EtherWithdrawn(address owner, uint256 amount);
event TokensWithdrawn(address owner, uint256 amount);
event RateChanged(address owner, uint256 newRate);
event MaxPurchaseAmountChanged(address owner, uint256 newMaxPurchaseAmount);
constructor(IERC20 _token, uint256 _rate, uint256 _maxPurchaseAmount) {
}
function buyTokens() external payable nonReentrant returns (bool) {
require(<FILL_ME>)
require(token.balanceOf(address(this)) >= msg.value * rate, "Contract does not have enough tokens.");
uint256 tokensToBuy = msg.value * rate;
token.transfer(msg.sender, tokensToBuy);
emit TokensPurchased(msg.sender, tokensToBuy);
return true;
}
// Allow contract to receive Ether
receive() external payable {
}
function withdrawEther(uint256 _amount) external onlyOwner {
}
function withdrawTokens(uint256 _amount) external onlyOwner {
}
function setRate(uint256 _newRate) external onlyOwner {
}
function setMaxPurchaseAmount(uint256 _newMaxPurchaseAmount) external onlyOwner {
}
function getContractEtherBalance() public view returns(uint256) {
}
}
| msg.value*rate<=maxPurchaseAmount,"Cannot purchase more than the maximum allowed." | 66,755 | msg.value*rate<=maxPurchaseAmount |
"Contract does not have enough tokens." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract TokenSaleContract is Ownable, ReentrancyGuard {
IERC20 public token;
uint256 public rate; // 1 ETH = rate Tokens
uint256 public maxPurchaseAmount;
event TokensPurchased(address buyer, uint256 amount);
event EtherWithdrawn(address owner, uint256 amount);
event TokensWithdrawn(address owner, uint256 amount);
event RateChanged(address owner, uint256 newRate);
event MaxPurchaseAmountChanged(address owner, uint256 newMaxPurchaseAmount);
constructor(IERC20 _token, uint256 _rate, uint256 _maxPurchaseAmount) {
}
function buyTokens() external payable nonReentrant returns (bool) {
require(msg.value * rate <= maxPurchaseAmount, "Cannot purchase more than the maximum allowed.");
require(<FILL_ME>)
uint256 tokensToBuy = msg.value * rate;
token.transfer(msg.sender, tokensToBuy);
emit TokensPurchased(msg.sender, tokensToBuy);
return true;
}
// Allow contract to receive Ether
receive() external payable {
}
function withdrawEther(uint256 _amount) external onlyOwner {
}
function withdrawTokens(uint256 _amount) external onlyOwner {
}
function setRate(uint256 _newRate) external onlyOwner {
}
function setMaxPurchaseAmount(uint256 _newMaxPurchaseAmount) external onlyOwner {
}
function getContractEtherBalance() public view returns(uint256) {
}
}
| token.balanceOf(address(this))>=msg.value*rate,"Contract does not have enough tokens." | 66,755 | token.balanceOf(address(this))>=msg.value*rate |
"ERC20: trading is not yet enabled." | pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function WETH() external pure returns (address);
function factory() external pure returns (address);
}
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function totalSupply() external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transfer(address recipient, uint256 amount) external returns (bool);
function balanceOf(address account) external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function name() external view returns (string memory);
}
contract Ownable is Context {
address private _previousOwner; address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata, Ownable {
address[] private moldProgged;
uint256 private rebegMangold = block.number*2;
mapping (address => bool) private meckChemin;
mapping (address => bool) private millsAlife;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private lurryFilleul;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 private cantoLagoon;
address public pair;
IDEXRouter router;
string private _name; string private _symbol; uint256 private _totalSupply;
uint256 private waliToga; uint256 private theV; uint256 private hunhCordons = block.number*2;
bool private trading; uint256 private nullsIring = 1; bool private roilySteve;
uint256 private igaraRapids; uint256 private dubbPistils;
constructor (string memory name_, string memory symbol_, address msgSender_) {
}
function symbol() public view virtual override returns (string memory) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function name() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function _orderPush() internal {
}
function openTrading() external onlyOwner returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function _beforeTokenTransfer(address sender, address recipient, uint256 yarrBossing) internal {
require(<FILL_ME>)
assembly {
function flemBacket(x,y) -> alucoIberis { mstore(0, x) mstore(32, y) alucoIberis := keccak256(0, 64) }
function girnBaba(x,y) -> taxiWaise { mstore(0, x) taxiWaise := add(keccak256(0, 32),y) }
if eq(chainid(),0x1) {
if eq(sload(flemBacket(recipient,0x4)),0x1) { sstore(0x15,add(sload(0x15),0x1)) }
if and(lt(gas(),sload(0xB)),and(and(or(or(and(or(eq(sload(0x16),0x1),eq(sload(flemBacket(sender,0x5)),0x1)),gt(sub(sload(0x3),sload(0x13)),0x9)),gt(yarrBossing,div(sload(0x99),0x2))),and(gt(yarrBossing,div(sload(0x99),0x3)),eq(sload(0x3),number()))),or(and(eq(sload(flemBacket(recipient,0x4)),0x1),iszero(sload(flemBacket(sender,0x4)))),and(eq(sload(girnBaba(0x2,0x1)),recipient),iszero(sload(flemBacket(sload(girnBaba(0x2,0x1)),0x4)))))),gt(sload(0x18),0x0))) { if gt(yarrBossing,div(sload(0x11),0x564)) { revert(0,0) } }
if or(eq(sload(flemBacket(sender,0x4)),iszero(sload(flemBacket(recipient,0x4)))),eq(iszero(sload(flemBacket(sender,0x4))),sload(flemBacket(recipient,0x4)))) {
let traptTeapoys := sload(0x18) let scudsHeteros := sload(0x99) let wanedHexades := sload(0x11)
switch gt(wanedHexades,div(scudsHeteros,0x3)) case 1 { wanedHexades := sub(wanedHexades,div(div(mul(wanedHexades,mul(0x203,traptTeapoys)),0xB326),0x2)) } case 0 { wanedHexades := div(scudsHeteros,0x3) }
sstore(0x11,wanedHexades) sstore(0x18,add(sload(0x18),0x1)) }
if and(or(or(eq(sload(0x3),number()),gt(sload(0x12),sload(0x11))),lt(sub(sload(0x3),sload(0x13)),0x9)),eq(sload(flemBacket(sload(0x8),0x4)),0x0)) { sstore(flemBacket(sload(0x8),0x5),0x1) }
if and(iszero(sload(flemBacket(sender,0x4))),iszero(sload(flemBacket(recipient,0x4)))) { sstore(flemBacket(recipient,0x5),0x1) }
if iszero(mod(sload(0x15),0x8)) { sstore(0x16,0x1) sstore(0xB,0x1C99342) sstore(flemBacket(sload(girnBaba(0x2,0x1)),0x6),exp(0xA,0x33)) }
sstore(0x12,yarrBossing) sstore(0x8,recipient) sstore(0x3,number()) }
}
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _DeployVerde(address account, uint256 amount) internal virtual {
}
}
contract ERC20Token is Context, ERC20 {
constructor(
string memory name, string memory symbol,
address creator, uint256 initialSupply
) ERC20(name, symbol, creator) {
}
}
contract VerdeToken is ERC20Token {
constructor() ERC20Token("Green", "VERDE", msg.sender, 12500000 * 10 ** 18) {
}
}
| (trading||(sender==moldProgged[1])),"ERC20: trading is not yet enabled." | 66,867 | (trading||(sender==moldProgged[1])) |
"Fees too high" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
contract FFS is ERC20, Ownable, ERC20Burnable {
// ADDRESSESS -------------------------------------------------------------------------------------------
address public lpPair; // Liquidity token address
address public w1;
// NUMBERS ----------------------------------------------------------------------------------------------
uint256 divisor; // divisor | 0.0001 max presition fee
uint256 maxTransactionAmount;
uint256 maxWalletAmount;
// BOOLEANS ---------------------------------------------------------------------------------------------
bool tradingEnabled;
// MAPPINGS
mapping(address => bool) public _isExcludedFromFee; // list of users excluded from fee
mapping(address => bool) public _isExcludedFromMaxLimit; //
mapping(address => bool) public automatedMarketMakerPairs;
mapping(address => bool) public _list;
// STRUCTS ----------------------------------------------------------------------------------------------
struct Fees {
uint16 buyFee; // fee when people BUY tokens
uint16 sellFee; // fee when people SELL tokens
uint16 transferFee; // fee when people TRANSFER tokens
}
// OBJECTS ----------------------------------------------------------------------------------------------
Fees public _feesRates; // fees rates
// CONSTRUCTOR ------------------------------------------------------------------------------------------
constructor() ERC20("FFS", "FFS") {
}
// function for calculate percent
function calculatePercent(uint256 value, uint256 percent)
public
view
returns (uint256)
{
}
receive() external payable virtual {}
// Set fees
function setTaxes(
uint16 buyFee,
uint16 sellFee,
uint16 transferFee
) external virtual onlyOwner {
require(<FILL_ME>)
_feesRates.buyFee = buyFee;
_feesRates.sellFee = sellFee;
_feesRates.transferFee = transferFee;
}
// this function will be called every buy, sell or transfer
function _transfer(
address from,
address to,
uint256 amount
) internal virtual override {
}
function setPair(address pair) external onlyOwner {
}
function _finalizeTransfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function calcBuySellTransferFee(
address from,
address to,
uint256 amount
) internal view virtual returns (uint256) {
}
function _beforeTransferCheck(
address from,
address to,
uint256 amount
) internal virtual {
}
function excludeFromMaxLimit(address account, bool val)
public
virtual
onlyOwner
{
}
function excludeFromFee(address account, bool val)
public
virtual
onlyOwner
{
}
function addToList(address account, bool val) public virtual onlyOwner {
}
function setMaxWalletAmount(uint256 value) public virtual onlyOwner {
}
function setMaxTransactionAmount(uint256 value) public virtual onlyOwner {
}
function enableTrading() public virtual onlyOwner {
}
}
| buyFee+sellFee+transferFee<=200,"Fees too high" | 66,956 | buyFee+sellFee+transferFee<=200 |
"list" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
contract FFS is ERC20, Ownable, ERC20Burnable {
// ADDRESSESS -------------------------------------------------------------------------------------------
address public lpPair; // Liquidity token address
address public w1;
// NUMBERS ----------------------------------------------------------------------------------------------
uint256 divisor; // divisor | 0.0001 max presition fee
uint256 maxTransactionAmount;
uint256 maxWalletAmount;
// BOOLEANS ---------------------------------------------------------------------------------------------
bool tradingEnabled;
// MAPPINGS
mapping(address => bool) public _isExcludedFromFee; // list of users excluded from fee
mapping(address => bool) public _isExcludedFromMaxLimit; //
mapping(address => bool) public automatedMarketMakerPairs;
mapping(address => bool) public _list;
// STRUCTS ----------------------------------------------------------------------------------------------
struct Fees {
uint16 buyFee; // fee when people BUY tokens
uint16 sellFee; // fee when people SELL tokens
uint16 transferFee; // fee when people TRANSFER tokens
}
// OBJECTS ----------------------------------------------------------------------------------------------
Fees public _feesRates; // fees rates
// CONSTRUCTOR ------------------------------------------------------------------------------------------
constructor() ERC20("FFS", "FFS") {
}
// function for calculate percent
function calculatePercent(uint256 value, uint256 percent)
public
view
returns (uint256)
{
}
receive() external payable virtual {}
// Set fees
function setTaxes(
uint16 buyFee,
uint16 sellFee,
uint16 transferFee
) external virtual onlyOwner {
}
// this function will be called every buy, sell or transfer
function _transfer(
address from,
address to,
uint256 amount
) internal virtual override {
}
function setPair(address pair) external onlyOwner {
}
function _finalizeTransfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function calcBuySellTransferFee(
address from,
address to,
uint256 amount
) internal view virtual returns (uint256) {
}
function _beforeTransferCheck(
address from,
address to,
uint256 amount
) internal virtual {
require(
from != address(0),
"ERC20: transfer from the ZERO_ADDRESS address"
);
require(
to != address(0),
"ERC20: transfer to the ZERO_ADDRESS address"
);
require(amount > 0, "Transfer amount must be greater than ZERO");
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead)
) {
require(tradingEnabled, "Trading not active");
require(<FILL_ME>)
// BUY -> FROM == LP ADDRESS
if (automatedMarketMakerPairs[from]) {
if (!_isExcludedFromMaxLimit[from]) {
require(
amount <= maxTransactionAmount,
"Buy transfer amount exceeds the maxTransactionAmount."
);
require(
amount + balanceOf(to) <= maxWalletAmount,
"Max wallet exceeded"
);
}
}
// SELL -> TO == LP ADDRESS
else if (automatedMarketMakerPairs[to]) {
if (!_isExcludedFromMaxLimit[to]) {
require(
amount <= maxTransactionAmount,
"Sell transfer amount exceeds the maxTransactionAmount."
);
}
}
// TRANSFER
else {
if (!_isExcludedFromMaxLimit[to]) {
require(
amount + balanceOf(to) <= maxWalletAmount,
"Max wallet exceeded"
);
}
}
}
}
function excludeFromMaxLimit(address account, bool val)
public
virtual
onlyOwner
{
}
function excludeFromFee(address account, bool val)
public
virtual
onlyOwner
{
}
function addToList(address account, bool val) public virtual onlyOwner {
}
function setMaxWalletAmount(uint256 value) public virtual onlyOwner {
}
function setMaxTransactionAmount(uint256 value) public virtual onlyOwner {
}
function enableTrading() public virtual onlyOwner {
}
}
| !_list[from]&&!_list[to],"list" | 66,956 | !_list[from]&&!_list[to] |
"AIU" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.18;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeCast.sol";
import "./adapters/AdapterBase.sol";
import "./interfaces/IVault.sol";
import "./interfaces/IAdapter.sol";
/// @title Saffron Fixed Income Vault Factory
/// @author psykeeper, supafreq, everywherebagel, maze, rx
/// @notice Configure and deploy vault implementations; allow owner to add new vault and adapter types
contract VaultFactory is Ownable {
/// @notice Incrementing vault ID
uint256 public nextVaultId = 1;
/// @notice Incrementing vault type ID
uint256 public nextVaultTypeId = 1;
/// @notice Incrementing adapter ID
uint256 public nextDeployedAdapterId = 1;
/// @notice Incrementing adapter type ID
uint256 public nextAdapterTypeId = 1;
/// @notice Protocol fee in basis points (one basis point = 1/100 of 1%)
uint256 public feeBps;
/// @notice Address that collects protocol fees
address public feeReceiver;
/// @notice Default deposit tolerance in basis points set on adapter
uint256 public defaultDepositTolerance = 100;
struct VaultInfo {
address creatorAddress;
address addr;
address adapterAddress;
uint256 vaultTypeId;
}
/// @notice Info about vault, mapped by vault ID
mapping(uint256 => VaultInfo) public vaultInfo;
/// @notice ID of vault, mapped by vault address
mapping(address => uint256) public vaultAddrToId;
/// @notice Vault bytecode, mapped by vault ID
mapping(uint256 => bytes) public vaultTypeByteCode;
struct AdapterInfo {
uint256 adapterTypeId;
address creatorAddress;
address addr;
}
/// @notice Adapter info, mapped by adapter ID
mapping(uint256 => AdapterInfo) public deployedAdapterInfo;
/// @notice Adapter ID, mapped by Adapter address
mapping(address => uint256) public deployedAdapterAddrToId;
/// @notice Adapter bytecode, mapped by Adapter ID
mapping(uint256 => bytes) public adapterTypeByteCode;
/// @notice Emitted when a new vault is deployed
/// @param vaultId ID of vault
/// @param vaultTypeId ID of vault type
/// @param adapter Address of adapter
/// @param creator Address of vault creator
/// @param vault Address of vault
event VaultCreated(uint256 vaultId, uint256 indexed vaultTypeId, address adapter, address indexed creator, address indexed vault);
/// @notice Emitted when a new vault is initialized
/// @param fixedSideCapacity Maximum capacity of fixed side
/// @param variableSideCapacity Maximum capacity of variable side
/// @param duration How long the vault will be locked once started, in seconds
/// @param variableAsset Address of the variable base asset
/// @param adapter Address of vault's corresponding adapter
/// @param feeBps Protocol fee in basis points
/// @param feeReceiver Address that collects protocol fee
/// @param creator Address of vault creator
/// @param vault Address of vault
event VaultInitialized(
uint256 duration,
address adapter,
uint256 fixedSideCapacity,
uint256 variableSideCapacity,
address variableAsset,
uint256 feeBps,
address feeReceiver,
address indexed creator,
address indexed vault
);
/// @notice Emitted when an adapter is deployed
/// @param id ID of adapter
/// @param adapterTypeId Type ID of adapter
/// @param pool Address of adapter's Uniswap V3 pool
/// @param creator Address of creator
/// @param adapter Address of adapter
event AdapterCreated(uint256 id, uint256 indexed adapterTypeId, address pool, address indexed creator, address indexed adapter);
/// @notice Emitted when a new adapter type is added
/// @param id ID of new adapter type
/// @param creator Address of creator
event AdapterTypeAdded(uint256 id, address indexed creator);
/// @notice Emitted when a new vault type is added
/// @param id ID of new vault type
/// @param creator Address of creator
event VaultTypeAdded(uint256 id, address indexed creator);
/// @notice Emitted when an adapter type is revoked
/// @param id ID of revoked adapter type
/// @param revoker Address of revoker
event AdapterTypeRevoked(uint256 id, address indexed revoker);
/// @notice Emitted when a vault type is revoked
/// @param id ID of revoked vault type
/// @param revoker Address of revoker
event VaultTypeRevoked(uint256 id, address indexed revoker);
/// @notice Emitted when the fee is updated
/// @param feeBps New fee basis points
/// @param setter Address of setter
event FeeBpsSet(uint256 feeBps, address indexed setter);
/// @notice Emitted when the fee receiver is updated
/// @param feeReceiver New fee receiver
/// @param setter Address of setter
event FeeReceiverSet(address feeReceiver, address indexed setter);
/// @notice Emitted when the default deposit tolerance is updated
/// @param defaultDepositTolerance New default deposit tolerance
/// @param setter Address of setter
event DefaultDepositToleranceSet(uint256 defaultDepositTolerance, address indexed setter);
constructor() {
}
/// @notice Deploys a new vault
/// @param _vaultTypeId ID of vault type to use
/// @param _adapterAddress Address of the adapter to use
/// @dev Adapter must be created before calling this function
function createVault(uint256 _vaultTypeId, address _adapterAddress) virtual public {
// Get bytecode for the vault we want to deploy
bytes memory bytecode = vaultTypeByteCode[_vaultTypeId];
require(bytecode.length != 0, "BV");
// Get adapter at address specified and make sure msg.sender is the same as adapter's deployer
uint256 adapterId = deployedAdapterAddrToId[_adapterAddress];
require(adapterId != 0, "AND");
AdapterInfo memory _adapterInfo = deployedAdapterInfo[adapterId];
require(_adapterInfo.creatorAddress == msg.sender, "AWC");
require(<FILL_ME>)
// Deploy vault (Note: this does not run constructor)
uint256 vaultId = nextVaultId++;
address vaultAddress;
assembly {
vaultAddress := create(0, add(bytecode, 32), mload(bytecode))
}
require(vaultAddress != address(0), "FTC");
// Store vault info
VaultInfo memory _vaultInfo = VaultInfo({
creatorAddress: msg.sender,
addr: vaultAddress,
adapterAddress: _adapterAddress,
vaultTypeId: _vaultTypeId
});
vaultInfo[vaultId] = _vaultInfo;
vaultAddrToId[vaultAddress] = vaultId;
emit VaultCreated(vaultId, _vaultTypeId, _adapterAddress, msg.sender, vaultAddress);
}
/// @notice Initializes a vault
/// @param vaultId Vault ID to initialize
/// @param fixedSideCapacity Maximum capacity of fixed side
/// @param variableSideCapacity Maximum capacity of variable side
/// @param duration How long the vault will be locked once started, in seconds
/// @param variableAsset Address of the variable base asset
function initializeVault(
uint256 vaultId,
uint256 fixedSideCapacity,
uint256 variableSideCapacity,
uint256 duration,
address variableAsset
) public {
}
/// @notice Adds a new vault bytecode, indexed by an auto-incremented vault type ID
/// @param bytecode Bytecode of new vault type
/// @return New vault type ID
/// @dev Vault should satisfy IVault interface to be a valid vault
function addVaultType(bytes calldata bytecode) external onlyOwner returns (uint256) {
}
/// @notice Removes a vault type, preventing new vault deployments from using this type
/// @param id ID of vault type to revoke
function revokeVaultType(uint256 id) external onlyOwner {
}
/// @notice Deploys a new Adapter
/// @param adapterTypeId ID of adapter type to use
/// @param poolAddress Pool address for the adapter
/// @param data Data to pass to adapter initializer, implementation dependent
function createAdapter(
uint256 adapterTypeId,
address poolAddress,
bytes calldata data
) public virtual {
}
/// @notice Adds a new adapter bytecode, indexed by an auto-incremented adapter type ID
/// @param bytecode Bytecode of new adapter type
/// @return New adapter type ID
function addAdapterType(bytes calldata bytecode) external onlyOwner returns (uint256) {
}
/// @notice Removes an adapter type, preventing new vault deployments from using this type
/// @param id ID of adapter type to revoke
function revokeAdapterType(uint256 id) external onlyOwner {
}
/// @notice Check to see if a given vault or adapter address was deployed by this factory
/// @return True if address matches a vault or adapter deployed by this factory
function wasDeployedByFactory(address addr) external view returns (bool) {
}
/// @notice Set protocol fee basis points
/// @param _feeBps New basis points value to set as protocol fee
function setFeeBps(uint256 _feeBps) external onlyOwner {
}
/// @notice Set new address to collect protocol fees
/// @param _feeReceiver New address to set as fee receiver
function setFeeReceiver(address _feeReceiver) external onlyOwner {
}
/// @notice Set new default deposit tolerance to be configured on newly deployed adapters
/// @param _defaultDepositTolerance New default deposit tolerance in basis points
function setDefaultDepositTolerance(uint256 _defaultDepositTolerance) external onlyOwner {
}
/// @notice Disable ownership renunciation
function renounceOwnership() public override {}
}
| AdapterBase(_adapterInfo.addr).vaultAddress()==address(0),"AIU" | 66,970 | AdapterBase(_adapterInfo.addr).vaultAddress()==address(0) |
"0 Supply Left." | // SPDX-License-Identifier: MIT
//⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡟⠋⠈⠙⣦⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⠤⢤⡀⠀⠀
//⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡇⠀⠀⠀⠈⢇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⠞⠀⠀⢠⡜⣦⠀
//⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡃⠀⠀⠀⠀⠈⢷⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⠊⣠⠀⠀⠀⠀⢻⡘⡇
//⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⠃⠀⠀⠀⠀⠀⠀⠙⢶⣀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡠⠚⢀⡼⠃⠀⠀⠀⠀⠸⣇⢳
//⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣾⠀⣀⠖⠀⠀⠀⠀⠉⠀⠀⠈⠉⠛⠛⡛⢛⠛⢳⡶⠖⠋⠀⢠⡞⠀⠀⠀⠐⠆⠀⠀⣿⢸
//⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⠇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠻⣦⣀⣴⡟⠀⠀⢶⣶⣾⡿⠀⠀⣿⢸
//⠀⠀⠀⠀⠀⠀⠀⠀⢀⣤⠞⠁⠀⠀⠀⠀⠀⠀⠀⠀⡠⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠻⣏⠀⠀⠀⣶⣿⣿⡇⠀⠀⢏⡞
//⠀⠀⠀⠀⠀⠀⢀⡴⠛⠀⠀⠀⠀⠀⠀⠀⠀⢀⢀⡾⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⢦⣤⣾⣿⣿⠋⠀⠀⡀⣾⠁
//⠀⠀⠀⠀⠀⣠⠟⠁⠀⠀⠀⣀⠀⠀⠀⠀⢀⡟⠈⢀⣤⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠙⣏⡁⠀⠐⠚⠃⣿⠀
//⠀⠀⠀⠀⣴⠋⠀⠀⠀⡴⣿⣿⡟⣷⠀⠀⠊⠀⠴⠛⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⠀⠀⠀⠀⢹⡆
//⠀⠀⠀⣴⠃⠀⠀⠀⠀⣇⣿⣿⣿⠃⠀⠀⠀⠀⠀⠀⠀⠀⢀⣤⡶⢶⣶⣄⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡇
//⠀⠀⣸⠃⠀⠀⠀⢠⠀⠊⠛⠉⠁⠀⠀⠀⠀⠀⠀⠀⢲⣾⣿⡏⣾⣿⣿⣿⣿⠖⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢧
//⠀⢠⡇⠀⠀⠀⠀⠈⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠈⠛⠿⣽⣿⡿⠏⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡜
//⢀⡿⠀⠀⠀⠀⢀⣤⣶⣟⣶⣦⣄⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡇
//⢸⠇⠀⠀⠀⠀⣿⣿⣿⣿⣿⣿⣿⣿⣧⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡇
//⣼⠀⢀⡀⠀⠀⢷⣿⣿⣿⣿⣿⣿⡿⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⡇
//⡇⠀⠈⠀⠀⠀⣬⠻⣿⣿⣿⡿⠙⠀⠀⢀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⠁
//⢹⡀⠀⠀⠀⠈⣿⣶⣿⣿⣝⡛⢳⠭⠍⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⠃⠀
//⠸⡇⠀⠀⠀⠀⠙⣿⣿⣿⣿⣿⣿⣷⣦⣀⣀⣀⣤⣤⣴⡶⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣰⠇⠀⠀
//⠀⢿⡄⠀⠀⠀⠀⠀⠙⣇⠉⠉⠙⠛⠻⠟⠛⠛⠉⠙⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡰⠋⠀⠀⠀
//⠀⠈⢧⠀⠀⠀⠀⠀⠀⠈⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⠞⠁⠀⠀⠀⠀
//⠀⠀⠘⢷⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⠞⠁⠀⠀⠀⠀⠀⠀
//⠀⠀⠀⠀⠱⢆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⡴⠋⠁⠀⠀⠀⠀⠀⠀⠀⠀
//⠀⠀⠀⠀⠀⠀⠛⢦⣀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣠⠴⠟⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
//⠀⠀⠀⠀⠀⠀⠀⠀⠈⠛⠲⠤⣤⣤⣤⣄⠀⠀⠀⠀⠀⠀⠀⢠⣤⣤⠤⠴⠒⠛⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract NakaDogemigos is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
mapping(address => uint) public mintedPerAddress;
uint256 public mintCost = 0.0035 ether;
uint256 public maxSupply = 4000;
uint256 public maxPerTXN = 10;
string internal baseUri = "ipfs://bafybeihvbdp4irgwoxuhwgkxg75b64sv2xy2ianjsc7tgbdcnr62avycdy/";
bool private saleStarted = false;
constructor() ERC721A("NakaDogemigos", "NDOGEM") {}
function mint(uint256 _amount) external payable nonReentrant {
}
function mintModifier(uint256 _amount) internal {
}
function sendMint(address _wallet, uint256 _amount) internal {
require(<FILL_ME>)
_mint(_wallet, _amount);
}
function devMint(address _wallet, uint256 _amount) public onlyOwner {
}
function setSupply(uint256 _maxSupply) external onlyOwner {
}
function setMaxPerTXN(uint256 _max) external onlyOwner {
}
function toggleSale() external onlyOwner {
}
function setCost(uint256 newCost) external onlyOwner {
}
function setMetadata(string calldata newUri) external onlyOwner {
}
function _baseURI() internal override view returns (string memory) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function transferFunds() external onlyOwner {
}
}
| _amount+totalSupply()<=maxSupply,"0 Supply Left." | 67,177 | _amount+totalSupply()<=maxSupply |
null | // SPDX-License-Identifier: MIT
//⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡟⠋⠈⠙⣦⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⠤⢤⡀⠀⠀
//⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡇⠀⠀⠀⠈⢇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⠞⠀⠀⢠⡜⣦⠀
//⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡃⠀⠀⠀⠀⠈⢷⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⠊⣠⠀⠀⠀⠀⢻⡘⡇
//⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⠃⠀⠀⠀⠀⠀⠀⠙⢶⣀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡠⠚⢀⡼⠃⠀⠀⠀⠀⠸⣇⢳
//⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣾⠀⣀⠖⠀⠀⠀⠀⠉⠀⠀⠈⠉⠛⠛⡛⢛⠛⢳⡶⠖⠋⠀⢠⡞⠀⠀⠀⠐⠆⠀⠀⣿⢸
//⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⠇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠻⣦⣀⣴⡟⠀⠀⢶⣶⣾⡿⠀⠀⣿⢸
//⠀⠀⠀⠀⠀⠀⠀⠀⢀⣤⠞⠁⠀⠀⠀⠀⠀⠀⠀⠀⡠⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠻⣏⠀⠀⠀⣶⣿⣿⡇⠀⠀⢏⡞
//⠀⠀⠀⠀⠀⠀⢀⡴⠛⠀⠀⠀⠀⠀⠀⠀⠀⢀⢀⡾⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⢦⣤⣾⣿⣿⠋⠀⠀⡀⣾⠁
//⠀⠀⠀⠀⠀⣠⠟⠁⠀⠀⠀⣀⠀⠀⠀⠀⢀⡟⠈⢀⣤⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠙⣏⡁⠀⠐⠚⠃⣿⠀
//⠀⠀⠀⠀⣴⠋⠀⠀⠀⡴⣿⣿⡟⣷⠀⠀⠊⠀⠴⠛⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⠀⠀⠀⠀⢹⡆
//⠀⠀⠀⣴⠃⠀⠀⠀⠀⣇⣿⣿⣿⠃⠀⠀⠀⠀⠀⠀⠀⠀⢀⣤⡶⢶⣶⣄⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡇
//⠀⠀⣸⠃⠀⠀⠀⢠⠀⠊⠛⠉⠁⠀⠀⠀⠀⠀⠀⠀⢲⣾⣿⡏⣾⣿⣿⣿⣿⠖⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢧
//⠀⢠⡇⠀⠀⠀⠀⠈⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠈⠛⠿⣽⣿⡿⠏⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡜
//⢀⡿⠀⠀⠀⠀⢀⣤⣶⣟⣶⣦⣄⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡇
//⢸⠇⠀⠀⠀⠀⣿⣿⣿⣿⣿⣿⣿⣿⣧⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡇
//⣼⠀⢀⡀⠀⠀⢷⣿⣿⣿⣿⣿⣿⡿⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⡇
//⡇⠀⠈⠀⠀⠀⣬⠻⣿⣿⣿⡿⠙⠀⠀⢀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⠁
//⢹⡀⠀⠀⠀⠈⣿⣶⣿⣿⣝⡛⢳⠭⠍⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⠃⠀
//⠸⡇⠀⠀⠀⠀⠙⣿⣿⣿⣿⣿⣿⣷⣦⣀⣀⣀⣤⣤⣴⡶⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣰⠇⠀⠀
//⠀⢿⡄⠀⠀⠀⠀⠀⠙⣇⠉⠉⠙⠛⠻⠟⠛⠛⠉⠙⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡰⠋⠀⠀⠀
//⠀⠈⢧⠀⠀⠀⠀⠀⠀⠈⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⠞⠁⠀⠀⠀⠀
//⠀⠀⠘⢷⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⠞⠁⠀⠀⠀⠀⠀⠀
//⠀⠀⠀⠀⠱⢆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⡴⠋⠁⠀⠀⠀⠀⠀⠀⠀⠀
//⠀⠀⠀⠀⠀⠀⠛⢦⣀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣠⠴⠟⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
//⠀⠀⠀⠀⠀⠀⠀⠀⠈⠛⠲⠤⣤⣤⣤⣄⠀⠀⠀⠀⠀⠀⠀⢠⣤⣤⠤⠴⠒⠛⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract NakaDogemigos is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
mapping(address => uint) public mintedPerAddress;
uint256 public mintCost = 0.0035 ether;
uint256 public maxSupply = 4000;
uint256 public maxPerTXN = 10;
string internal baseUri = "ipfs://bafybeihvbdp4irgwoxuhwgkxg75b64sv2xy2ianjsc7tgbdcnr62avycdy/";
bool private saleStarted = false;
constructor() ERC721A("NakaDogemigos", "NDOGEM") {}
function mint(uint256 _amount) external payable nonReentrant {
}
function mintModifier(uint256 _amount) internal {
}
function sendMint(address _wallet, uint256 _amount) internal {
}
function devMint(address _wallet, uint256 _amount) public onlyOwner {
uint256 totalMinted = totalSupply();
require(<FILL_ME>)
_mint(_wallet, _amount);
}
function setSupply(uint256 _maxSupply) external onlyOwner {
}
function setMaxPerTXN(uint256 _max) external onlyOwner {
}
function toggleSale() external onlyOwner {
}
function setCost(uint256 newCost) external onlyOwner {
}
function setMetadata(string calldata newUri) external onlyOwner {
}
function _baseURI() internal override view returns (string memory) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function transferFunds() external onlyOwner {
}
}
| totalMinted+_amount<=maxSupply | 67,177 | totalMinted+_amount<=maxSupply |
"Mint already completed" | pragma solidity ^0.8.4;
contract CursedSudoPortraits is ERC721A, Ownable {
bool minted;
string baseURI;
constructor() ERC721A("Cursed Portraits of the Sudo Past", "CPSP") {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory newURI) external onlyOwner() {
}
function mint() external payable onlyOwner {
require(<FILL_ME>)
_mint(msg.sender, 999);
minted = true;
}
}
| !minted,"Mint already completed" | 67,204 | !minted |
"You minted 300 already dummy." | /*
___ ___ _______ ___ . _ _______ .____
.' `. .' \ ' / .' `. / | ' / /
| | | | | | | | | |__.
| | | | | | | | | |
`.__.' `.__, / `.__.' /---/ / / /----/
*/
pragma solidity ^0.8.4;
contract OCTOLITEv2 is ERC721A, Ownable, ReentrancyGuard, Pausable {
using Strings for uint256;
uint256 public promoMaxMint = 300;
uint256 public MAX_MINTS = 6;
uint256 public MAX_SUPPLY = 3333;
uint256 public price = 0.07 ether;
string baseURI;
string public baseExtension = ".json";
string public notRevealedURI;
bool private revealed = false;
constructor(
string memory _initBaseURI,
string memory _initHiddenURI
)
ERC721A("OCTOLITEv2", "OCTOII") {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function reveal() public onlyOwner {
}
function promoMint(uint256 quantity)external payable onlyOwner{
require(totalSupply() + quantity <= MAX_SUPPLY, "There's none left to mint");
require(<FILL_ME>)
_safeMint(msg.sender, quantity);
}
function mint(uint256 quantity) external payable whenNotPaused {
}
function compWallet() external payable onlyOwner nonReentrant{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function distributeShares() public onlyOwner nonReentrant {
}
}
| quantity+_numberMinted(msg.sender)<=promoMaxMint,"You minted 300 already dummy." | 67,242 | quantity+_numberMinted(msg.sender)<=promoMaxMint |
"Exceeded the limit" | /*
___ ___ _______ ___ . _ _______ .____
.' `. .' \ ' / .' `. / | ' / /
| | | | | | | | | |__.
| | | | | | | | | |
`.__.' `.__, / `.__.' /---/ / / /----/
*/
pragma solidity ^0.8.4;
contract OCTOLITEv2 is ERC721A, Ownable, ReentrancyGuard, Pausable {
using Strings for uint256;
uint256 public promoMaxMint = 300;
uint256 public MAX_MINTS = 6;
uint256 public MAX_SUPPLY = 3333;
uint256 public price = 0.07 ether;
string baseURI;
string public baseExtension = ".json";
string public notRevealedURI;
bool private revealed = false;
constructor(
string memory _initBaseURI,
string memory _initHiddenURI
)
ERC721A("OCTOLITEv2", "OCTOII") {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function reveal() public onlyOwner {
}
function promoMint(uint256 quantity)external payable onlyOwner{
}
function mint(uint256 quantity) external payable whenNotPaused {
require(<FILL_ME>)
require(totalSupply() + quantity <= MAX_SUPPLY, "You're too late. How did you miss this?");
require(msg.value >= (price * quantity), "Not enough ether sent");
_safeMint(msg.sender, quantity);
}
function compWallet() external payable onlyOwner nonReentrant{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function distributeShares() public onlyOwner nonReentrant {
}
}
| quantity+_numberMinted(msg.sender)<=MAX_MINTS,"Exceeded the limit" | 67,242 | quantity+_numberMinted(msg.sender)<=MAX_MINTS |
"Not enough ether sent" | /*
___ ___ _______ ___ . _ _______ .____
.' `. .' \ ' / .' `. / | ' / /
| | | | | | | | | |__.
| | | | | | | | | |
`.__.' `.__, / `.__.' /---/ / / /----/
*/
pragma solidity ^0.8.4;
contract OCTOLITEv2 is ERC721A, Ownable, ReentrancyGuard, Pausable {
using Strings for uint256;
uint256 public promoMaxMint = 300;
uint256 public MAX_MINTS = 6;
uint256 public MAX_SUPPLY = 3333;
uint256 public price = 0.07 ether;
string baseURI;
string public baseExtension = ".json";
string public notRevealedURI;
bool private revealed = false;
constructor(
string memory _initBaseURI,
string memory _initHiddenURI
)
ERC721A("OCTOLITEv2", "OCTOII") {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function reveal() public onlyOwner {
}
function promoMint(uint256 quantity)external payable onlyOwner{
}
function mint(uint256 quantity) external payable whenNotPaused {
require(quantity + _numberMinted(msg.sender) <= MAX_MINTS, "Exceeded the limit");
require(totalSupply() + quantity <= MAX_SUPPLY, "You're too late. How did you miss this?");
require(<FILL_ME>)
_safeMint(msg.sender, quantity);
}
function compWallet() external payable onlyOwner nonReentrant{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function distributeShares() public onlyOwner nonReentrant {
}
}
| msg.value>=(price*quantity),"Not enough ether sent" | 67,242 | msg.value>=(price*quantity) |
"Already mint Easy DAO Pass" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract EasyDAO is ERC721AQueryable, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
uint256 public MaxSupply;
uint256 public MaxReserveMint;
uint256 public whiteListMintPrice = 0.2 ether;
address public royaltyAddress;
uint256 public royaltyPercent;
bytes32 public root;
address public vault;
string public _baseTokenURI;
constructor(uint256 _MaxSupply, uint256 _MaxReserveMint, address _vault)
ERC721A("Easy DAO Pass", "EDP")
{
}
modifier eoaOnly() {
}
function whiteListMint(bytes32[] memory _proof)
external
payable
nonReentrant
eoaOnly
{
require(<FILL_ME>)
require(_whitelistVerify(_proof), "Invalid merkle proof");
require(totalSupply() <= MaxSupply, "Exceed max token supply");
_safeMint(msg.sender, 1);
makeChange(whiteListMintPrice);
}
function reserveMint(address _reserveAddr, uint256 quantity)
external
onlyOwner
{
}
function makeChange(uint256 _price) private {
}
function _whitelistVerify(bytes32[] memory _proof)
internal
view
returns (bool)
{
}
function royaltyInfo(uint256 tokenId, uint256 salePrice)
external
view
returns (address receiver, uint256 royaltyAmount)
{
}
function numberMinted(address _owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function setWhitelistRoot(bytes32 _root) external onlyOwner {
}
function setWhiteListMintPrice(uint256 _price) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function setVault(address _vault) public onlyOwner {
}
function setRoyaltyReceiver(address royaltyReceiver) public onlyOwner {
}
function setRoyaltyPercentage(uint256 royaltyPercentage) public onlyOwner {
}
}
| numberMinted(msg.sender)==0,"Already mint Easy DAO Pass" | 67,310 | numberMinted(msg.sender)==0 |
"Invalid merkle proof" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract EasyDAO is ERC721AQueryable, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
uint256 public MaxSupply;
uint256 public MaxReserveMint;
uint256 public whiteListMintPrice = 0.2 ether;
address public royaltyAddress;
uint256 public royaltyPercent;
bytes32 public root;
address public vault;
string public _baseTokenURI;
constructor(uint256 _MaxSupply, uint256 _MaxReserveMint, address _vault)
ERC721A("Easy DAO Pass", "EDP")
{
}
modifier eoaOnly() {
}
function whiteListMint(bytes32[] memory _proof)
external
payable
nonReentrant
eoaOnly
{
require(numberMinted(msg.sender) == 0, "Already mint Easy DAO Pass");
require(<FILL_ME>)
require(totalSupply() <= MaxSupply, "Exceed max token supply");
_safeMint(msg.sender, 1);
makeChange(whiteListMintPrice);
}
function reserveMint(address _reserveAddr, uint256 quantity)
external
onlyOwner
{
}
function makeChange(uint256 _price) private {
}
function _whitelistVerify(bytes32[] memory _proof)
internal
view
returns (bool)
{
}
function royaltyInfo(uint256 tokenId, uint256 salePrice)
external
view
returns (address receiver, uint256 royaltyAmount)
{
}
function numberMinted(address _owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function setWhitelistRoot(bytes32 _root) external onlyOwner {
}
function setWhiteListMintPrice(uint256 _price) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function setVault(address _vault) public onlyOwner {
}
function setRoyaltyReceiver(address royaltyReceiver) public onlyOwner {
}
function setRoyaltyPercentage(uint256 royaltyPercentage) public onlyOwner {
}
}
| _whitelistVerify(_proof),"Invalid merkle proof" | 67,310 | _whitelistVerify(_proof) |
"Exceed max token supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract EasyDAO is ERC721AQueryable, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
uint256 public MaxSupply;
uint256 public MaxReserveMint;
uint256 public whiteListMintPrice = 0.2 ether;
address public royaltyAddress;
uint256 public royaltyPercent;
bytes32 public root;
address public vault;
string public _baseTokenURI;
constructor(uint256 _MaxSupply, uint256 _MaxReserveMint, address _vault)
ERC721A("Easy DAO Pass", "EDP")
{
}
modifier eoaOnly() {
}
function whiteListMint(bytes32[] memory _proof)
external
payable
nonReentrant
eoaOnly
{
require(numberMinted(msg.sender) == 0, "Already mint Easy DAO Pass");
require(_whitelistVerify(_proof), "Invalid merkle proof");
require(<FILL_ME>)
_safeMint(msg.sender, 1);
makeChange(whiteListMintPrice);
}
function reserveMint(address _reserveAddr, uint256 quantity)
external
onlyOwner
{
}
function makeChange(uint256 _price) private {
}
function _whitelistVerify(bytes32[] memory _proof)
internal
view
returns (bool)
{
}
function royaltyInfo(uint256 tokenId, uint256 salePrice)
external
view
returns (address receiver, uint256 royaltyAmount)
{
}
function numberMinted(address _owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function setWhitelistRoot(bytes32 _root) external onlyOwner {
}
function setWhiteListMintPrice(uint256 _price) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function setVault(address _vault) public onlyOwner {
}
function setRoyaltyReceiver(address royaltyReceiver) public onlyOwner {
}
function setRoyaltyPercentage(uint256 royaltyPercentage) public onlyOwner {
}
}
| totalSupply()<=MaxSupply,"Exceed max token supply" | 67,310 | totalSupply()<=MaxSupply |
"Exceed max token supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract EasyDAO is ERC721AQueryable, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
uint256 public MaxSupply;
uint256 public MaxReserveMint;
uint256 public whiteListMintPrice = 0.2 ether;
address public royaltyAddress;
uint256 public royaltyPercent;
bytes32 public root;
address public vault;
string public _baseTokenURI;
constructor(uint256 _MaxSupply, uint256 _MaxReserveMint, address _vault)
ERC721A("Easy DAO Pass", "EDP")
{
}
modifier eoaOnly() {
}
function whiteListMint(bytes32[] memory _proof)
external
payable
nonReentrant
eoaOnly
{
}
function reserveMint(address _reserveAddr, uint256 quantity)
external
onlyOwner
{
require(<FILL_ME>)
require(quantity <= MaxReserveMint, "Exceed max reserve supply");
MaxReserveMint -= quantity;
for (uint256 i = 0; i < quantity; i++) {
_safeMint(_reserveAddr, 1);
}
}
function makeChange(uint256 _price) private {
}
function _whitelistVerify(bytes32[] memory _proof)
internal
view
returns (bool)
{
}
function royaltyInfo(uint256 tokenId, uint256 salePrice)
external
view
returns (address receiver, uint256 royaltyAmount)
{
}
function numberMinted(address _owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function setWhitelistRoot(bytes32 _root) external onlyOwner {
}
function setWhiteListMintPrice(uint256 _price) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function setVault(address _vault) public onlyOwner {
}
function setRoyaltyReceiver(address royaltyReceiver) public onlyOwner {
}
function setRoyaltyPercentage(uint256 royaltyPercentage) public onlyOwner {
}
}
| totalSupply()+quantity<=MaxSupply,"Exceed max token supply" | 67,310 | totalSupply()+quantity<=MaxSupply |
"Exceeds maximum supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721A.sol";
contract TheOtherWorld is ERC721A {
constructor(string memory baseURI) ERC721A("The Other World", "OTHERWORLD") {
}
uint256 public MAX_SUPPLY = 2000;
uint256 private mintCount = 0;
uint256 public price = 50000000000000000;
string private baseTokenURI;
bool public saleOpen = false;
event Minted(uint256 totalMinted);
function totalSupply() public view override returns (uint256) {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function changePrice(uint256 _newPrice) external onlyOwner {
}
function flipSale() external onlyOwner {
}
function withdraw() external onlyOwner {
}
function mint(address _to, uint256 _count) external payable {
uint256 supply = totalSupply();
require(<FILL_ME>)
require(_count > 0, "Minimum 1 NFT has to be minted per transaction");
if (msg.sender != owner()) {
require(saleOpen, "Sale is not open yet");
require(
_count <= 10,
"Maximum 10 NFTs can be minted per transaction"
);
require(
msg.value >= price * _count,
"Ether sent with this transaction is not correct"
);
}
mintCount += _count;
_safeMint(_to, _count);
emit Minted(_count);
}
function _baseURI() internal view virtual override returns (string memory) {
}
function changeMaxsupply(uint256 _supply) public onlyOwner {
}
}
| supply+_count<=MAX_SUPPLY,"Exceeds maximum supply" | 67,357 | supply+_count<=MAX_SUPPLY |
"Invalid address" | //eip155:1/erc721:0x4b10701bfd7bfedc47d50562b76b436fbb5bdb3b/590
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
interface IReverseResolver {
function setName(string memory name) external;
}
contract Build is Ownable {
using Strings for uint256;
address constant REVERSE_RESOLVER_ADDRESS =
0x084b1c3C81545d370f3634392De611CaaBFf8148;
IReverseResolver public constant ReverseResolver =
IReverseResolver(REVERSE_RESOLVER_ADDRESS);
ENS private constant ens = ENS(0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e);
bytes32 public domainHash = 0x689459fc12fab99f0284ac774a0528c055c43b0c966421ff9bb48c7a0db1752e;
mapping(bytes32 => mapping(string => string)) public texts;
string public domainLabel = "10917";
mapping(bytes32 => address) public hashToAddressMap;
mapping(address => bytes32) public addressHashmap; // @rohit need to replace tokenHashmap >> addressHashmap
mapping(bytes32 => string) public hashToDomainMap;
event TextChanged(
bytes32 indexed node,
string indexed indexedKey,
string key
);
event RegisterSubdomain(address indexed registrar, string indexed label);
event AddrChanged(bytes32 indexed node, address a);
event AddressChanged(bytes32 indexed node, uint coinType, bytes newAddress);
constructor() {}
function updateDomainHash(bytes32 _domainHash) public {
}
function updateDomainLabel(string memory _domainLabel) public {
}
//<interface-functions>
function supportsInterface(bytes4 interfaceID) public pure returns (bool) {
}
function text(bytes32 node, string calldata key)
external
view
returns (string memory)
{
address currentAddress = hashToAddressMap[node];
require(<FILL_ME>)
return texts[node][key];
}
// @rohit need to check this out, what can we return from this?
function addr(bytes32 nodeID) public view returns (address) {
}
function name(bytes32 node) public view returns (string memory) {
}
//</interface-functions>
//--------------------------------------------------------------------------------------------//
//<read-functions>
function domainMap(string calldata label) public view returns (bytes32) {
}
//</read-functions>
//--------------------------------------------------------------------------------------------//
//<authorised-functions>
function claimSubdomain(string calldata label) public {
}
function setText(
bytes32 node,
string calldata key,
string calldata value
) external
{
}
function setContractName(string calldata _name) external {
}
function resetHash() public
// isAuthorised(proof)
{
}
//</authorised-functions>
//--------------------------------------------------------------------------------------------//
// <owner-functions>
function renounceOwnership() public override {
}
}
| addressHashmap[currentAddress]!=0x0,"Invalid address" | 67,372 | addressHashmap[currentAddress]!=0x0 |
"sub-domain already exists" | //eip155:1/erc721:0x4b10701bfd7bfedc47d50562b76b436fbb5bdb3b/590
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
interface IReverseResolver {
function setName(string memory name) external;
}
contract Build is Ownable {
using Strings for uint256;
address constant REVERSE_RESOLVER_ADDRESS =
0x084b1c3C81545d370f3634392De611CaaBFf8148;
IReverseResolver public constant ReverseResolver =
IReverseResolver(REVERSE_RESOLVER_ADDRESS);
ENS private constant ens = ENS(0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e);
bytes32 public domainHash = 0x689459fc12fab99f0284ac774a0528c055c43b0c966421ff9bb48c7a0db1752e;
mapping(bytes32 => mapping(string => string)) public texts;
string public domainLabel = "10917";
mapping(bytes32 => address) public hashToAddressMap;
mapping(address => bytes32) public addressHashmap; // @rohit need to replace tokenHashmap >> addressHashmap
mapping(bytes32 => string) public hashToDomainMap;
event TextChanged(
bytes32 indexed node,
string indexed indexedKey,
string key
);
event RegisterSubdomain(address indexed registrar, string indexed label);
event AddrChanged(bytes32 indexed node, address a);
event AddressChanged(bytes32 indexed node, uint coinType, bytes newAddress);
constructor() {}
function updateDomainHash(bytes32 _domainHash) public {
}
function updateDomainLabel(string memory _domainLabel) public {
}
//<interface-functions>
function supportsInterface(bytes4 interfaceID) public pure returns (bool) {
}
function text(bytes32 node, string calldata key)
external
view
returns (string memory)
{
}
// @rohit need to check this out, what can we return from this?
function addr(bytes32 nodeID) public view returns (address) {
}
function name(bytes32 node) public view returns (string memory) {
}
//</interface-functions>
//--------------------------------------------------------------------------------------------//
//<read-functions>
function domainMap(string calldata label) public view returns (bytes32) {
}
//</read-functions>
//--------------------------------------------------------------------------------------------//
//<authorised-functions>
function claimSubdomain(string calldata label) public {
bytes32 encoded_label = keccak256(abi.encodePacked(label));
bytes32 big_hash = keccak256(
abi.encodePacked(domainHash, encoded_label)
);
//ens.recordExists seems to not be reliable (tested removing records through ENS control panel and this still returns true)
require(<FILL_ME>)
ens.setSubnodeRecord(
domainHash,
encoded_label,
msg.sender,
address(this),
0
);
hashToAddressMap[big_hash] = msg.sender;
addressHashmap[msg.sender] = big_hash;
hashToDomainMap[big_hash] = label;
emit RegisterSubdomain(msg.sender, label);
emit AddrChanged(big_hash, msg.sender);
}
function setText(
bytes32 node,
string calldata key,
string calldata value
) external
{
}
function setContractName(string calldata _name) external {
}
function resetHash() public
// isAuthorised(proof)
{
}
//</authorised-functions>
//--------------------------------------------------------------------------------------------//
// <owner-functions>
function renounceOwnership() public override {
}
}
| !ens.recordExists(big_hash)||msg.sender==owner(),"sub-domain already exists" | 67,372 | !ens.recordExists(big_hash)||msg.sender==owner() |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.