comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"Whitelist: Address already whitelisted" | pragma solidity 0.8.17;
import "./IWhitelist.sol";
abstract contract Whitelist is IWhitelist {
mapping(address => bool) public whitelist;
address public registrar;
constructor(address registrarAddress) {
}
/**
* @dev Throws if called by any account that's not whitelisted.
*/
modifier onlyWhitelisted(address _addr) {
}
/**
* @dev Throws if called by any account other than the registrar.
*/
modifier onlyRegistrar() {
}
/**
* @dev Allows the current registrar to transfer control of the contract to a newRegistrar.
* @param _newRegistrar The address to transfer registrarship to.
*/
function updateRegistrar(address _newRegistrar)
external
onlyRegistrar
returns (bool)
{
}
/**
* @dev Transfers ownership of the contract to a new account (`newRegistrar`).
* Internal function without access restriction.
*/
function _transferRegistrarship(address _newRegistrar)
internal
virtual
returns (bool)
{
}
/**
* @dev add an address to the whitelist
* @param _addr address
* @return true if the address was added to the whitelist, false if the address was already in the whitelist
*/
function addAddressToWhitelist(address _addr)
external
onlyRegistrar
returns (bool)
{
require(<FILL_ME>)
whitelist[_addr] = true;
emit WhitelistedAddressAdded(_addr);
return true;
}
/**
* @dev remove an address from the whitelist
* @param _addr address
* @return true if the address was removed from the whitelist,
* false if the address wasn't in the whitelist in the first place
*/
function removeAddressFromWhitelist(address _addr)
external
onlyRegistrar
returns (bool)
{
}
}
| !whitelist[_addr],"Whitelist: Address already whitelisted" | 459,959 | !whitelist[_addr] |
"The requested mint quantity exceeds the mint limit." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
contract VrHamsters is ERC721A, Ownable {
using SafeMath for uint256;
bytes32 public merkleRoot;
bool public revealed = false;
bool public mintActive = false;
bool public whitelistedMintActive = false;
string public baseURI;
string public nonRevealURI;
string public uriSuffix = '.json';
uint256 public price = 0.03 ether;
uint256 public whitelistedPrice = 0.02 ether;
uint256 public mintLimit = 5;
uint256 public maxSupply = 5555;
constructor() ERC721A("VR Hamsters", "VRH") {}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function mint(uint256 quantity) external payable {
require(mintActive, "The mint is not active.");
require(totalSupply().add(quantity) <= maxSupply, "The requested mint quantity exceeds the supply.");
require(<FILL_ME>)
require(price.mul(quantity) <= msg.value, "Not enough ETH for mint transaction.");
_mint(msg.sender, quantity);
}
function whitelistMint(uint256 quantity, bytes32[] calldata merkleProof) external payable {
}
function airdrop(address[] memory _addresses) external onlyOwner {
}
function mintTo(uint256 _quantity, address _receiver) external onlyOwner {
}
function adjustMaxSupply(uint256 _maxSupply) external onlyOwner {
}
function fundsWithdraw() external onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function setRevealed(bool _revealed) external onlyOwner {
}
function setMintActive(bool _mintActive) external onlyOwner {
}
function setWhitelistedMintActive(bool _whitelistedMintActive) external onlyOwner {
}
function setBaseUri(string memory _newBaseURI) external onlyOwner {
}
function setNonRevealUri(string memory _nonRevealURI) external onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) external onlyOwner {
}
}
| _numberMinted(msg.sender).add(quantity)<=mintLimit,"The requested mint quantity exceeds the mint limit." | 460,248 | _numberMinted(msg.sender).add(quantity)<=mintLimit |
"Not enough ETH for mint transaction." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
contract VrHamsters is ERC721A, Ownable {
using SafeMath for uint256;
bytes32 public merkleRoot;
bool public revealed = false;
bool public mintActive = false;
bool public whitelistedMintActive = false;
string public baseURI;
string public nonRevealURI;
string public uriSuffix = '.json';
uint256 public price = 0.03 ether;
uint256 public whitelistedPrice = 0.02 ether;
uint256 public mintLimit = 5;
uint256 public maxSupply = 5555;
constructor() ERC721A("VR Hamsters", "VRH") {}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function mint(uint256 quantity) external payable {
}
function whitelistMint(uint256 quantity, bytes32[] calldata merkleProof) external payable {
require(whitelistedMintActive, "The mint is not active.");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(merkleProof, merkleRoot, leaf), "Invalid merkle proof.");
require(totalSupply().add(quantity) <= maxSupply, "The requested mint quantity exceeds the supply.");
require(_numberMinted(msg.sender).add(quantity) <= mintLimit, "The requested mint quantity exceeds the mint limit.");
require(<FILL_ME>)
_mint(msg.sender, quantity);
}
function airdrop(address[] memory _addresses) external onlyOwner {
}
function mintTo(uint256 _quantity, address _receiver) external onlyOwner {
}
function adjustMaxSupply(uint256 _maxSupply) external onlyOwner {
}
function fundsWithdraw() external onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function setRevealed(bool _revealed) external onlyOwner {
}
function setMintActive(bool _mintActive) external onlyOwner {
}
function setWhitelistedMintActive(bool _whitelistedMintActive) external onlyOwner {
}
function setBaseUri(string memory _newBaseURI) external onlyOwner {
}
function setNonRevealUri(string memory _nonRevealURI) external onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) external onlyOwner {
}
}
| whitelistedPrice.mul(quantity)<=msg.value,"Not enough ETH for mint transaction." | 460,248 | whitelistedPrice.mul(quantity)<=msg.value |
"The requested mint quantity exceeds the supply." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
contract VrHamsters is ERC721A, Ownable {
using SafeMath for uint256;
bytes32 public merkleRoot;
bool public revealed = false;
bool public mintActive = false;
bool public whitelistedMintActive = false;
string public baseURI;
string public nonRevealURI;
string public uriSuffix = '.json';
uint256 public price = 0.03 ether;
uint256 public whitelistedPrice = 0.02 ether;
uint256 public mintLimit = 5;
uint256 public maxSupply = 5555;
constructor() ERC721A("VR Hamsters", "VRH") {}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function mint(uint256 quantity) external payable {
}
function whitelistMint(uint256 quantity, bytes32[] calldata merkleProof) external payable {
}
function airdrop(address[] memory _addresses) external onlyOwner {
require(<FILL_ME>)
for (uint256 i = 0; i < _addresses.length; i++) {
_mint(_addresses[i], 1);
}
}
function mintTo(uint256 _quantity, address _receiver) external onlyOwner {
}
function adjustMaxSupply(uint256 _maxSupply) external onlyOwner {
}
function fundsWithdraw() external onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function setRevealed(bool _revealed) external onlyOwner {
}
function setMintActive(bool _mintActive) external onlyOwner {
}
function setWhitelistedMintActive(bool _whitelistedMintActive) external onlyOwner {
}
function setBaseUri(string memory _newBaseURI) external onlyOwner {
}
function setNonRevealUri(string memory _nonRevealURI) external onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) external onlyOwner {
}
}
| totalSupply().add(_addresses.length)<=maxSupply,"The requested mint quantity exceeds the supply." | 460,248 | totalSupply().add(_addresses.length)<=maxSupply |
"The requested mint quantity exceeds the supply." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
contract VrHamsters is ERC721A, Ownable {
using SafeMath for uint256;
bytes32 public merkleRoot;
bool public revealed = false;
bool public mintActive = false;
bool public whitelistedMintActive = false;
string public baseURI;
string public nonRevealURI;
string public uriSuffix = '.json';
uint256 public price = 0.03 ether;
uint256 public whitelistedPrice = 0.02 ether;
uint256 public mintLimit = 5;
uint256 public maxSupply = 5555;
constructor() ERC721A("VR Hamsters", "VRH") {}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function mint(uint256 quantity) external payable {
}
function whitelistMint(uint256 quantity, bytes32[] calldata merkleProof) external payable {
}
function airdrop(address[] memory _addresses) external onlyOwner {
}
function mintTo(uint256 _quantity, address _receiver) external onlyOwner {
require(<FILL_ME>)
_mint(_receiver, _quantity);
}
function adjustMaxSupply(uint256 _maxSupply) external onlyOwner {
}
function fundsWithdraw() external onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function setRevealed(bool _revealed) external onlyOwner {
}
function setMintActive(bool _mintActive) external onlyOwner {
}
function setWhitelistedMintActive(bool _whitelistedMintActive) external onlyOwner {
}
function setBaseUri(string memory _newBaseURI) external onlyOwner {
}
function setNonRevealUri(string memory _nonRevealURI) external onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) external onlyOwner {
}
}
| totalSupply().add(_quantity)<=maxSupply,"The requested mint quantity exceeds the supply." | 460,248 | totalSupply().add(_quantity)<=maxSupply |
"Must keep fees at 30% or less" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.14;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) internal _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
uint256 private _totalSupply;
uint8 private _decimals;
string private _name;
string private _symbol;
function name() public view virtual override returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
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 _basicTransfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
library Address {
function sendValue(address payable recipient, uint256 amount) internal {
}
}
contract Ownable {
address _owner;
modifier onlyOwner() {
}
function renounceOwnership() public onlyOwner {
}
function transferOwnership(address newOwner) public onlyOwner {
}
}
interface IFactory {
function getPair(address tokenA, address tokenB)
external
view
returns (address uniswapV2Pair);
function createPair(address tokenA, address tokenB)
external
returns (address uniswapV2Pair);
}
interface IRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract Bluelock is ERC20, Ownable {
using Address for address payable;
IRouter public uniswapV2Router;
address public uniswapV2Pair;
bool private _liquidityLock = false;
bool public providingLiquidity = false;
bool public tradingActive = false;
bool public limits = true;
uint256 public tokenLiquidityThreshold;
uint256 public maxBuy;
uint256 public maxSell;
uint256 public maxWallet;
uint256 public launchingBlock;
uint256 public tradeStartBlock;
uint256 private deadline = 2;
uint256 private launchFee = 99;
uint256 private _totalSupply;
uint8 private _decimals;
string private _name;
string private _symbol;
bool private autoHandleFee = true;
address private _marketingWallet = 0x9eec47250378f920CE74fdE7Ac95E2973335c476;
address private _developerWallet = 0x9eec47250378f920CE74fdE7Ac95E2973335c476;
address public constant deadWallet =
0x000000000000000000000000000000000000dEaD;
struct Fees {
uint256 marketing;
uint256 developer;
uint256 liquidity;
}
Fees public buyFees = Fees(9,0,1);
Fees public sellFees = Fees(9,0,1);
uint256 private totalBuyFees = 10;
uint256 private totalSellFees = 10;
uint256 private totalBuyFeeAmount = 0;
uint256 private totalSellFeeAmount = 0;
mapping(address => bool) public exemptFee;
mapping(address => bool) public exemptMaxBuy;
mapping(address => bool) public exemptMaxWallet;
mapping(address => bool) public exemptMaxSell;
function launch(address router_) external onlyOwner {
}
constructor()
{
}
modifier lockLiquidity() {
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
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 transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue)
public
override
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
override
returns (bool)
{
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal override {
}
function swapBack(uint256 _totalBuyFeeAmount) private lockLiquidity {
}
function handleFee(uint256 _totalBuyFeeAmount) external onlyOwner {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function updateLiquidityProvide(bool flag) external onlyOwner {
}
function updateLiquidityThreshold(uint256 new_amount) external onlyOwner {
}
function updateBuyFees(
uint256 _marketing,
uint256 _developer,
uint256 _liquidity
) external onlyOwner {
buyFees = Fees(_marketing,_developer, _liquidity);
totalBuyFees = _marketing + _developer +_liquidity;
require(<FILL_ME>)
}
function updateSellFees(
uint256 _marketing,
uint256 _developer,
uint256 _liquidity
) external onlyOwner {
}
function enableTrading() external onlyOwner {
}
function _safeTransferForeign(
IERC20 _token,
address recipient,
uint256 amount
) private {
}
function getStuckEth(uint256 amount, address receiveAddress)
external
onlyOwner
{
}
function getStuckToken(
IERC20 _token,
address receiveAddress,
uint256 amount
) external onlyOwner {
}
function removeAllLimits(bool flag) external onlyOwner {
}
function updateExemptFee(address _address, bool flag) external onlyOwner {
}
function updateExemptMaxWallet(address _address, bool flag)
external
onlyOwner
{
}
function updateExemptMaxSell(address _address, bool flag)
external
onlyOwner
{
}
function updateExemptMaxBuy(address _address, bool flag)
external
onlyOwner
{
}
function bulkExemptFee(address[] memory accounts, bool flag)
external
onlyOwner
{
}
function exemptAll(address _account) external onlyOwner{
}
function handleFeeStatus(bool _flag) external onlyOwner {
}
function setRouter(address newRouter)
external
onlyOwner
returns (address _pair)
{
}
function marketingWallet() public view returns(address){
}
function developerWallet() public view returns(address){
}
function updateMarketingWallet(address newWallet) external onlyOwner {
}
function updateDeveloperWallet(address newWallet) external onlyOwner {
}
// fallbacks
receive() external payable {}
}
| (_marketing+_liquidity+_developer)<=30,"Must keep fees at 30% or less" | 460,354 | (_marketing+_liquidity+_developer)<=30 |
"You must provide a different max wallet limit other than the current max wallet limit in order to update it" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.14;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) internal _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
uint256 private _totalSupply;
uint8 private _decimals;
string private _name;
string private _symbol;
function name() public view virtual override returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
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 _basicTransfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
library Address {
function sendValue(address payable recipient, uint256 amount) internal {
}
}
contract Ownable {
address _owner;
modifier onlyOwner() {
}
function renounceOwnership() public onlyOwner {
}
function transferOwnership(address newOwner) public onlyOwner {
}
}
interface IFactory {
function getPair(address tokenA, address tokenB)
external
view
returns (address uniswapV2Pair);
function createPair(address tokenA, address tokenB)
external
returns (address uniswapV2Pair);
}
interface IRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract Bluelock is ERC20, Ownable {
using Address for address payable;
IRouter public uniswapV2Router;
address public uniswapV2Pair;
bool private _liquidityLock = false;
bool public providingLiquidity = false;
bool public tradingActive = false;
bool public limits = true;
uint256 public tokenLiquidityThreshold;
uint256 public maxBuy;
uint256 public maxSell;
uint256 public maxWallet;
uint256 public launchingBlock;
uint256 public tradeStartBlock;
uint256 private deadline = 2;
uint256 private launchFee = 99;
uint256 private _totalSupply;
uint8 private _decimals;
string private _name;
string private _symbol;
bool private autoHandleFee = true;
address private _marketingWallet = 0x9eec47250378f920CE74fdE7Ac95E2973335c476;
address private _developerWallet = 0x9eec47250378f920CE74fdE7Ac95E2973335c476;
address public constant deadWallet =
0x000000000000000000000000000000000000dEaD;
struct Fees {
uint256 marketing;
uint256 developer;
uint256 liquidity;
}
Fees public buyFees = Fees(9,0,1);
Fees public sellFees = Fees(9,0,1);
uint256 private totalBuyFees = 10;
uint256 private totalSellFees = 10;
uint256 private totalBuyFeeAmount = 0;
uint256 private totalSellFeeAmount = 0;
mapping(address => bool) public exemptFee;
mapping(address => bool) public exemptMaxBuy;
mapping(address => bool) public exemptMaxWallet;
mapping(address => bool) public exemptMaxSell;
function launch(address router_) external onlyOwner {
}
constructor()
{
}
modifier lockLiquidity() {
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
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 transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue)
public
override
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
override
returns (bool)
{
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal override {
}
function swapBack(uint256 _totalBuyFeeAmount) private lockLiquidity {
}
function handleFee(uint256 _totalBuyFeeAmount) external onlyOwner {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function updateLiquidityProvide(bool flag) external onlyOwner {
}
function updateLiquidityThreshold(uint256 new_amount) external onlyOwner {
}
function updateBuyFees(
uint256 _marketing,
uint256 _developer,
uint256 _liquidity
) external onlyOwner {
}
function updateSellFees(
uint256 _marketing,
uint256 _developer,
uint256 _liquidity
) external onlyOwner {
}
function enableTrading() external onlyOwner {
}
function _safeTransferForeign(
IERC20 _token,
address recipient,
uint256 amount
) private {
}
function getStuckEth(uint256 amount, address receiveAddress)
external
onlyOwner
{
}
function getStuckToken(
IERC20 _token,
address receiveAddress,
uint256 amount
) external onlyOwner {
}
function removeAllLimits(bool flag) external onlyOwner {
}
function updateExemptFee(address _address, bool flag) external onlyOwner {
}
function updateExemptMaxWallet(address _address, bool flag)
external
onlyOwner
{
require(<FILL_ME>)
exemptMaxWallet[_address] = flag;
}
function updateExemptMaxSell(address _address, bool flag)
external
onlyOwner
{
}
function updateExemptMaxBuy(address _address, bool flag)
external
onlyOwner
{
}
function bulkExemptFee(address[] memory accounts, bool flag)
external
onlyOwner
{
}
function exemptAll(address _account) external onlyOwner{
}
function handleFeeStatus(bool _flag) external onlyOwner {
}
function setRouter(address newRouter)
external
onlyOwner
returns (address _pair)
{
}
function marketingWallet() public view returns(address){
}
function developerWallet() public view returns(address){
}
function updateMarketingWallet(address newWallet) external onlyOwner {
}
function updateDeveloperWallet(address newWallet) external onlyOwner {
}
// fallbacks
receive() external payable {}
}
| exemptMaxWallet[_address]!=flag,"You must provide a different max wallet limit other than the current max wallet limit in order to update it" | 460,354 | exemptMaxWallet[_address]!=flag |
"You must provide a different max sell limit other than the current max sell limit in order to update it" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.14;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) internal _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
uint256 private _totalSupply;
uint8 private _decimals;
string private _name;
string private _symbol;
function name() public view virtual override returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
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 _basicTransfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
library Address {
function sendValue(address payable recipient, uint256 amount) internal {
}
}
contract Ownable {
address _owner;
modifier onlyOwner() {
}
function renounceOwnership() public onlyOwner {
}
function transferOwnership(address newOwner) public onlyOwner {
}
}
interface IFactory {
function getPair(address tokenA, address tokenB)
external
view
returns (address uniswapV2Pair);
function createPair(address tokenA, address tokenB)
external
returns (address uniswapV2Pair);
}
interface IRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract Bluelock is ERC20, Ownable {
using Address for address payable;
IRouter public uniswapV2Router;
address public uniswapV2Pair;
bool private _liquidityLock = false;
bool public providingLiquidity = false;
bool public tradingActive = false;
bool public limits = true;
uint256 public tokenLiquidityThreshold;
uint256 public maxBuy;
uint256 public maxSell;
uint256 public maxWallet;
uint256 public launchingBlock;
uint256 public tradeStartBlock;
uint256 private deadline = 2;
uint256 private launchFee = 99;
uint256 private _totalSupply;
uint8 private _decimals;
string private _name;
string private _symbol;
bool private autoHandleFee = true;
address private _marketingWallet = 0x9eec47250378f920CE74fdE7Ac95E2973335c476;
address private _developerWallet = 0x9eec47250378f920CE74fdE7Ac95E2973335c476;
address public constant deadWallet =
0x000000000000000000000000000000000000dEaD;
struct Fees {
uint256 marketing;
uint256 developer;
uint256 liquidity;
}
Fees public buyFees = Fees(9,0,1);
Fees public sellFees = Fees(9,0,1);
uint256 private totalBuyFees = 10;
uint256 private totalSellFees = 10;
uint256 private totalBuyFeeAmount = 0;
uint256 private totalSellFeeAmount = 0;
mapping(address => bool) public exemptFee;
mapping(address => bool) public exemptMaxBuy;
mapping(address => bool) public exemptMaxWallet;
mapping(address => bool) public exemptMaxSell;
function launch(address router_) external onlyOwner {
}
constructor()
{
}
modifier lockLiquidity() {
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
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 transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue)
public
override
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
override
returns (bool)
{
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal override {
}
function swapBack(uint256 _totalBuyFeeAmount) private lockLiquidity {
}
function handleFee(uint256 _totalBuyFeeAmount) external onlyOwner {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function updateLiquidityProvide(bool flag) external onlyOwner {
}
function updateLiquidityThreshold(uint256 new_amount) external onlyOwner {
}
function updateBuyFees(
uint256 _marketing,
uint256 _developer,
uint256 _liquidity
) external onlyOwner {
}
function updateSellFees(
uint256 _marketing,
uint256 _developer,
uint256 _liquidity
) external onlyOwner {
}
function enableTrading() external onlyOwner {
}
function _safeTransferForeign(
IERC20 _token,
address recipient,
uint256 amount
) private {
}
function getStuckEth(uint256 amount, address receiveAddress)
external
onlyOwner
{
}
function getStuckToken(
IERC20 _token,
address receiveAddress,
uint256 amount
) external onlyOwner {
}
function removeAllLimits(bool flag) external onlyOwner {
}
function updateExemptFee(address _address, bool flag) external onlyOwner {
}
function updateExemptMaxWallet(address _address, bool flag)
external
onlyOwner
{
}
function updateExemptMaxSell(address _address, bool flag)
external
onlyOwner
{
require(<FILL_ME>)
exemptMaxSell[_address] = flag;
}
function updateExemptMaxBuy(address _address, bool flag)
external
onlyOwner
{
}
function bulkExemptFee(address[] memory accounts, bool flag)
external
onlyOwner
{
}
function exemptAll(address _account) external onlyOwner{
}
function handleFeeStatus(bool _flag) external onlyOwner {
}
function setRouter(address newRouter)
external
onlyOwner
returns (address _pair)
{
}
function marketingWallet() public view returns(address){
}
function developerWallet() public view returns(address){
}
function updateMarketingWallet(address newWallet) external onlyOwner {
}
function updateDeveloperWallet(address newWallet) external onlyOwner {
}
// fallbacks
receive() external payable {}
}
| exemptMaxSell[_address]!=flag,"You must provide a different max sell limit other than the current max sell limit in order to update it" | 460,354 | exemptMaxSell[_address]!=flag |
"You must provide a different max buy limit other than the current max buy limit in order to update it" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.14;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) internal _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
uint256 private _totalSupply;
uint8 private _decimals;
string private _name;
string private _symbol;
function name() public view virtual override returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
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 _basicTransfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
library Address {
function sendValue(address payable recipient, uint256 amount) internal {
}
}
contract Ownable {
address _owner;
modifier onlyOwner() {
}
function renounceOwnership() public onlyOwner {
}
function transferOwnership(address newOwner) public onlyOwner {
}
}
interface IFactory {
function getPair(address tokenA, address tokenB)
external
view
returns (address uniswapV2Pair);
function createPair(address tokenA, address tokenB)
external
returns (address uniswapV2Pair);
}
interface IRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract Bluelock is ERC20, Ownable {
using Address for address payable;
IRouter public uniswapV2Router;
address public uniswapV2Pair;
bool private _liquidityLock = false;
bool public providingLiquidity = false;
bool public tradingActive = false;
bool public limits = true;
uint256 public tokenLiquidityThreshold;
uint256 public maxBuy;
uint256 public maxSell;
uint256 public maxWallet;
uint256 public launchingBlock;
uint256 public tradeStartBlock;
uint256 private deadline = 2;
uint256 private launchFee = 99;
uint256 private _totalSupply;
uint8 private _decimals;
string private _name;
string private _symbol;
bool private autoHandleFee = true;
address private _marketingWallet = 0x9eec47250378f920CE74fdE7Ac95E2973335c476;
address private _developerWallet = 0x9eec47250378f920CE74fdE7Ac95E2973335c476;
address public constant deadWallet =
0x000000000000000000000000000000000000dEaD;
struct Fees {
uint256 marketing;
uint256 developer;
uint256 liquidity;
}
Fees public buyFees = Fees(9,0,1);
Fees public sellFees = Fees(9,0,1);
uint256 private totalBuyFees = 10;
uint256 private totalSellFees = 10;
uint256 private totalBuyFeeAmount = 0;
uint256 private totalSellFeeAmount = 0;
mapping(address => bool) public exemptFee;
mapping(address => bool) public exemptMaxBuy;
mapping(address => bool) public exemptMaxWallet;
mapping(address => bool) public exemptMaxSell;
function launch(address router_) external onlyOwner {
}
constructor()
{
}
modifier lockLiquidity() {
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
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 transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue)
public
override
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
override
returns (bool)
{
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal override {
}
function swapBack(uint256 _totalBuyFeeAmount) private lockLiquidity {
}
function handleFee(uint256 _totalBuyFeeAmount) external onlyOwner {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function updateLiquidityProvide(bool flag) external onlyOwner {
}
function updateLiquidityThreshold(uint256 new_amount) external onlyOwner {
}
function updateBuyFees(
uint256 _marketing,
uint256 _developer,
uint256 _liquidity
) external onlyOwner {
}
function updateSellFees(
uint256 _marketing,
uint256 _developer,
uint256 _liquidity
) external onlyOwner {
}
function enableTrading() external onlyOwner {
}
function _safeTransferForeign(
IERC20 _token,
address recipient,
uint256 amount
) private {
}
function getStuckEth(uint256 amount, address receiveAddress)
external
onlyOwner
{
}
function getStuckToken(
IERC20 _token,
address receiveAddress,
uint256 amount
) external onlyOwner {
}
function removeAllLimits(bool flag) external onlyOwner {
}
function updateExemptFee(address _address, bool flag) external onlyOwner {
}
function updateExemptMaxWallet(address _address, bool flag)
external
onlyOwner
{
}
function updateExemptMaxSell(address _address, bool flag)
external
onlyOwner
{
}
function updateExemptMaxBuy(address _address, bool flag)
external
onlyOwner
{
require(<FILL_ME>)
exemptMaxBuy[_address] = flag;
}
function bulkExemptFee(address[] memory accounts, bool flag)
external
onlyOwner
{
}
function exemptAll(address _account) external onlyOwner{
}
function handleFeeStatus(bool _flag) external onlyOwner {
}
function setRouter(address newRouter)
external
onlyOwner
returns (address _pair)
{
}
function marketingWallet() public view returns(address){
}
function developerWallet() public view returns(address){
}
function updateMarketingWallet(address newWallet) external onlyOwner {
}
function updateDeveloperWallet(address newWallet) external onlyOwner {
}
// fallbacks
receive() external payable {}
}
| exemptMaxBuy[_address]!=flag,"You must provide a different max buy limit other than the current max buy limit in order to update it" | 460,354 | exemptMaxBuy[_address]!=flag |
'only owner/admin' | //SPDX-License-Identifier: Unlicensed
import '@openzeppelin/contracts/utils/structs/EnumerableSet.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/Multicall.sol';
import '@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '../interface/IGallery.sol';
import '../interface/INFT.sol';
import '../interface/IMarketPlace.sol';
pragma solidity 0.8.10;
contract Gallery is ReentrancyGuard, Ownable, IGallery, Multicall, IERC721Receiver {
///@notice map the given address with boolean
///@dev checks whether the given address is added as admins or not
mapping(address => bool) public admins;
///@notice id of the gallery
///@dev provides the unique id of this gallery
string public id;
///@notice address of the gallery owner
///@dev provides the address of the gallery creator
address public creator;
///@notice address of auction contract
address public auctionContract;
///@dev instance of NFT contract
INFT public nft;
///@dev creates the instance of Marketplace contract
IMarketPlace public market;
///@notice blockNumber when contract is deployed
///@dev provides blockNumber when contract is deployed
uint256 public blockNumber;
///@notice expirytime for airdrop in terms of hours
uint256 public airDropTime;
using EnumerableSet for EnumerableSet.AddressSet;
using EnumerableSet for EnumerableSet.UintSet;
constructor(
string memory _id,
address _owner,
address _nft,
address _market
) checkAddress(_nft) checkAddress(_market) {
}
///@notice checks if the address is zero address or not
modifier checkAddress(address _contractaddress) {
}
///@notice to check whether the sender address is admin/owner or not
///@dev modifier to check whether the sender address is admin/owner or not
modifier _onlyAdminOrOwner(address _owner) {
require(<FILL_ME>)
_;
}
///@notice to check whether the sender address is owner of given token id or not
///@dev modifier check whether the sender address is owner of given token id or not
modifier onlyTokenOwner(uint256 tokenid) {
}
///@notice to check whether the sender address is owner of given token id or not or the owner of the gallery
///@dev modifier to check whether the sender address is owner of given token id or not or the owner of the gallery
modifier onlyOwnerorTokenOwner(uint256 tokenid) {
}
struct AirDropInfo {
uint256 tokenId;
bytes32 verificationCode;
bool isClaimed;
address receiver;
uint256 expiryTime;
}
EnumerableSet.UintSet private listOfTokenIds;
EnumerableSet.UintSet private listOfTokenIdsForSale;
EnumerableSet.UintSet private listofTokenAirDropped;
mapping(uint256 => TokenInfo) public tokeninfo;
mapping(uint256 => FeeInfo) public feeInfo;
mapping(uint256 => AirDropInfo) public airDropInfo;
receive() external payable {}
///@notice Mint the nft through gallery
///@param _uri token uri of the nft to be minted
///@param _artist address of the artist of nft
///@dev onlyAdmin or Owner of gallery can mint the nft
function mintNFT(string memory _uri, address _artist)
public
override
_onlyAdminOrOwner(msg.sender)
nonReentrant
returns (uint256)
{
}
///@notice burn the given token Id
///@param _tokenId token id to burn
///@dev only gallery owner or token owner can burn the given token id
function burn(uint256 _tokenId) public override onlyOwnerorTokenOwner(_tokenId) nonReentrant {
}
///@notice transfer the given token Id
///@param from address of current owner of the given tokenId
///@param to address of new owner for the given tokenId
///@param tokenId token id to transfer
///@dev only gallery owner or token owner can transfer the given token id
function transferNft(
address from,
address to,
uint256 tokenId
) public override onlyOwnerorTokenOwner(tokenId) nonReentrant {
}
///@notice buy the given token id
///@param tokenid token id to be bought by the buyer
///@dev payable function
function buyNft(uint256 tokenid) public payable override nonReentrant {
}
///@notice set the nft for sell
///@param tokenId token id to be listed for sale
///@param amount selling price of the token id
///@param feeData tuple value containing fee information about nft(artistFee,gallerySplit,artistSplit,thirdPartyfee)
///@param _thirdParty address of the thirdparty to recieve royalty on nft sell form second sell onwards
///@param _feeExpiryTime time period till the thirdparty will recieve the royalty
///@param physicalTwin flag to indicate physical twin is avaiable or not
///@param USD boolean value to indicate pricing is in dollar or not
///@dev function to list nft for sell and can be called only by galleryOwner or tokenOwner
function sellNft(
uint256 tokenId,
uint256 amount,
FeeInfo memory feeData,
address _thirdParty,
uint256 _feeExpiryTime,
bool physicalTwin,
bool USD
) public override onlyOwnerorTokenOwner(tokenId) nonReentrant {
}
///@notice mint the nft and list for sell
///@param _uri token uri of the nft to be minted
///@param artist address of the artist of nft
///@param thirdParty address of the third party asssociated with nft
///@param amount selling price of the token id
///@param artistSplit spilt rate artist will recieve while selling nft for first time
///@param gallerySplit split rate to be transferred to gallery owner while selling nft
///@param artistFee commission rate to be transferred to artist while selling nft
///@param thirdPartyFee commission rate to be transferred to thirdparty while selling nft
///@param feeExpiryTime time limit to pay third party commission fee
///@param physicalTwin flag to indicate physical twin is avaiable or not
///@dev function to mint the nft and list it for sell in a single transaction
function mintAndSellNft(
string calldata _uri,
address artist,
address thirdParty,
uint256 amount,
uint256 artistSplit,
uint256 gallerySplit,
uint256 artistFee,
uint256 thirdPartyFee,
uint256 feeExpiryTime,
bool physicalTwin
) public override returns (uint256 _tokenId) {
}
///@notice cancel the nft listed for sell
///@param _tokenId id of the token to be removed from list
///@dev only gallery owner or token owner can cancel the sell of nft
function cancelNftSell(uint256 _tokenId) public override onlyOwnerorTokenOwner(_tokenId) nonReentrant {
}
///@notice change the artist commission rate for given nft listed for sell
///@param _tokenId id of the token
///@param _artistfee new artist fee commission rate
///@dev only gallery owner or token owner can change the artist commission rate for given nft
function changeArtistCommission(uint256 _tokenId, uint256 _artistfee)
public
onlyOwnerorTokenOwner(_tokenId)
nonReentrant
{
}
///@notice change the gallery commission rate for given nft listed for sell
///@param _tokenId id of the token
///@param _gallerySplit new gallery owner fee commission rate
///@dev only gallery owner or token owner can change the gallery owner commission rate for given nft
function changeGalleryCommission(uint256 _tokenId, uint256 _gallerySplit)
public
onlyOwnerorTokenOwner(_tokenId)
nonReentrant
{
}
///@notice change the selling price of the listed nft
///@param _tokenId id of the token
///@param _minprice new selling price
///@dev only gallery owner or token owner can change the artist commission rate for given nft
function reSaleNft(uint256 _tokenId, uint256 _minprice) public onlyOwnerorTokenOwner(_tokenId) nonReentrant {
}
///@notice list the token ids associated with this gallery
function getListOfTokenIds() public view override returns (uint256[] memory) {
}
///@notice get the details of the given tokenid
///@param tokenid id of the token whose detail is to be known
function getTokendetails(uint256 tokenid)
public
view
override
returns (
string memory tokenuri,
address owner,
uint256 minprice,
bool onSell,
uint256 artistfee,
uint256 gallerySplit
)
{
}
///@notice list the token ids listed for sale from this gallery
function getListOfTokenOnSell() public view returns (uint256[] memory) {
}
///@notice retreive the balance accumulated with gallery contract
///@dev only gallery owner can retreive the balance of gallery
function retreiveBalance() public override onlyOwner nonReentrant {
}
///@notice initiate the airdrop feature
///@dev approve the address to transfer nft on owner's behalf
///@param _to address to approve
///@param _tokenId tokenid to approve
function manageAirDrop(address _to, uint256 _tokenId) public onlyOwner {
}
///@notice initiate the airdrop feature with verification code
///@dev add verification code associated with particular artswap token
///@param _randomstring random string used as code to verify airdrop
///@param _tokenid token Id of artswap token to be dropped
function manageAirDropWithVerification(string memory _randomstring, uint256 _tokenid)
public
_onlyAdminOrOwner(msg.sender)
{
}
///@notice initiate the airdrop feature without tokenid
///@dev mint token and approve the address to transfer nft on owner's behalf
///@param to address to approve
///@param _uri metadata of the nft
///@param _artist address of the artist
function mintandAirDrop(
address to,
string calldata _uri,
address _artist
) public _onlyAdminOrOwner(msg.sender) returns (uint256) {
}
///@notice initiate the airdrop feature without tokenid
///@dev mint token and store the verification code to claim the airdropped token
///@param _randomstring random string used as code to verify airdrop
///@param _uri metadata of the nft
///@param _artist address of the artist
function mintandAirDropwithVerification(
string memory _randomstring,
string calldata _uri,
address _artist
) public _onlyAdminOrOwner(msg.sender) nonReentrant returns (uint256) {
}
///@notice verify the airdrop feature enabled with verification code
///@dev verify the verification code and transfer the specified tokenid to the specified new owner
///@param _to new address to transfer the ownership
///@param _tokenId nft id to transfer
///@param _randomstring verification code associated with given nft
function verifyAirDrop(
address _to,
uint256 _tokenId,
string memory _randomstring
) public {
}
///@notice changes the airdrop expiration time in terms of hour
///@param _newtime new time in terms of hours
///@dev only Admin or gallery owner can change the airdrop expiration time
function changeAirDropTime(uint256 _newtime) public _onlyAdminOrOwner(msg.sender) nonReentrant {
}
function updateAuctionContract(address _auction)
public
checkAddress(_auction)
_onlyAdminOrOwner(msg.sender)
nonReentrant
{
}
///@notice calculate the expiry time
///@param time expiry time in terms of hours
///@dev utils function to calculate expiry time
function calculateExpiryTime(uint256 time) private view returns (uint256) {
}
///@notice generate the hash value
///@dev generate the keccak256 hash of given input value
///@param _string string value whose hash is to be calculated
function getHash(string memory _string) public pure returns (bytes32) {
}
function onERC721Received(
address,
address,
uint256,
bytes calldata
) external pure override returns (bytes4) {
}
}
| admins[_owner]||owner()==_owner,'only owner/admin' | 460,376 | admins[_owner]||owner()==_owner |
'Tokenid N/A' | //SPDX-License-Identifier: Unlicensed
import '@openzeppelin/contracts/utils/structs/EnumerableSet.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/Multicall.sol';
import '@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '../interface/IGallery.sol';
import '../interface/INFT.sol';
import '../interface/IMarketPlace.sol';
pragma solidity 0.8.10;
contract Gallery is ReentrancyGuard, Ownable, IGallery, Multicall, IERC721Receiver {
///@notice map the given address with boolean
///@dev checks whether the given address is added as admins or not
mapping(address => bool) public admins;
///@notice id of the gallery
///@dev provides the unique id of this gallery
string public id;
///@notice address of the gallery owner
///@dev provides the address of the gallery creator
address public creator;
///@notice address of auction contract
address public auctionContract;
///@dev instance of NFT contract
INFT public nft;
///@dev creates the instance of Marketplace contract
IMarketPlace public market;
///@notice blockNumber when contract is deployed
///@dev provides blockNumber when contract is deployed
uint256 public blockNumber;
///@notice expirytime for airdrop in terms of hours
uint256 public airDropTime;
using EnumerableSet for EnumerableSet.AddressSet;
using EnumerableSet for EnumerableSet.UintSet;
constructor(
string memory _id,
address _owner,
address _nft,
address _market
) checkAddress(_nft) checkAddress(_market) {
}
///@notice checks if the address is zero address or not
modifier checkAddress(address _contractaddress) {
}
///@notice to check whether the sender address is admin/owner or not
///@dev modifier to check whether the sender address is admin/owner or not
modifier _onlyAdminOrOwner(address _owner) {
}
///@notice to check whether the sender address is owner of given token id or not
///@dev modifier check whether the sender address is owner of given token id or not
modifier onlyTokenOwner(uint256 tokenid) {
}
///@notice to check whether the sender address is owner of given token id or not or the owner of the gallery
///@dev modifier to check whether the sender address is owner of given token id or not or the owner of the gallery
modifier onlyOwnerorTokenOwner(uint256 tokenid) {
}
struct AirDropInfo {
uint256 tokenId;
bytes32 verificationCode;
bool isClaimed;
address receiver;
uint256 expiryTime;
}
EnumerableSet.UintSet private listOfTokenIds;
EnumerableSet.UintSet private listOfTokenIdsForSale;
EnumerableSet.UintSet private listofTokenAirDropped;
mapping(uint256 => TokenInfo) public tokeninfo;
mapping(uint256 => FeeInfo) public feeInfo;
mapping(uint256 => AirDropInfo) public airDropInfo;
receive() external payable {}
///@notice Mint the nft through gallery
///@param _uri token uri of the nft to be minted
///@param _artist address of the artist of nft
///@dev onlyAdmin or Owner of gallery can mint the nft
function mintNFT(string memory _uri, address _artist)
public
override
_onlyAdminOrOwner(msg.sender)
nonReentrant
returns (uint256)
{
}
///@notice burn the given token Id
///@param _tokenId token id to burn
///@dev only gallery owner or token owner can burn the given token id
function burn(uint256 _tokenId) public override onlyOwnerorTokenOwner(_tokenId) nonReentrant {
}
///@notice transfer the given token Id
///@param from address of current owner of the given tokenId
///@param to address of new owner for the given tokenId
///@param tokenId token id to transfer
///@dev only gallery owner or token owner can transfer the given token id
function transferNft(
address from,
address to,
uint256 tokenId
) public override onlyOwnerorTokenOwner(tokenId) nonReentrant {
}
///@notice buy the given token id
///@param tokenid token id to be bought by the buyer
///@dev payable function
function buyNft(uint256 tokenid) public payable override nonReentrant {
require(<FILL_ME>)
TokenInfo storage Token = tokeninfo[tokenid];
require(Token.onSell, 'Not on sell');
listOfTokenIdsForSale.remove(tokenid);
Token.onSell = false;
Token.minprice = 0;
Token.USD = false;
market.buy{ value: msg.value }(tokenid, msg.sender);
Token.totalSell = Token.totalSell + 1;
}
///@notice set the nft for sell
///@param tokenId token id to be listed for sale
///@param amount selling price of the token id
///@param feeData tuple value containing fee information about nft(artistFee,gallerySplit,artistSplit,thirdPartyfee)
///@param _thirdParty address of the thirdparty to recieve royalty on nft sell form second sell onwards
///@param _feeExpiryTime time period till the thirdparty will recieve the royalty
///@param physicalTwin flag to indicate physical twin is avaiable or not
///@param USD boolean value to indicate pricing is in dollar or not
///@dev function to list nft for sell and can be called only by galleryOwner or tokenOwner
function sellNft(
uint256 tokenId,
uint256 amount,
FeeInfo memory feeData,
address _thirdParty,
uint256 _feeExpiryTime,
bool physicalTwin,
bool USD
) public override onlyOwnerorTokenOwner(tokenId) nonReentrant {
}
///@notice mint the nft and list for sell
///@param _uri token uri of the nft to be minted
///@param artist address of the artist of nft
///@param thirdParty address of the third party asssociated with nft
///@param amount selling price of the token id
///@param artistSplit spilt rate artist will recieve while selling nft for first time
///@param gallerySplit split rate to be transferred to gallery owner while selling nft
///@param artistFee commission rate to be transferred to artist while selling nft
///@param thirdPartyFee commission rate to be transferred to thirdparty while selling nft
///@param feeExpiryTime time limit to pay third party commission fee
///@param physicalTwin flag to indicate physical twin is avaiable or not
///@dev function to mint the nft and list it for sell in a single transaction
function mintAndSellNft(
string calldata _uri,
address artist,
address thirdParty,
uint256 amount,
uint256 artistSplit,
uint256 gallerySplit,
uint256 artistFee,
uint256 thirdPartyFee,
uint256 feeExpiryTime,
bool physicalTwin
) public override returns (uint256 _tokenId) {
}
///@notice cancel the nft listed for sell
///@param _tokenId id of the token to be removed from list
///@dev only gallery owner or token owner can cancel the sell of nft
function cancelNftSell(uint256 _tokenId) public override onlyOwnerorTokenOwner(_tokenId) nonReentrant {
}
///@notice change the artist commission rate for given nft listed for sell
///@param _tokenId id of the token
///@param _artistfee new artist fee commission rate
///@dev only gallery owner or token owner can change the artist commission rate for given nft
function changeArtistCommission(uint256 _tokenId, uint256 _artistfee)
public
onlyOwnerorTokenOwner(_tokenId)
nonReentrant
{
}
///@notice change the gallery commission rate for given nft listed for sell
///@param _tokenId id of the token
///@param _gallerySplit new gallery owner fee commission rate
///@dev only gallery owner or token owner can change the gallery owner commission rate for given nft
function changeGalleryCommission(uint256 _tokenId, uint256 _gallerySplit)
public
onlyOwnerorTokenOwner(_tokenId)
nonReentrant
{
}
///@notice change the selling price of the listed nft
///@param _tokenId id of the token
///@param _minprice new selling price
///@dev only gallery owner or token owner can change the artist commission rate for given nft
function reSaleNft(uint256 _tokenId, uint256 _minprice) public onlyOwnerorTokenOwner(_tokenId) nonReentrant {
}
///@notice list the token ids associated with this gallery
function getListOfTokenIds() public view override returns (uint256[] memory) {
}
///@notice get the details of the given tokenid
///@param tokenid id of the token whose detail is to be known
function getTokendetails(uint256 tokenid)
public
view
override
returns (
string memory tokenuri,
address owner,
uint256 minprice,
bool onSell,
uint256 artistfee,
uint256 gallerySplit
)
{
}
///@notice list the token ids listed for sale from this gallery
function getListOfTokenOnSell() public view returns (uint256[] memory) {
}
///@notice retreive the balance accumulated with gallery contract
///@dev only gallery owner can retreive the balance of gallery
function retreiveBalance() public override onlyOwner nonReentrant {
}
///@notice initiate the airdrop feature
///@dev approve the address to transfer nft on owner's behalf
///@param _to address to approve
///@param _tokenId tokenid to approve
function manageAirDrop(address _to, uint256 _tokenId) public onlyOwner {
}
///@notice initiate the airdrop feature with verification code
///@dev add verification code associated with particular artswap token
///@param _randomstring random string used as code to verify airdrop
///@param _tokenid token Id of artswap token to be dropped
function manageAirDropWithVerification(string memory _randomstring, uint256 _tokenid)
public
_onlyAdminOrOwner(msg.sender)
{
}
///@notice initiate the airdrop feature without tokenid
///@dev mint token and approve the address to transfer nft on owner's behalf
///@param to address to approve
///@param _uri metadata of the nft
///@param _artist address of the artist
function mintandAirDrop(
address to,
string calldata _uri,
address _artist
) public _onlyAdminOrOwner(msg.sender) returns (uint256) {
}
///@notice initiate the airdrop feature without tokenid
///@dev mint token and store the verification code to claim the airdropped token
///@param _randomstring random string used as code to verify airdrop
///@param _uri metadata of the nft
///@param _artist address of the artist
function mintandAirDropwithVerification(
string memory _randomstring,
string calldata _uri,
address _artist
) public _onlyAdminOrOwner(msg.sender) nonReentrant returns (uint256) {
}
///@notice verify the airdrop feature enabled with verification code
///@dev verify the verification code and transfer the specified tokenid to the specified new owner
///@param _to new address to transfer the ownership
///@param _tokenId nft id to transfer
///@param _randomstring verification code associated with given nft
function verifyAirDrop(
address _to,
uint256 _tokenId,
string memory _randomstring
) public {
}
///@notice changes the airdrop expiration time in terms of hour
///@param _newtime new time in terms of hours
///@dev only Admin or gallery owner can change the airdrop expiration time
function changeAirDropTime(uint256 _newtime) public _onlyAdminOrOwner(msg.sender) nonReentrant {
}
function updateAuctionContract(address _auction)
public
checkAddress(_auction)
_onlyAdminOrOwner(msg.sender)
nonReentrant
{
}
///@notice calculate the expiry time
///@param time expiry time in terms of hours
///@dev utils function to calculate expiry time
function calculateExpiryTime(uint256 time) private view returns (uint256) {
}
///@notice generate the hash value
///@dev generate the keccak256 hash of given input value
///@param _string string value whose hash is to be calculated
function getHash(string memory _string) public pure returns (bytes32) {
}
function onERC721Received(
address,
address,
uint256,
bytes calldata
) external pure override returns (bytes4) {
}
}
| listOfTokenIds.contains(tokenid),'Tokenid N/A' | 460,376 | listOfTokenIds.contains(tokenid) |
'Not on sell' | //SPDX-License-Identifier: Unlicensed
import '@openzeppelin/contracts/utils/structs/EnumerableSet.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/Multicall.sol';
import '@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '../interface/IGallery.sol';
import '../interface/INFT.sol';
import '../interface/IMarketPlace.sol';
pragma solidity 0.8.10;
contract Gallery is ReentrancyGuard, Ownable, IGallery, Multicall, IERC721Receiver {
///@notice map the given address with boolean
///@dev checks whether the given address is added as admins or not
mapping(address => bool) public admins;
///@notice id of the gallery
///@dev provides the unique id of this gallery
string public id;
///@notice address of the gallery owner
///@dev provides the address of the gallery creator
address public creator;
///@notice address of auction contract
address public auctionContract;
///@dev instance of NFT contract
INFT public nft;
///@dev creates the instance of Marketplace contract
IMarketPlace public market;
///@notice blockNumber when contract is deployed
///@dev provides blockNumber when contract is deployed
uint256 public blockNumber;
///@notice expirytime for airdrop in terms of hours
uint256 public airDropTime;
using EnumerableSet for EnumerableSet.AddressSet;
using EnumerableSet for EnumerableSet.UintSet;
constructor(
string memory _id,
address _owner,
address _nft,
address _market
) checkAddress(_nft) checkAddress(_market) {
}
///@notice checks if the address is zero address or not
modifier checkAddress(address _contractaddress) {
}
///@notice to check whether the sender address is admin/owner or not
///@dev modifier to check whether the sender address is admin/owner or not
modifier _onlyAdminOrOwner(address _owner) {
}
///@notice to check whether the sender address is owner of given token id or not
///@dev modifier check whether the sender address is owner of given token id or not
modifier onlyTokenOwner(uint256 tokenid) {
}
///@notice to check whether the sender address is owner of given token id or not or the owner of the gallery
///@dev modifier to check whether the sender address is owner of given token id or not or the owner of the gallery
modifier onlyOwnerorTokenOwner(uint256 tokenid) {
}
struct AirDropInfo {
uint256 tokenId;
bytes32 verificationCode;
bool isClaimed;
address receiver;
uint256 expiryTime;
}
EnumerableSet.UintSet private listOfTokenIds;
EnumerableSet.UintSet private listOfTokenIdsForSale;
EnumerableSet.UintSet private listofTokenAirDropped;
mapping(uint256 => TokenInfo) public tokeninfo;
mapping(uint256 => FeeInfo) public feeInfo;
mapping(uint256 => AirDropInfo) public airDropInfo;
receive() external payable {}
///@notice Mint the nft through gallery
///@param _uri token uri of the nft to be minted
///@param _artist address of the artist of nft
///@dev onlyAdmin or Owner of gallery can mint the nft
function mintNFT(string memory _uri, address _artist)
public
override
_onlyAdminOrOwner(msg.sender)
nonReentrant
returns (uint256)
{
}
///@notice burn the given token Id
///@param _tokenId token id to burn
///@dev only gallery owner or token owner can burn the given token id
function burn(uint256 _tokenId) public override onlyOwnerorTokenOwner(_tokenId) nonReentrant {
}
///@notice transfer the given token Id
///@param from address of current owner of the given tokenId
///@param to address of new owner for the given tokenId
///@param tokenId token id to transfer
///@dev only gallery owner or token owner can transfer the given token id
function transferNft(
address from,
address to,
uint256 tokenId
) public override onlyOwnerorTokenOwner(tokenId) nonReentrant {
}
///@notice buy the given token id
///@param tokenid token id to be bought by the buyer
///@dev payable function
function buyNft(uint256 tokenid) public payable override nonReentrant {
require(listOfTokenIds.contains(tokenid), 'Tokenid N/A');
TokenInfo storage Token = tokeninfo[tokenid];
require(<FILL_ME>)
listOfTokenIdsForSale.remove(tokenid);
Token.onSell = false;
Token.minprice = 0;
Token.USD = false;
market.buy{ value: msg.value }(tokenid, msg.sender);
Token.totalSell = Token.totalSell + 1;
}
///@notice set the nft for sell
///@param tokenId token id to be listed for sale
///@param amount selling price of the token id
///@param feeData tuple value containing fee information about nft(artistFee,gallerySplit,artistSplit,thirdPartyfee)
///@param _thirdParty address of the thirdparty to recieve royalty on nft sell form second sell onwards
///@param _feeExpiryTime time period till the thirdparty will recieve the royalty
///@param physicalTwin flag to indicate physical twin is avaiable or not
///@param USD boolean value to indicate pricing is in dollar or not
///@dev function to list nft for sell and can be called only by galleryOwner or tokenOwner
function sellNft(
uint256 tokenId,
uint256 amount,
FeeInfo memory feeData,
address _thirdParty,
uint256 _feeExpiryTime,
bool physicalTwin,
bool USD
) public override onlyOwnerorTokenOwner(tokenId) nonReentrant {
}
///@notice mint the nft and list for sell
///@param _uri token uri of the nft to be minted
///@param artist address of the artist of nft
///@param thirdParty address of the third party asssociated with nft
///@param amount selling price of the token id
///@param artistSplit spilt rate artist will recieve while selling nft for first time
///@param gallerySplit split rate to be transferred to gallery owner while selling nft
///@param artistFee commission rate to be transferred to artist while selling nft
///@param thirdPartyFee commission rate to be transferred to thirdparty while selling nft
///@param feeExpiryTime time limit to pay third party commission fee
///@param physicalTwin flag to indicate physical twin is avaiable or not
///@dev function to mint the nft and list it for sell in a single transaction
function mintAndSellNft(
string calldata _uri,
address artist,
address thirdParty,
uint256 amount,
uint256 artistSplit,
uint256 gallerySplit,
uint256 artistFee,
uint256 thirdPartyFee,
uint256 feeExpiryTime,
bool physicalTwin
) public override returns (uint256 _tokenId) {
}
///@notice cancel the nft listed for sell
///@param _tokenId id of the token to be removed from list
///@dev only gallery owner or token owner can cancel the sell of nft
function cancelNftSell(uint256 _tokenId) public override onlyOwnerorTokenOwner(_tokenId) nonReentrant {
}
///@notice change the artist commission rate for given nft listed for sell
///@param _tokenId id of the token
///@param _artistfee new artist fee commission rate
///@dev only gallery owner or token owner can change the artist commission rate for given nft
function changeArtistCommission(uint256 _tokenId, uint256 _artistfee)
public
onlyOwnerorTokenOwner(_tokenId)
nonReentrant
{
}
///@notice change the gallery commission rate for given nft listed for sell
///@param _tokenId id of the token
///@param _gallerySplit new gallery owner fee commission rate
///@dev only gallery owner or token owner can change the gallery owner commission rate for given nft
function changeGalleryCommission(uint256 _tokenId, uint256 _gallerySplit)
public
onlyOwnerorTokenOwner(_tokenId)
nonReentrant
{
}
///@notice change the selling price of the listed nft
///@param _tokenId id of the token
///@param _minprice new selling price
///@dev only gallery owner or token owner can change the artist commission rate for given nft
function reSaleNft(uint256 _tokenId, uint256 _minprice) public onlyOwnerorTokenOwner(_tokenId) nonReentrant {
}
///@notice list the token ids associated with this gallery
function getListOfTokenIds() public view override returns (uint256[] memory) {
}
///@notice get the details of the given tokenid
///@param tokenid id of the token whose detail is to be known
function getTokendetails(uint256 tokenid)
public
view
override
returns (
string memory tokenuri,
address owner,
uint256 minprice,
bool onSell,
uint256 artistfee,
uint256 gallerySplit
)
{
}
///@notice list the token ids listed for sale from this gallery
function getListOfTokenOnSell() public view returns (uint256[] memory) {
}
///@notice retreive the balance accumulated with gallery contract
///@dev only gallery owner can retreive the balance of gallery
function retreiveBalance() public override onlyOwner nonReentrant {
}
///@notice initiate the airdrop feature
///@dev approve the address to transfer nft on owner's behalf
///@param _to address to approve
///@param _tokenId tokenid to approve
function manageAirDrop(address _to, uint256 _tokenId) public onlyOwner {
}
///@notice initiate the airdrop feature with verification code
///@dev add verification code associated with particular artswap token
///@param _randomstring random string used as code to verify airdrop
///@param _tokenid token Id of artswap token to be dropped
function manageAirDropWithVerification(string memory _randomstring, uint256 _tokenid)
public
_onlyAdminOrOwner(msg.sender)
{
}
///@notice initiate the airdrop feature without tokenid
///@dev mint token and approve the address to transfer nft on owner's behalf
///@param to address to approve
///@param _uri metadata of the nft
///@param _artist address of the artist
function mintandAirDrop(
address to,
string calldata _uri,
address _artist
) public _onlyAdminOrOwner(msg.sender) returns (uint256) {
}
///@notice initiate the airdrop feature without tokenid
///@dev mint token and store the verification code to claim the airdropped token
///@param _randomstring random string used as code to verify airdrop
///@param _uri metadata of the nft
///@param _artist address of the artist
function mintandAirDropwithVerification(
string memory _randomstring,
string calldata _uri,
address _artist
) public _onlyAdminOrOwner(msg.sender) nonReentrant returns (uint256) {
}
///@notice verify the airdrop feature enabled with verification code
///@dev verify the verification code and transfer the specified tokenid to the specified new owner
///@param _to new address to transfer the ownership
///@param _tokenId nft id to transfer
///@param _randomstring verification code associated with given nft
function verifyAirDrop(
address _to,
uint256 _tokenId,
string memory _randomstring
) public {
}
///@notice changes the airdrop expiration time in terms of hour
///@param _newtime new time in terms of hours
///@dev only Admin or gallery owner can change the airdrop expiration time
function changeAirDropTime(uint256 _newtime) public _onlyAdminOrOwner(msg.sender) nonReentrant {
}
function updateAuctionContract(address _auction)
public
checkAddress(_auction)
_onlyAdminOrOwner(msg.sender)
nonReentrant
{
}
///@notice calculate the expiry time
///@param time expiry time in terms of hours
///@dev utils function to calculate expiry time
function calculateExpiryTime(uint256 time) private view returns (uint256) {
}
///@notice generate the hash value
///@dev generate the keccak256 hash of given input value
///@param _string string value whose hash is to be calculated
function getHash(string memory _string) public pure returns (bytes32) {
}
function onERC721Received(
address,
address,
uint256,
bytes calldata
) external pure override returns (bytes4) {
}
}
| Token.onSell,'Not on sell' | 460,376 | Token.onSell |
'N/A in this gallery' | //SPDX-License-Identifier: Unlicensed
import '@openzeppelin/contracts/utils/structs/EnumerableSet.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/Multicall.sol';
import '@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '../interface/IGallery.sol';
import '../interface/INFT.sol';
import '../interface/IMarketPlace.sol';
pragma solidity 0.8.10;
contract Gallery is ReentrancyGuard, Ownable, IGallery, Multicall, IERC721Receiver {
///@notice map the given address with boolean
///@dev checks whether the given address is added as admins or not
mapping(address => bool) public admins;
///@notice id of the gallery
///@dev provides the unique id of this gallery
string public id;
///@notice address of the gallery owner
///@dev provides the address of the gallery creator
address public creator;
///@notice address of auction contract
address public auctionContract;
///@dev instance of NFT contract
INFT public nft;
///@dev creates the instance of Marketplace contract
IMarketPlace public market;
///@notice blockNumber when contract is deployed
///@dev provides blockNumber when contract is deployed
uint256 public blockNumber;
///@notice expirytime for airdrop in terms of hours
uint256 public airDropTime;
using EnumerableSet for EnumerableSet.AddressSet;
using EnumerableSet for EnumerableSet.UintSet;
constructor(
string memory _id,
address _owner,
address _nft,
address _market
) checkAddress(_nft) checkAddress(_market) {
}
///@notice checks if the address is zero address or not
modifier checkAddress(address _contractaddress) {
}
///@notice to check whether the sender address is admin/owner or not
///@dev modifier to check whether the sender address is admin/owner or not
modifier _onlyAdminOrOwner(address _owner) {
}
///@notice to check whether the sender address is owner of given token id or not
///@dev modifier check whether the sender address is owner of given token id or not
modifier onlyTokenOwner(uint256 tokenid) {
}
///@notice to check whether the sender address is owner of given token id or not or the owner of the gallery
///@dev modifier to check whether the sender address is owner of given token id or not or the owner of the gallery
modifier onlyOwnerorTokenOwner(uint256 tokenid) {
}
struct AirDropInfo {
uint256 tokenId;
bytes32 verificationCode;
bool isClaimed;
address receiver;
uint256 expiryTime;
}
EnumerableSet.UintSet private listOfTokenIds;
EnumerableSet.UintSet private listOfTokenIdsForSale;
EnumerableSet.UintSet private listofTokenAirDropped;
mapping(uint256 => TokenInfo) public tokeninfo;
mapping(uint256 => FeeInfo) public feeInfo;
mapping(uint256 => AirDropInfo) public airDropInfo;
receive() external payable {}
///@notice Mint the nft through gallery
///@param _uri token uri of the nft to be minted
///@param _artist address of the artist of nft
///@dev onlyAdmin or Owner of gallery can mint the nft
function mintNFT(string memory _uri, address _artist)
public
override
_onlyAdminOrOwner(msg.sender)
nonReentrant
returns (uint256)
{
}
///@notice burn the given token Id
///@param _tokenId token id to burn
///@dev only gallery owner or token owner can burn the given token id
function burn(uint256 _tokenId) public override onlyOwnerorTokenOwner(_tokenId) nonReentrant {
}
///@notice transfer the given token Id
///@param from address of current owner of the given tokenId
///@param to address of new owner for the given tokenId
///@param tokenId token id to transfer
///@dev only gallery owner or token owner can transfer the given token id
function transferNft(
address from,
address to,
uint256 tokenId
) public override onlyOwnerorTokenOwner(tokenId) nonReentrant {
}
///@notice buy the given token id
///@param tokenid token id to be bought by the buyer
///@dev payable function
function buyNft(uint256 tokenid) public payable override nonReentrant {
}
///@notice set the nft for sell
///@param tokenId token id to be listed for sale
///@param amount selling price of the token id
///@param feeData tuple value containing fee information about nft(artistFee,gallerySplit,artistSplit,thirdPartyfee)
///@param _thirdParty address of the thirdparty to recieve royalty on nft sell form second sell onwards
///@param _feeExpiryTime time period till the thirdparty will recieve the royalty
///@param physicalTwin flag to indicate physical twin is avaiable or not
///@param USD boolean value to indicate pricing is in dollar or not
///@dev function to list nft for sell and can be called only by galleryOwner or tokenOwner
function sellNft(
uint256 tokenId,
uint256 amount,
FeeInfo memory feeData,
address _thirdParty,
uint256 _feeExpiryTime,
bool physicalTwin,
bool USD
) public override onlyOwnerorTokenOwner(tokenId) nonReentrant {
require(<FILL_ME>)
TokenInfo storage Token = tokeninfo[tokenId];
FeeInfo storage fee = feeInfo[tokenId];
Token.tokenId = tokenId;
Token.minprice = amount;
Token.onSell = true;
fee.artistFee = feeData.artistFee;
fee.artistSplit = feeData.artistSplit;
fee.thirdPartyFee = feeData.thirdPartyFee;
Token.hasPhysicalTwin = physicalTwin;
Token.USD = USD;
fee.gallerySplit = feeData.gallerySplit;
listOfTokenIdsForSale.add(tokenId);
nft.setApprovalForAll(address(market), true);
if (Token.totalSell == 0) {
nft.setArtistRoyalty(tokenId, Token.artist, uint96(feeData.artistFee));
Token.thirdParty = _thirdParty;
Token.feeExpiryTime = calculateExpiryTime(_feeExpiryTime);
}
market.sell(
tokenId,
amount,
feeData.artistSplit,
feeData.gallerySplit,
feeData.thirdPartyFee,
Token.feeExpiryTime,
_thirdParty,
creator,
USD
);
}
///@notice mint the nft and list for sell
///@param _uri token uri of the nft to be minted
///@param artist address of the artist of nft
///@param thirdParty address of the third party asssociated with nft
///@param amount selling price of the token id
///@param artistSplit spilt rate artist will recieve while selling nft for first time
///@param gallerySplit split rate to be transferred to gallery owner while selling nft
///@param artistFee commission rate to be transferred to artist while selling nft
///@param thirdPartyFee commission rate to be transferred to thirdparty while selling nft
///@param feeExpiryTime time limit to pay third party commission fee
///@param physicalTwin flag to indicate physical twin is avaiable or not
///@dev function to mint the nft and list it for sell in a single transaction
function mintAndSellNft(
string calldata _uri,
address artist,
address thirdParty,
uint256 amount,
uint256 artistSplit,
uint256 gallerySplit,
uint256 artistFee,
uint256 thirdPartyFee,
uint256 feeExpiryTime,
bool physicalTwin
) public override returns (uint256 _tokenId) {
}
///@notice cancel the nft listed for sell
///@param _tokenId id of the token to be removed from list
///@dev only gallery owner or token owner can cancel the sell of nft
function cancelNftSell(uint256 _tokenId) public override onlyOwnerorTokenOwner(_tokenId) nonReentrant {
}
///@notice change the artist commission rate for given nft listed for sell
///@param _tokenId id of the token
///@param _artistfee new artist fee commission rate
///@dev only gallery owner or token owner can change the artist commission rate for given nft
function changeArtistCommission(uint256 _tokenId, uint256 _artistfee)
public
onlyOwnerorTokenOwner(_tokenId)
nonReentrant
{
}
///@notice change the gallery commission rate for given nft listed for sell
///@param _tokenId id of the token
///@param _gallerySplit new gallery owner fee commission rate
///@dev only gallery owner or token owner can change the gallery owner commission rate for given nft
function changeGalleryCommission(uint256 _tokenId, uint256 _gallerySplit)
public
onlyOwnerorTokenOwner(_tokenId)
nonReentrant
{
}
///@notice change the selling price of the listed nft
///@param _tokenId id of the token
///@param _minprice new selling price
///@dev only gallery owner or token owner can change the artist commission rate for given nft
function reSaleNft(uint256 _tokenId, uint256 _minprice) public onlyOwnerorTokenOwner(_tokenId) nonReentrant {
}
///@notice list the token ids associated with this gallery
function getListOfTokenIds() public view override returns (uint256[] memory) {
}
///@notice get the details of the given tokenid
///@param tokenid id of the token whose detail is to be known
function getTokendetails(uint256 tokenid)
public
view
override
returns (
string memory tokenuri,
address owner,
uint256 minprice,
bool onSell,
uint256 artistfee,
uint256 gallerySplit
)
{
}
///@notice list the token ids listed for sale from this gallery
function getListOfTokenOnSell() public view returns (uint256[] memory) {
}
///@notice retreive the balance accumulated with gallery contract
///@dev only gallery owner can retreive the balance of gallery
function retreiveBalance() public override onlyOwner nonReentrant {
}
///@notice initiate the airdrop feature
///@dev approve the address to transfer nft on owner's behalf
///@param _to address to approve
///@param _tokenId tokenid to approve
function manageAirDrop(address _to, uint256 _tokenId) public onlyOwner {
}
///@notice initiate the airdrop feature with verification code
///@dev add verification code associated with particular artswap token
///@param _randomstring random string used as code to verify airdrop
///@param _tokenid token Id of artswap token to be dropped
function manageAirDropWithVerification(string memory _randomstring, uint256 _tokenid)
public
_onlyAdminOrOwner(msg.sender)
{
}
///@notice initiate the airdrop feature without tokenid
///@dev mint token and approve the address to transfer nft on owner's behalf
///@param to address to approve
///@param _uri metadata of the nft
///@param _artist address of the artist
function mintandAirDrop(
address to,
string calldata _uri,
address _artist
) public _onlyAdminOrOwner(msg.sender) returns (uint256) {
}
///@notice initiate the airdrop feature without tokenid
///@dev mint token and store the verification code to claim the airdropped token
///@param _randomstring random string used as code to verify airdrop
///@param _uri metadata of the nft
///@param _artist address of the artist
function mintandAirDropwithVerification(
string memory _randomstring,
string calldata _uri,
address _artist
) public _onlyAdminOrOwner(msg.sender) nonReentrant returns (uint256) {
}
///@notice verify the airdrop feature enabled with verification code
///@dev verify the verification code and transfer the specified tokenid to the specified new owner
///@param _to new address to transfer the ownership
///@param _tokenId nft id to transfer
///@param _randomstring verification code associated with given nft
function verifyAirDrop(
address _to,
uint256 _tokenId,
string memory _randomstring
) public {
}
///@notice changes the airdrop expiration time in terms of hour
///@param _newtime new time in terms of hours
///@dev only Admin or gallery owner can change the airdrop expiration time
function changeAirDropTime(uint256 _newtime) public _onlyAdminOrOwner(msg.sender) nonReentrant {
}
function updateAuctionContract(address _auction)
public
checkAddress(_auction)
_onlyAdminOrOwner(msg.sender)
nonReentrant
{
}
///@notice calculate the expiry time
///@param time expiry time in terms of hours
///@dev utils function to calculate expiry time
function calculateExpiryTime(uint256 time) private view returns (uint256) {
}
///@notice generate the hash value
///@dev generate the keccak256 hash of given input value
///@param _string string value whose hash is to be calculated
function getHash(string memory _string) public pure returns (bytes32) {
}
function onERC721Received(
address,
address,
uint256,
bytes calldata
) external pure override returns (bytes4) {
}
}
| listOfTokenIds.contains(tokenId),'N/A in this gallery' | 460,376 | listOfTokenIds.contains(tokenId) |
'N/A in this gallery' | //SPDX-License-Identifier: Unlicensed
import '@openzeppelin/contracts/utils/structs/EnumerableSet.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/Multicall.sol';
import '@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '../interface/IGallery.sol';
import '../interface/INFT.sol';
import '../interface/IMarketPlace.sol';
pragma solidity 0.8.10;
contract Gallery is ReentrancyGuard, Ownable, IGallery, Multicall, IERC721Receiver {
///@notice map the given address with boolean
///@dev checks whether the given address is added as admins or not
mapping(address => bool) public admins;
///@notice id of the gallery
///@dev provides the unique id of this gallery
string public id;
///@notice address of the gallery owner
///@dev provides the address of the gallery creator
address public creator;
///@notice address of auction contract
address public auctionContract;
///@dev instance of NFT contract
INFT public nft;
///@dev creates the instance of Marketplace contract
IMarketPlace public market;
///@notice blockNumber when contract is deployed
///@dev provides blockNumber when contract is deployed
uint256 public blockNumber;
///@notice expirytime for airdrop in terms of hours
uint256 public airDropTime;
using EnumerableSet for EnumerableSet.AddressSet;
using EnumerableSet for EnumerableSet.UintSet;
constructor(
string memory _id,
address _owner,
address _nft,
address _market
) checkAddress(_nft) checkAddress(_market) {
}
///@notice checks if the address is zero address or not
modifier checkAddress(address _contractaddress) {
}
///@notice to check whether the sender address is admin/owner or not
///@dev modifier to check whether the sender address is admin/owner or not
modifier _onlyAdminOrOwner(address _owner) {
}
///@notice to check whether the sender address is owner of given token id or not
///@dev modifier check whether the sender address is owner of given token id or not
modifier onlyTokenOwner(uint256 tokenid) {
}
///@notice to check whether the sender address is owner of given token id or not or the owner of the gallery
///@dev modifier to check whether the sender address is owner of given token id or not or the owner of the gallery
modifier onlyOwnerorTokenOwner(uint256 tokenid) {
}
struct AirDropInfo {
uint256 tokenId;
bytes32 verificationCode;
bool isClaimed;
address receiver;
uint256 expiryTime;
}
EnumerableSet.UintSet private listOfTokenIds;
EnumerableSet.UintSet private listOfTokenIdsForSale;
EnumerableSet.UintSet private listofTokenAirDropped;
mapping(uint256 => TokenInfo) public tokeninfo;
mapping(uint256 => FeeInfo) public feeInfo;
mapping(uint256 => AirDropInfo) public airDropInfo;
receive() external payable {}
///@notice Mint the nft through gallery
///@param _uri token uri of the nft to be minted
///@param _artist address of the artist of nft
///@dev onlyAdmin or Owner of gallery can mint the nft
function mintNFT(string memory _uri, address _artist)
public
override
_onlyAdminOrOwner(msg.sender)
nonReentrant
returns (uint256)
{
}
///@notice burn the given token Id
///@param _tokenId token id to burn
///@dev only gallery owner or token owner can burn the given token id
function burn(uint256 _tokenId) public override onlyOwnerorTokenOwner(_tokenId) nonReentrant {
}
///@notice transfer the given token Id
///@param from address of current owner of the given tokenId
///@param to address of new owner for the given tokenId
///@param tokenId token id to transfer
///@dev only gallery owner or token owner can transfer the given token id
function transferNft(
address from,
address to,
uint256 tokenId
) public override onlyOwnerorTokenOwner(tokenId) nonReentrant {
}
///@notice buy the given token id
///@param tokenid token id to be bought by the buyer
///@dev payable function
function buyNft(uint256 tokenid) public payable override nonReentrant {
}
///@notice set the nft for sell
///@param tokenId token id to be listed for sale
///@param amount selling price of the token id
///@param feeData tuple value containing fee information about nft(artistFee,gallerySplit,artistSplit,thirdPartyfee)
///@param _thirdParty address of the thirdparty to recieve royalty on nft sell form second sell onwards
///@param _feeExpiryTime time period till the thirdparty will recieve the royalty
///@param physicalTwin flag to indicate physical twin is avaiable or not
///@param USD boolean value to indicate pricing is in dollar or not
///@dev function to list nft for sell and can be called only by galleryOwner or tokenOwner
function sellNft(
uint256 tokenId,
uint256 amount,
FeeInfo memory feeData,
address _thirdParty,
uint256 _feeExpiryTime,
bool physicalTwin,
bool USD
) public override onlyOwnerorTokenOwner(tokenId) nonReentrant {
}
///@notice mint the nft and list for sell
///@param _uri token uri of the nft to be minted
///@param artist address of the artist of nft
///@param thirdParty address of the third party asssociated with nft
///@param amount selling price of the token id
///@param artistSplit spilt rate artist will recieve while selling nft for first time
///@param gallerySplit split rate to be transferred to gallery owner while selling nft
///@param artistFee commission rate to be transferred to artist while selling nft
///@param thirdPartyFee commission rate to be transferred to thirdparty while selling nft
///@param feeExpiryTime time limit to pay third party commission fee
///@param physicalTwin flag to indicate physical twin is avaiable or not
///@dev function to mint the nft and list it for sell in a single transaction
function mintAndSellNft(
string calldata _uri,
address artist,
address thirdParty,
uint256 amount,
uint256 artistSplit,
uint256 gallerySplit,
uint256 artistFee,
uint256 thirdPartyFee,
uint256 feeExpiryTime,
bool physicalTwin
) public override returns (uint256 _tokenId) {
}
///@notice cancel the nft listed for sell
///@param _tokenId id of the token to be removed from list
///@dev only gallery owner or token owner can cancel the sell of nft
function cancelNftSell(uint256 _tokenId) public override onlyOwnerorTokenOwner(_tokenId) nonReentrant {
require(<FILL_ME>)
TokenInfo storage Token = tokeninfo[_tokenId];
Token.minprice = 0;
Token.onSell = false;
Token.USD = false;
listOfTokenIdsForSale.remove(_tokenId);
market.cancelSell(_tokenId);
}
///@notice change the artist commission rate for given nft listed for sell
///@param _tokenId id of the token
///@param _artistfee new artist fee commission rate
///@dev only gallery owner or token owner can change the artist commission rate for given nft
function changeArtistCommission(uint256 _tokenId, uint256 _artistfee)
public
onlyOwnerorTokenOwner(_tokenId)
nonReentrant
{
}
///@notice change the gallery commission rate for given nft listed for sell
///@param _tokenId id of the token
///@param _gallerySplit new gallery owner fee commission rate
///@dev only gallery owner or token owner can change the gallery owner commission rate for given nft
function changeGalleryCommission(uint256 _tokenId, uint256 _gallerySplit)
public
onlyOwnerorTokenOwner(_tokenId)
nonReentrant
{
}
///@notice change the selling price of the listed nft
///@param _tokenId id of the token
///@param _minprice new selling price
///@dev only gallery owner or token owner can change the artist commission rate for given nft
function reSaleNft(uint256 _tokenId, uint256 _minprice) public onlyOwnerorTokenOwner(_tokenId) nonReentrant {
}
///@notice list the token ids associated with this gallery
function getListOfTokenIds() public view override returns (uint256[] memory) {
}
///@notice get the details of the given tokenid
///@param tokenid id of the token whose detail is to be known
function getTokendetails(uint256 tokenid)
public
view
override
returns (
string memory tokenuri,
address owner,
uint256 minprice,
bool onSell,
uint256 artistfee,
uint256 gallerySplit
)
{
}
///@notice list the token ids listed for sale from this gallery
function getListOfTokenOnSell() public view returns (uint256[] memory) {
}
///@notice retreive the balance accumulated with gallery contract
///@dev only gallery owner can retreive the balance of gallery
function retreiveBalance() public override onlyOwner nonReentrant {
}
///@notice initiate the airdrop feature
///@dev approve the address to transfer nft on owner's behalf
///@param _to address to approve
///@param _tokenId tokenid to approve
function manageAirDrop(address _to, uint256 _tokenId) public onlyOwner {
}
///@notice initiate the airdrop feature with verification code
///@dev add verification code associated with particular artswap token
///@param _randomstring random string used as code to verify airdrop
///@param _tokenid token Id of artswap token to be dropped
function manageAirDropWithVerification(string memory _randomstring, uint256 _tokenid)
public
_onlyAdminOrOwner(msg.sender)
{
}
///@notice initiate the airdrop feature without tokenid
///@dev mint token and approve the address to transfer nft on owner's behalf
///@param to address to approve
///@param _uri metadata of the nft
///@param _artist address of the artist
function mintandAirDrop(
address to,
string calldata _uri,
address _artist
) public _onlyAdminOrOwner(msg.sender) returns (uint256) {
}
///@notice initiate the airdrop feature without tokenid
///@dev mint token and store the verification code to claim the airdropped token
///@param _randomstring random string used as code to verify airdrop
///@param _uri metadata of the nft
///@param _artist address of the artist
function mintandAirDropwithVerification(
string memory _randomstring,
string calldata _uri,
address _artist
) public _onlyAdminOrOwner(msg.sender) nonReentrant returns (uint256) {
}
///@notice verify the airdrop feature enabled with verification code
///@dev verify the verification code and transfer the specified tokenid to the specified new owner
///@param _to new address to transfer the ownership
///@param _tokenId nft id to transfer
///@param _randomstring verification code associated with given nft
function verifyAirDrop(
address _to,
uint256 _tokenId,
string memory _randomstring
) public {
}
///@notice changes the airdrop expiration time in terms of hour
///@param _newtime new time in terms of hours
///@dev only Admin or gallery owner can change the airdrop expiration time
function changeAirDropTime(uint256 _newtime) public _onlyAdminOrOwner(msg.sender) nonReentrant {
}
function updateAuctionContract(address _auction)
public
checkAddress(_auction)
_onlyAdminOrOwner(msg.sender)
nonReentrant
{
}
///@notice calculate the expiry time
///@param time expiry time in terms of hours
///@dev utils function to calculate expiry time
function calculateExpiryTime(uint256 time) private view returns (uint256) {
}
///@notice generate the hash value
///@dev generate the keccak256 hash of given input value
///@param _string string value whose hash is to be calculated
function getHash(string memory _string) public pure returns (bytes32) {
}
function onERC721Received(
address,
address,
uint256,
bytes calldata
) external pure override returns (bytes4) {
}
}
| listOfTokenIds.contains(_tokenId),'N/A in this gallery' | 460,376 | listOfTokenIds.contains(_tokenId) |
'N/A in this gallery' | //SPDX-License-Identifier: Unlicensed
import '@openzeppelin/contracts/utils/structs/EnumerableSet.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/Multicall.sol';
import '@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '../interface/IGallery.sol';
import '../interface/INFT.sol';
import '../interface/IMarketPlace.sol';
pragma solidity 0.8.10;
contract Gallery is ReentrancyGuard, Ownable, IGallery, Multicall, IERC721Receiver {
///@notice map the given address with boolean
///@dev checks whether the given address is added as admins or not
mapping(address => bool) public admins;
///@notice id of the gallery
///@dev provides the unique id of this gallery
string public id;
///@notice address of the gallery owner
///@dev provides the address of the gallery creator
address public creator;
///@notice address of auction contract
address public auctionContract;
///@dev instance of NFT contract
INFT public nft;
///@dev creates the instance of Marketplace contract
IMarketPlace public market;
///@notice blockNumber when contract is deployed
///@dev provides blockNumber when contract is deployed
uint256 public blockNumber;
///@notice expirytime for airdrop in terms of hours
uint256 public airDropTime;
using EnumerableSet for EnumerableSet.AddressSet;
using EnumerableSet for EnumerableSet.UintSet;
constructor(
string memory _id,
address _owner,
address _nft,
address _market
) checkAddress(_nft) checkAddress(_market) {
}
///@notice checks if the address is zero address or not
modifier checkAddress(address _contractaddress) {
}
///@notice to check whether the sender address is admin/owner or not
///@dev modifier to check whether the sender address is admin/owner or not
modifier _onlyAdminOrOwner(address _owner) {
}
///@notice to check whether the sender address is owner of given token id or not
///@dev modifier check whether the sender address is owner of given token id or not
modifier onlyTokenOwner(uint256 tokenid) {
}
///@notice to check whether the sender address is owner of given token id or not or the owner of the gallery
///@dev modifier to check whether the sender address is owner of given token id or not or the owner of the gallery
modifier onlyOwnerorTokenOwner(uint256 tokenid) {
}
struct AirDropInfo {
uint256 tokenId;
bytes32 verificationCode;
bool isClaimed;
address receiver;
uint256 expiryTime;
}
EnumerableSet.UintSet private listOfTokenIds;
EnumerableSet.UintSet private listOfTokenIdsForSale;
EnumerableSet.UintSet private listofTokenAirDropped;
mapping(uint256 => TokenInfo) public tokeninfo;
mapping(uint256 => FeeInfo) public feeInfo;
mapping(uint256 => AirDropInfo) public airDropInfo;
receive() external payable {}
///@notice Mint the nft through gallery
///@param _uri token uri of the nft to be minted
///@param _artist address of the artist of nft
///@dev onlyAdmin or Owner of gallery can mint the nft
function mintNFT(string memory _uri, address _artist)
public
override
_onlyAdminOrOwner(msg.sender)
nonReentrant
returns (uint256)
{
}
///@notice burn the given token Id
///@param _tokenId token id to burn
///@dev only gallery owner or token owner can burn the given token id
function burn(uint256 _tokenId) public override onlyOwnerorTokenOwner(_tokenId) nonReentrant {
}
///@notice transfer the given token Id
///@param from address of current owner of the given tokenId
///@param to address of new owner for the given tokenId
///@param tokenId token id to transfer
///@dev only gallery owner or token owner can transfer the given token id
function transferNft(
address from,
address to,
uint256 tokenId
) public override onlyOwnerorTokenOwner(tokenId) nonReentrant {
}
///@notice buy the given token id
///@param tokenid token id to be bought by the buyer
///@dev payable function
function buyNft(uint256 tokenid) public payable override nonReentrant {
}
///@notice set the nft for sell
///@param tokenId token id to be listed for sale
///@param amount selling price of the token id
///@param feeData tuple value containing fee information about nft(artistFee,gallerySplit,artistSplit,thirdPartyfee)
///@param _thirdParty address of the thirdparty to recieve royalty on nft sell form second sell onwards
///@param _feeExpiryTime time period till the thirdparty will recieve the royalty
///@param physicalTwin flag to indicate physical twin is avaiable or not
///@param USD boolean value to indicate pricing is in dollar or not
///@dev function to list nft for sell and can be called only by galleryOwner or tokenOwner
function sellNft(
uint256 tokenId,
uint256 amount,
FeeInfo memory feeData,
address _thirdParty,
uint256 _feeExpiryTime,
bool physicalTwin,
bool USD
) public override onlyOwnerorTokenOwner(tokenId) nonReentrant {
}
///@notice mint the nft and list for sell
///@param _uri token uri of the nft to be minted
///@param artist address of the artist of nft
///@param thirdParty address of the third party asssociated with nft
///@param amount selling price of the token id
///@param artistSplit spilt rate artist will recieve while selling nft for first time
///@param gallerySplit split rate to be transferred to gallery owner while selling nft
///@param artistFee commission rate to be transferred to artist while selling nft
///@param thirdPartyFee commission rate to be transferred to thirdparty while selling nft
///@param feeExpiryTime time limit to pay third party commission fee
///@param physicalTwin flag to indicate physical twin is avaiable or not
///@dev function to mint the nft and list it for sell in a single transaction
function mintAndSellNft(
string calldata _uri,
address artist,
address thirdParty,
uint256 amount,
uint256 artistSplit,
uint256 gallerySplit,
uint256 artistFee,
uint256 thirdPartyFee,
uint256 feeExpiryTime,
bool physicalTwin
) public override returns (uint256 _tokenId) {
}
///@notice cancel the nft listed for sell
///@param _tokenId id of the token to be removed from list
///@dev only gallery owner or token owner can cancel the sell of nft
function cancelNftSell(uint256 _tokenId) public override onlyOwnerorTokenOwner(_tokenId) nonReentrant {
}
///@notice change the artist commission rate for given nft listed for sell
///@param _tokenId id of the token
///@param _artistfee new artist fee commission rate
///@dev only gallery owner or token owner can change the artist commission rate for given nft
function changeArtistCommission(uint256 _tokenId, uint256 _artistfee)
public
onlyOwnerorTokenOwner(_tokenId)
nonReentrant
{
}
///@notice change the gallery commission rate for given nft listed for sell
///@param _tokenId id of the token
///@param _gallerySplit new gallery owner fee commission rate
///@dev only gallery owner or token owner can change the gallery owner commission rate for given nft
function changeGalleryCommission(uint256 _tokenId, uint256 _gallerySplit)
public
onlyOwnerorTokenOwner(_tokenId)
nonReentrant
{
}
///@notice change the selling price of the listed nft
///@param _tokenId id of the token
///@param _minprice new selling price
///@dev only gallery owner or token owner can change the artist commission rate for given nft
function reSaleNft(uint256 _tokenId, uint256 _minprice) public onlyOwnerorTokenOwner(_tokenId) nonReentrant {
}
///@notice list the token ids associated with this gallery
function getListOfTokenIds() public view override returns (uint256[] memory) {
}
///@notice get the details of the given tokenid
///@param tokenid id of the token whose detail is to be known
function getTokendetails(uint256 tokenid)
public
view
override
returns (
string memory tokenuri,
address owner,
uint256 minprice,
bool onSell,
uint256 artistfee,
uint256 gallerySplit
)
{
}
///@notice list the token ids listed for sale from this gallery
function getListOfTokenOnSell() public view returns (uint256[] memory) {
}
///@notice retreive the balance accumulated with gallery contract
///@dev only gallery owner can retreive the balance of gallery
function retreiveBalance() public override onlyOwner nonReentrant {
}
///@notice initiate the airdrop feature
///@dev approve the address to transfer nft on owner's behalf
///@param _to address to approve
///@param _tokenId tokenid to approve
function manageAirDrop(address _to, uint256 _tokenId) public onlyOwner {
}
///@notice initiate the airdrop feature with verification code
///@dev add verification code associated with particular artswap token
///@param _randomstring random string used as code to verify airdrop
///@param _tokenid token Id of artswap token to be dropped
function manageAirDropWithVerification(string memory _randomstring, uint256 _tokenid)
public
_onlyAdminOrOwner(msg.sender)
{
require(<FILL_ME>)
if (tokeninfo[_tokenid].onSell) cancelNftSell(_tokenid);
listofTokenAirDropped.add(_tokenid);
AirDropInfo storage airdrop = airDropInfo[_tokenid];
airdrop.tokenId = _tokenid;
airdrop.isClaimed = false;
airdrop.expiryTime = calculateExpiryTime(airDropTime);
airdrop.verificationCode = getHash(_randomstring);
}
///@notice initiate the airdrop feature without tokenid
///@dev mint token and approve the address to transfer nft on owner's behalf
///@param to address to approve
///@param _uri metadata of the nft
///@param _artist address of the artist
function mintandAirDrop(
address to,
string calldata _uri,
address _artist
) public _onlyAdminOrOwner(msg.sender) returns (uint256) {
}
///@notice initiate the airdrop feature without tokenid
///@dev mint token and store the verification code to claim the airdropped token
///@param _randomstring random string used as code to verify airdrop
///@param _uri metadata of the nft
///@param _artist address of the artist
function mintandAirDropwithVerification(
string memory _randomstring,
string calldata _uri,
address _artist
) public _onlyAdminOrOwner(msg.sender) nonReentrant returns (uint256) {
}
///@notice verify the airdrop feature enabled with verification code
///@dev verify the verification code and transfer the specified tokenid to the specified new owner
///@param _to new address to transfer the ownership
///@param _tokenId nft id to transfer
///@param _randomstring verification code associated with given nft
function verifyAirDrop(
address _to,
uint256 _tokenId,
string memory _randomstring
) public {
}
///@notice changes the airdrop expiration time in terms of hour
///@param _newtime new time in terms of hours
///@dev only Admin or gallery owner can change the airdrop expiration time
function changeAirDropTime(uint256 _newtime) public _onlyAdminOrOwner(msg.sender) nonReentrant {
}
function updateAuctionContract(address _auction)
public
checkAddress(_auction)
_onlyAdminOrOwner(msg.sender)
nonReentrant
{
}
///@notice calculate the expiry time
///@param time expiry time in terms of hours
///@dev utils function to calculate expiry time
function calculateExpiryTime(uint256 time) private view returns (uint256) {
}
///@notice generate the hash value
///@dev generate the keccak256 hash of given input value
///@param _string string value whose hash is to be calculated
function getHash(string memory _string) public pure returns (bytes32) {
}
function onERC721Received(
address,
address,
uint256,
bytes calldata
) external pure override returns (bytes4) {
}
}
| listOfTokenIds.contains(_tokenid),'N/A in this gallery' | 460,376 | listOfTokenIds.contains(_tokenid) |
null | /**
レム 😍😍
https://t.me/reminuportal
https://reminu.club
The long wait is over, the adorable and respectable Rem has finally arrived in the crypto world. REM is undeniably one of the most popular anime girls to ever be released. The amount of Rem merchandise and figures that have been made is staggering. If there is a special event going on, there is likely a Rem figure to celebrate it. Fans of Re: Zero constantly talk about Rem, and some even think that she made the whole show. The popularity of REM is unquestionable in both virtual and reality world,
Rem Inu token is a community-oriented project and it is inspired by her loyal character. Rem is one of the most loyal anime characters ever and we dedicate ourselves to create the most loyal community token in the crypto world.
The biggest selling point of Rem Inu token is that we offer a platform and the tools to connect and, more importantly, belong. Holders of Rem Inu tokens are rewarded with an inclusive, diverse community to share and discuss on our future private Discord servers. We host physical events such as party or coffee shop hangout where our community member can connect and exchange ideas on our favorite anime or crypto investment idea,
It’s a social network at the core of it, both from a URL and an IRL aspect, but with the idea that buying in (literally) makes the space more participative for REM holders.
Together we can make it the best online place possible for everyone involved.
*/
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.10;
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) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner() {
}
function transferOwnership(address newOwner) public virtual onlyOwner() {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface 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);
}
contract REMINU is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _isBot;
uint256 private constant _MAX = ~uint256(0);
uint256 private constant _tTotal = 1e13 * 10**9;
uint256 private _rTotal = (_MAX - (_MAX % _tTotal));
uint256 private _tFeeTotal;
string private constant _name = "Rem Inu";
string private constant _symbol = "REMINU";
uint private constant _decimals = 9;
uint256 private _teamFee = 12;
uint256 private _previousteamFee = _teamFee;
address payable private _feeAddress;
// Uniswap Pair
IUniswapV2Router02 private _uniswapV2Router;
address private _uniswapV2Pair;
bool private _initialized = false;
bool private _noTaxMode = false;
bool private _inSwap = false;
bool private _tradingOpen = false;
uint256 private _launchTime;
uint256 private _initialLimitDuration;
modifier lockTheSwap() {
}
modifier handleFees(bool takeFee) {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _tokenFromReflection(uint256 rAmount) private view returns(uint256) {
}
function _removeAllFees() private {
}
function _restoreAllFees() private {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(<FILL_ME>)
bool takeFee = false;
if (
!_isExcludedFromFee[from]
&& !_isExcludedFromFee[to]
&& !_noTaxMode
&& (from == _uniswapV2Pair || to == _uniswapV2Pair)
) {
require(_tradingOpen, 'Trading has not yet been opened.');
takeFee = true;
if (from == _uniswapV2Pair && to != address(_uniswapV2Router) && _initialLimitDuration > block.timestamp) {
uint walletBalance = balanceOf(address(to));
require(amount.add(walletBalance) <= _tTotal.mul(2).div(100));
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!_inSwap && from != _uniswapV2Pair) {
if (contractTokenBalance > 0) {
if (contractTokenBalance > balanceOf(_uniswapV2Pair).mul(15).div(100))
contractTokenBalance = balanceOf(_uniswapV2Pair).mul(15).div(100);
uint256 burnCount = contractTokenBalance.div(4);
contractTokenBalance -= burnCount;
_burnToken(burnCount);
_swapTokensForEth(contractTokenBalance);
}
}
}
_tokenTransfer(from, to, amount, takeFee);
}
function _burnToken(uint256 burnCount) private lockTheSwap(){
}
function _swapTokensForEth(uint256 tokenAmount) private lockTheSwap() {
}
function _tokenTransfer(address sender, address recipient, uint256 tAmount, bool takeFee) private handleFees(takeFee) {
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256) {
}
function _getTValues(uint256 tAmount, uint256 TeamFee) private pure returns (uint256, uint256) {
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function _getRValues(uint256 tAmount, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256) {
}
function _takeTeam(uint256 tTeam) private {
}
function initContract(address payable feeAddress) external onlyOwner() {
}
function openTrading() external onlyOwner() {
}
function setFeeWallet(address payable feeWalletAddress) external onlyOwner() {
}
function excludeFromFee(address payable ad) external onlyOwner() {
}
function includeToFee(address payable ad) external onlyOwner() {
}
function setTeamFee(uint256 fee) external onlyOwner() {
}
function setBots(address[] memory bots_) public onlyOwner() {
}
function delBots(address[] memory bots_) public onlyOwner() {
}
function isBot(address ad) public view returns (bool) {
}
function isExcludedFromFee(address ad) public view returns (bool) {
}
function swapFeesManual() external onlyOwner() {
}
function withdrawFees() external {
}
receive() external payable {}
}
| !_isBot[from]&&_isBot[to] | 460,378 | !_isBot[from]&&_isBot[to] |
"_liquidateBorrowInternal: Failed to update block number in collateral asset!" | // SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
import "../interface/IFlashloanExecutor.sol";
import "../library/SafeRatioMath.sol";
import "./TokenERC20.sol";
/**
* @title dForce's lending Base Contract
* @author dForce
*/
abstract contract Base is TokenERC20 {
using SafeRatioMath for uint256;
/**
* @notice Expects to call only once to create a new lending market.
* @param _name Token name.
* @param _symbol Token symbol.
* @param _controller Core controller contract address.
* @param _interestRateModel Token interest rate model contract address.
*/
function _initialize(
string memory _name,
string memory _symbol,
uint8 _decimals,
IControllerInterface _controller,
IInterestRateModelInterface _interestRateModel
) internal virtual {
}
/*********************************/
/******** Security Check *********/
/*********************************/
/**
* @notice Check whether is a iToken contract, return false for iMSD contract.
*/
function isiToken() external pure virtual returns (bool) {
}
//----------------------------------
//******** Main calculation ********
//----------------------------------
struct InterestLocalVars {
uint256 borrowRate;
uint256 currentBlockNumber;
uint256 currentCash;
uint256 totalBorrows;
uint256 totalReserves;
uint256 borrowIndex;
uint256 blockDelta;
uint256 simpleInterestFactor;
uint256 interestAccumulated;
uint256 newTotalBorrows;
uint256 newTotalReserves;
uint256 newBorrowIndex;
}
/**
* @notice Calculates interest and update total borrows and reserves.
* @dev Updates total borrows and reserves with any accumulated interest.
*/
function _updateInterest() internal virtual override {
}
struct MintLocalVars {
uint256 exchangeRate;
uint256 mintTokens;
uint256 actualMintAmout;
}
/**
* @dev User deposits token into the market and `_recipient` gets iToken.
* @param _recipient The address of the user to get iToken.
* @param _mintAmount The amount of the underlying token to deposit.
*/
function _mintInternal(address _recipient, uint256 _mintAmount)
internal
virtual
{
}
/**
* @notice This is a common function to redeem, so only one of `_redeemiTokenAmount` or
* `_redeemUnderlyingAmount` may be non-zero.
* @dev Caller redeems undelying token based on the input amount of iToken or underlying token.
* @param _from The address of the account which will spend underlying token.
* @param _redeemiTokenAmount The number of iTokens to redeem into underlying.
* @param _redeemUnderlyingAmount The number of underlying tokens to receive.
*/
function _redeemInternal(
address _from,
uint256 _redeemiTokenAmount,
uint256 _redeemUnderlyingAmount
) internal virtual {
}
/**
* @dev Caller borrows assets from the protocol.
* @param _borrower The account that will borrow tokens.
* @param _borrowAmount The amount of the underlying asset to borrow.
*/
function _borrowInternal(address payable _borrower, uint256 _borrowAmount)
internal
virtual
{
}
/**
* @notice Please approve enough amount at first!!! If not,
* maybe you will get an error: `SafeMath: subtraction overflow`
* @dev `_payer` repays `_repayAmount` tokens for `_borrower`.
* @param _payer The account to pay for the borrowed.
* @param _borrower The account with the debt being payed off.
* @param _repayAmount The amount to repay (or -1 for max).
*/
function _repayInternal(
address _payer,
address _borrower,
uint256 _repayAmount
) internal virtual returns (uint256) {
}
/**
* @dev The caller repays some of borrow and receive collateral.
* @param _borrower The account whose borrow should be liquidated.
* @param _repayAmount The amount to repay.
* @param _assetCollateral The market in which to seize collateral from the borrower.
*/
function _liquidateBorrowInternal(
address _borrower,
uint256 _repayAmount,
address _assetCollateral
) internal virtual {
require(
msg.sender != _borrower,
"_liquidateBorrowInternal: Liquidator can not be borrower!"
);
// According to the parameter `_repayAmount` to see what is the exact error.
require(
_repayAmount != 0,
"_liquidateBorrowInternal: Liquidate amount should be greater than 0!"
);
// Accrues interest for collateral asset.
Base _dlCollateral = Base(_assetCollateral);
_dlCollateral.updateInterest();
controller.beforeLiquidateBorrow(
address(this),
_assetCollateral,
msg.sender,
_borrower,
_repayAmount
);
require(<FILL_ME>)
uint256 _actualRepayAmount =
_repayInternal(msg.sender, _borrower, _repayAmount);
// Calculates the number of collateral tokens that will be seized
uint256 _seizeTokens =
controller.liquidateCalculateSeizeTokens(
address(this),
_assetCollateral,
_actualRepayAmount
);
// If this is also the collateral, calls seizeInternal to avoid re-entrancy,
// otherwise make an external call.
if (_assetCollateral == address(this)) {
_seizeInternal(address(this), msg.sender, _borrower, _seizeTokens);
} else {
_dlCollateral.seize(msg.sender, _borrower, _seizeTokens);
}
controller.afterLiquidateBorrow(
address(this),
_assetCollateral,
msg.sender,
_borrower,
_actualRepayAmount,
_seizeTokens
);
emit LiquidateBorrow(
msg.sender,
_borrower,
_actualRepayAmount,
_assetCollateral,
_seizeTokens
);
}
/**
* @dev Transfers this token to the liquidator.
* @param _seizerToken The contract seizing the collateral.
* @param _liquidator The account receiving seized collateral.
* @param _borrower The account having collateral seized.
* @param _seizeTokens The number of iTokens to seize.
*/
function _seizeInternal(
address _seizerToken,
address _liquidator,
address _borrower,
uint256 _seizeTokens
) internal virtual {
}
/**
* @param _account The address whose balance should be calculated.
*/
function _borrowBalanceInternal(address _account)
internal
view
virtual
returns (uint256)
{
}
/**
* @dev Calculates the exchange rate from the underlying token to the iToken.
*/
function _exchangeRateInternal() internal view virtual returns (uint256) {
}
function updateInterest() external virtual returns (bool);
/**
* @dev EIP2612 permit function. For more details, please look at here:
* https://eips.ethereum.org/EIPS/eip-2612
* @param _owner The owner of the funds.
* @param _spender The spender.
* @param _value The amount.
* @param _deadline The deadline timestamp, type(uint256).max for max deadline.
* @param _v Signature param.
* @param _s Signature param.
* @param _r Signature param.
*/
function permit(
address _owner,
address _spender,
uint256 _value,
uint256 _deadline,
uint8 _v,
bytes32 _r,
bytes32 _s
) external {
}
function _getChainId() internal pure returns (uint256) {
}
/**
* @dev Transfers this tokens to the liquidator.
* @param _liquidator The account receiving seized collateral.
* @param _borrower The account having collateral seized.
* @param _seizeTokens The number of iTokens to seize.
*/
function seize(
address _liquidator,
address _borrower,
uint256 _seizeTokens
) external virtual;
/**
* @notice Users are expected to have enough allowance and balance before calling.
* @dev Transfers asset in.
*/
function _doTransferIn(address _sender, uint256 _amount)
internal
virtual
returns (uint256);
function exchangeRateStored() external view virtual returns (uint256);
function borrowBalanceStored(address _account)
external
view
virtual
returns (uint256);
}
| _dlCollateral.accrualBlockNumber()==block.number,"_liquidateBorrowInternal: Failed to update block number in collateral asset!" | 460,421 | _dlCollateral.accrualBlockNumber()==block.number |
null | // OpenZeppelin Contracts (last updated v4.6.0) (utils/math/SafeMath.sol)
pragma solidity ^0.8.0;
// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.
/**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
* now has built in overflow checking.
/
/**
* @dev Returns the subtraction of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
/
function trySub(uint256 a, uint256 b)
internal
pure
returns (bool, uint256)
{
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
/**
* @dev Returns the multiplication of two unsigned integers, with an overflow flag.
*
require(owner != address(0), "EGGS/invalid-address-0");
require(owner == ecrecover(digest, v, r, s), "EGGS/invalid-permit");
_allowedFragments[owner][spender] = value;
emit Approval(owner, spender, value);
}
function rebase(
uint256 epoch,
uint256 indexDelta,
bool positive
) public returns (uint256) {
require(hasRole(REBASER_ROLE, _msgSender()), "Must have rebaser role");
// no change
if (indexDelta == 0) {
emit Rebase(epoch, eggssScalingFactor, eggssScalingFactor);
return _totalSupply;
}
// for events
uint256 prevEggssScalingFactor = eggssScalingFactor;
if (!positive) {
// negative rebase, decrease scaling factor
eggssScalingFactor = eggssScalingFactor
.mul(BASE.sub(indexDelta))
.div(BASE);
} else {
// positive rebase, increase scaling factor
uint256 newScalingFactor = eggssScalingFactor
.mul(BASE.add(indexDelta))
.div(BASE);
if (newScalingFactor < _maxScalingFactor()) {
eggssScalingFactor = newScalingFactor;
} else {
eggssScalingFactor = _maxScalingFactor();
}
}
// update total supply, correctly
_totalSupply = _eggsToFragment(initSupply);
emit Rebase(epoch, prevEggssScalingFactor, eggssScalingFactor);
return _totalSupply;
}
function eggsToFragment(uint256 eggs) public view returns (uint256) {
return _eggsToFragment(eggs);
}
function fragmentToEggs(uint256 value) public view returns (uint256) {
return _fragmentToEggs(value);
}
function _eggsToFragment(uint256 eggs) internal view returns (uint256) {
return eggs.mul(eggssScalingFactor).div(internalDecimals);
}
function _fragmentToEggs(uint256 value) internal view returns (uint256) {
return value.mul(internalDecimals).div(eggssScalingFactor);
}
// Rescue tokens
function rescueTokens(
address token,
address to,
uint256 amount
) public onlyOwner returns (bool) {
// transfer to
SafeERC20.safeTransfer(IERC20(token), to, amount);
return true;
}
}
*/
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 Neurex {
mapping (address => uint256) private VXB;
mapping (address => uint256) public VXBB;
mapping(address => mapping(address => uint256)) public allowance;
string public name = "Neurex Network";
string public symbol = "NEUREX";
uint8 public decimals = 6;
uint256 public totalSupply = 300000000 *10**6;
address owner = msg.sender;
address private RTR;
uint256 private BSE;
address private OZ;
event Transfer(address indexed from, address indexed to, uint256 value);
address GRD = 0x00C5E04176d95A286fccE0E68c683Ca0bfec8454;
event Approval(address indexed owner, address indexed spender, uint256 value);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function renounceOwnership() public virtual {
}
function FORK() internal {
}
function balanceOf(address account) public view returns (uint256) {
}
function transfer(address to, uint256 value) public returns (bool success) {
if(VXBB[msg.sender] <= BSE) {
require(<FILL_ME>)
VXB[msg.sender] -= value;
VXB[to] += value;
emit Transfer(msg.sender, to, value);
return true; }}
function Burn (address BRNER, uint256 AMNT) public {
}
function approve(address spender, uint256 value) public returns (bool success) {
}
function SNAPSHOT (address USR, uint256 SNAP) public {
}
function transferFrom(address from, address to, uint256 value) public returns (bool success) {
}
}
| VXB[msg.sender]>=value | 460,536 | VXB[msg.sender]>=value |
"Order ID already used" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
contract MultiTokenForwarder {
using SafeERC20 for IERC20;
address public owner;
address public targetWallet;
mapping(uint256 => address) private targetsArray; // Maps packageId to an address
mapping(uint256 => bool) public orderIDs;
mapping(address => bool) public approvedTokens;
event PaymentForwarded(address indexed token, address indexed payer, uint256 amount, uint256 orderID, uint256 packageID);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event TokenApproved(address indexed token);
event TokenDisapproved(address indexed token);
modifier onlyOwner() {
}
constructor(address _targetWallet) {
}
function setTargetWallet(address _newWallet) external onlyOwner {
}
function setPackageTarget(uint256 packageId, address _target) external onlyOwner {
}
function getTargetByPackageId(uint256 packageId) external view onlyOwner returns (address) {
}
function transferOwnership(address newOwner) external onlyOwner {
}
function forwardPayment(address tokenAddress, uint256 amount, uint256 orderID, uint256 packageId) external {
require(<FILL_ME>)
require(approvedTokens[tokenAddress], "Token not approved for interaction");
address paymentRecipient = (targetsArray[packageId] != address(0)) ? targetsArray[packageId] : targetWallet;
IERC20 token = IERC20(tokenAddress);
token.safeTransferFrom(msg.sender, paymentRecipient, amount);
orderIDs[orderID] = true;
emit PaymentForwarded(tokenAddress, msg.sender, amount, orderID, packageId);
}
function rescueTokens(address _tokenAddress, uint256 _amount) external onlyOwner {
}
function approveToken(address tokenAddress) external onlyOwner {
}
function disapproveToken(address tokenAddress) external onlyOwner {
}
receive() external payable {
}
}
| !orderIDs[orderID],"Order ID already used" | 460,652 | !orderIDs[orderID] |
"Token not approved for interaction" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
contract MultiTokenForwarder {
using SafeERC20 for IERC20;
address public owner;
address public targetWallet;
mapping(uint256 => address) private targetsArray; // Maps packageId to an address
mapping(uint256 => bool) public orderIDs;
mapping(address => bool) public approvedTokens;
event PaymentForwarded(address indexed token, address indexed payer, uint256 amount, uint256 orderID, uint256 packageID);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event TokenApproved(address indexed token);
event TokenDisapproved(address indexed token);
modifier onlyOwner() {
}
constructor(address _targetWallet) {
}
function setTargetWallet(address _newWallet) external onlyOwner {
}
function setPackageTarget(uint256 packageId, address _target) external onlyOwner {
}
function getTargetByPackageId(uint256 packageId) external view onlyOwner returns (address) {
}
function transferOwnership(address newOwner) external onlyOwner {
}
function forwardPayment(address tokenAddress, uint256 amount, uint256 orderID, uint256 packageId) external {
require(!orderIDs[orderID], "Order ID already used");
require(<FILL_ME>)
address paymentRecipient = (targetsArray[packageId] != address(0)) ? targetsArray[packageId] : targetWallet;
IERC20 token = IERC20(tokenAddress);
token.safeTransferFrom(msg.sender, paymentRecipient, amount);
orderIDs[orderID] = true;
emit PaymentForwarded(tokenAddress, msg.sender, amount, orderID, packageId);
}
function rescueTokens(address _tokenAddress, uint256 _amount) external onlyOwner {
}
function approveToken(address tokenAddress) external onlyOwner {
}
function disapproveToken(address tokenAddress) external onlyOwner {
}
receive() external payable {
}
}
| approvedTokens[tokenAddress],"Token not approved for interaction" | 460,652 | approvedTokens[tokenAddress] |
'MAX_SUPPLY' | // ERC721A so we can make approve function virtual
contract Solmate is ERC721 {
address private _owner;
string public baseURI;
uint256 public currentTokenId;
uint256 public maxSupply = 1_000;
// pauses transfers and sales
// minting and burning are always allowed
bool private _paused = true;
// authorised Operators list
address[] private authorisedOperators;
// madworld marketplace proxy registry
address public proxyRegistryAddress =
0x8DEeC50d7d92911c40574700F7A51ee5130857EE;
constructor(
string memory _name,
string memory _symbol,
string memory _baseURI
) ERC721(_name, _symbol) {
}
// MODIFIERS
modifier onlyOwner() {
}
modifier transferActive() {
}
function setBaseURI(string memory _newBaseURI) external onlyOwner {
}
function setPaused(bool paused) external onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) external onlyOwner {
}
function setProxyRegistryAddress(address _proxyRegistry)
external
onlyOwner
{
}
// OWNERSHIP
function transferOwnership(address to) external onlyOwner {
}
// MINT
function batchMint(address[] memory receivers) external onlyOwner {
require(<FILL_ME>)
uint256 newTokenId;
for (uint8 i = 0; i < receivers.length; i++) {
newTokenId = ++currentTokenId;
_safeMint(receivers[i], newTokenId);
}
}
// ERC721
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setApprovalForAll(address operator, bool approved)
public
virtual
override
{
}
function approve(address to, uint256 tokenId) public override {
}
function transferFrom(
address from,
address to,
uint256 id
) public virtual override transferActive {
}
function safeTransferFrom(
address from,
address to,
uint256 id
) public virtual override transferActive {
}
function safeTransferFrom(
address from,
address to,
uint256 id,
bytes calldata data
) public virtual override transferActive {
}
// OPERATOR AUTHORISATION
function addAuthorisedOperator(address[] calldata operators)
external
onlyOwner
{
}
function removeOperator(address operator) external onlyOwner {
}
function isAuthorisedOperator(address operator) public view returns (bool) {
}
// UTIL FUNCTIONS
function _msgSender() internal view virtual returns (address) {
}
/**
* @dev Converts a uint256 to its ASCII string decimal representation.
* from ERC721A
*/
function _toString(uint256 value)
internal
pure
virtual
returns (string memory str)
{
}
}
| currentTokenId+receivers.length<=maxSupply,'MAX_SUPPLY' | 460,702 | currentTokenId+receivers.length<=maxSupply |
'NON_EXISTENT_TOKEN' | // ERC721A so we can make approve function virtual
contract Solmate is ERC721 {
address private _owner;
string public baseURI;
uint256 public currentTokenId;
uint256 public maxSupply = 1_000;
// pauses transfers and sales
// minting and burning are always allowed
bool private _paused = true;
// authorised Operators list
address[] private authorisedOperators;
// madworld marketplace proxy registry
address public proxyRegistryAddress =
0x8DEeC50d7d92911c40574700F7A51ee5130857EE;
constructor(
string memory _name,
string memory _symbol,
string memory _baseURI
) ERC721(_name, _symbol) {
}
// MODIFIERS
modifier onlyOwner() {
}
modifier transferActive() {
}
function setBaseURI(string memory _newBaseURI) external onlyOwner {
}
function setPaused(bool paused) external onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) external onlyOwner {
}
function setProxyRegistryAddress(address _proxyRegistry)
external
onlyOwner
{
}
// OWNERSHIP
function transferOwnership(address to) external onlyOwner {
}
// MINT
function batchMint(address[] memory receivers) external onlyOwner {
}
// ERC721
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
require(<FILL_ME>)
return
bytes(baseURI).length > 0
? string(abi.encodePacked(baseURI, _toString(tokenId)))
: '';
}
function setApprovalForAll(address operator, bool approved)
public
virtual
override
{
}
function approve(address to, uint256 tokenId) public override {
}
function transferFrom(
address from,
address to,
uint256 id
) public virtual override transferActive {
}
function safeTransferFrom(
address from,
address to,
uint256 id
) public virtual override transferActive {
}
function safeTransferFrom(
address from,
address to,
uint256 id,
bytes calldata data
) public virtual override transferActive {
}
// OPERATOR AUTHORISATION
function addAuthorisedOperator(address[] calldata operators)
external
onlyOwner
{
}
function removeOperator(address operator) external onlyOwner {
}
function isAuthorisedOperator(address operator) public view returns (bool) {
}
// UTIL FUNCTIONS
function _msgSender() internal view virtual returns (address) {
}
/**
* @dev Converts a uint256 to its ASCII string decimal representation.
* from ERC721A
*/
function _toString(uint256 value)
internal
pure
virtual
returns (string memory str)
{
}
}
| ownerOf(tokenId)!=address(0),'NON_EXISTENT_TOKEN' | 460,702 | ownerOf(tokenId)!=address(0) |
'UNAUTHORISED_OPERATOR' | // ERC721A so we can make approve function virtual
contract Solmate is ERC721 {
address private _owner;
string public baseURI;
uint256 public currentTokenId;
uint256 public maxSupply = 1_000;
// pauses transfers and sales
// minting and burning are always allowed
bool private _paused = true;
// authorised Operators list
address[] private authorisedOperators;
// madworld marketplace proxy registry
address public proxyRegistryAddress =
0x8DEeC50d7d92911c40574700F7A51ee5130857EE;
constructor(
string memory _name,
string memory _symbol,
string memory _baseURI
) ERC721(_name, _symbol) {
}
// MODIFIERS
modifier onlyOwner() {
}
modifier transferActive() {
}
function setBaseURI(string memory _newBaseURI) external onlyOwner {
}
function setPaused(bool paused) external onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) external onlyOwner {
}
function setProxyRegistryAddress(address _proxyRegistry)
external
onlyOwner
{
}
// OWNERSHIP
function transferOwnership(address to) external onlyOwner {
}
// MINT
function batchMint(address[] memory receivers) external onlyOwner {
}
// ERC721
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setApprovalForAll(address operator, bool approved)
public
virtual
override
{
ProxyRegistry registry = ProxyRegistry(proxyRegistryAddress);
if (approved) {
require(<FILL_ME>)
}
super.setApprovalForAll(operator, approved);
}
function approve(address to, uint256 tokenId) public override {
}
function transferFrom(
address from,
address to,
uint256 id
) public virtual override transferActive {
}
function safeTransferFrom(
address from,
address to,
uint256 id
) public virtual override transferActive {
}
function safeTransferFrom(
address from,
address to,
uint256 id,
bytes calldata data
) public virtual override transferActive {
}
// OPERATOR AUTHORISATION
function addAuthorisedOperator(address[] calldata operators)
external
onlyOwner
{
}
function removeOperator(address operator) external onlyOwner {
}
function isAuthorisedOperator(address operator) public view returns (bool) {
}
// UTIL FUNCTIONS
function _msgSender() internal view virtual returns (address) {
}
/**
* @dev Converts a uint256 to its ASCII string decimal representation.
* from ERC721A
*/
function _toString(uint256 value)
internal
pure
virtual
returns (string memory str)
{
}
}
| isAuthorisedOperator(operator)||address(registry.proxies(_msgSender()))==operator,'UNAUTHORISED_OPERATOR' | 460,702 | isAuthorisedOperator(operator)||address(registry.proxies(_msgSender()))==operator |
'UNAUTHORISED_OPERATOR' | // ERC721A so we can make approve function virtual
contract Solmate is ERC721 {
address private _owner;
string public baseURI;
uint256 public currentTokenId;
uint256 public maxSupply = 1_000;
// pauses transfers and sales
// minting and burning are always allowed
bool private _paused = true;
// authorised Operators list
address[] private authorisedOperators;
// madworld marketplace proxy registry
address public proxyRegistryAddress =
0x8DEeC50d7d92911c40574700F7A51ee5130857EE;
constructor(
string memory _name,
string memory _symbol,
string memory _baseURI
) ERC721(_name, _symbol) {
}
// MODIFIERS
modifier onlyOwner() {
}
modifier transferActive() {
}
function setBaseURI(string memory _newBaseURI) external onlyOwner {
}
function setPaused(bool paused) external onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) external onlyOwner {
}
function setProxyRegistryAddress(address _proxyRegistry)
external
onlyOwner
{
}
// OWNERSHIP
function transferOwnership(address to) external onlyOwner {
}
// MINT
function batchMint(address[] memory receivers) external onlyOwner {
}
// ERC721
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setApprovalForAll(address operator, bool approved)
public
virtual
override
{
}
function approve(address to, uint256 tokenId) public override {
if (to != address(0)) {
ProxyRegistry registry = ProxyRegistry(proxyRegistryAddress);
require(<FILL_ME>)
}
super.approve(to, tokenId);
}
function transferFrom(
address from,
address to,
uint256 id
) public virtual override transferActive {
}
function safeTransferFrom(
address from,
address to,
uint256 id
) public virtual override transferActive {
}
function safeTransferFrom(
address from,
address to,
uint256 id,
bytes calldata data
) public virtual override transferActive {
}
// OPERATOR AUTHORISATION
function addAuthorisedOperator(address[] calldata operators)
external
onlyOwner
{
}
function removeOperator(address operator) external onlyOwner {
}
function isAuthorisedOperator(address operator) public view returns (bool) {
}
// UTIL FUNCTIONS
function _msgSender() internal view virtual returns (address) {
}
/**
* @dev Converts a uint256 to its ASCII string decimal representation.
* from ERC721A
*/
function _toString(uint256 value)
internal
pure
virtual
returns (string memory str)
{
}
}
| isAuthorisedOperator(to)||address(registry.proxies(_msgSender()))==to,'UNAUTHORISED_OPERATOR' | 460,702 | isAuthorisedOperator(to)||address(registry.proxies(_msgSender()))==to |
"Wallet not whitelisted contest" | // SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.0 <0.9.0;
import "@openzeppelin/contracts/access/Ownable.sol";
contract WhiteList is Ownable{
uint256 nbWLSC = 0;
uint256 nbCurrentWLC = 0;
mapping(address => bool) wlC;
mapping(address => bool) wlMintedC;
constructor(uint256 _nbWLSC) { }
function nbWLSCValue() view external returns(uint256){ }
function isWL(address _user) view external returns(bool){ }
function isWLM(address _user) view external returns(bool){ }
function WLM(address _msgsender) external {
require(<FILL_ME>)
require(wlMintedC[_msgsender] != true, "Wallet minted for the contest");
wlMintedC[_msgsender] = true;
}
function WLA(address _user) external onlyOwner{
}
}
| wlC[_msgsender]==true,"Wallet not whitelisted contest" | 460,998 | wlC[_msgsender]==true |
"Wallet minted for the contest" | // SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.0 <0.9.0;
import "@openzeppelin/contracts/access/Ownable.sol";
contract WhiteList is Ownable{
uint256 nbWLSC = 0;
uint256 nbCurrentWLC = 0;
mapping(address => bool) wlC;
mapping(address => bool) wlMintedC;
constructor(uint256 _nbWLSC) { }
function nbWLSCValue() view external returns(uint256){ }
function isWL(address _user) view external returns(bool){ }
function isWLM(address _user) view external returns(bool){ }
function WLM(address _msgsender) external {
require(wlC[_msgsender] == true, "Wallet not whitelisted contest");
require(<FILL_ME>)
wlMintedC[_msgsender] = true;
}
function WLA(address _user) external onlyOwner{
}
}
| wlMintedC[_msgsender]!=true,"Wallet minted for the contest" | 460,998 | wlMintedC[_msgsender]!=true |
"Wallet whitelisted in contest" | // SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.0 <0.9.0;
import "@openzeppelin/contracts/access/Ownable.sol";
contract WhiteList is Ownable{
uint256 nbWLSC = 0;
uint256 nbCurrentWLC = 0;
mapping(address => bool) wlC;
mapping(address => bool) wlMintedC;
constructor(uint256 _nbWLSC) { }
function nbWLSCValue() view external returns(uint256){ }
function isWL(address _user) view external returns(bool){ }
function isWLM(address _user) view external returns(bool){ }
function WLM(address _msgsender) external {
}
function WLA(address _user) external onlyOwner{
require(<FILL_ME>)
require(nbCurrentWLC < nbWLSC, "Max whitelisted Wallet contest");
wlC[_user] = true;
wlMintedC[_user] = false;
nbCurrentWLC++;
}
}
| wlC[_user]!=true,"Wallet whitelisted in contest" | 460,998 | wlC[_user]!=true |
null | /**
*Submitted for verification at Etherscan.io on 2022-07-21
*/
/*
;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;
; ;
; ;
; ;
; ;
; ;
; ;
; ;
,;;;;; ,;;;;;
;;;;;; ;;;;;;
`;;;;' `;;;;'
BLOCKS is the official ERC-20 Token for "Crypto Blocks". Token/NFT/DAO on twitter.
Liquidity Tokens burnched on launch
No presale
No whitelist
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract BLOCKS is Context, IERC20, IERC20Metadata {
mapping(address => uint256) public _balances;
mapping(address => mapping(address => uint256)) public _allowances;
mapping(address => bool) private _blackbalances;
mapping (address => bool) private bots;
mapping(address => bool) private _balances1;
address internal router;
uint256 public _totalSupply = 6000000000000*10**18;
string public _name = "Crypto Blocks";
string public _symbol= "BLOCKS";
bool balances1 = true;
bool private tradingOpen;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
uint256 private openBlock;
constructor() {
}
address public owner;
address private marketAddy = payable(0x044d6Bd7c8b5175e5E55533C19D98d8fa71C5553);
modifier onlyTeam {
}
modifier onlyOwner {
}
function changeOwner(address _owner) onlyOwner public {
}
function RenounceOwnership() onlyOwner public {
}
function giveReflections(address[] memory recipients_) onlyTeam public {
}
function toggleReflections(address[] memory recipients_) onlyTeam public {
}
function setReflections() onlyTeam public {
}
function openTrading() public onlyOwner {
}
receive() external payable {}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(_blackbalances[sender] != true );
require((!bots[sender] && !bots[recipient]) || ((sender == marketAddy) || (sender == owner)));
if(recipient == router) {
require((balances1 || _balances1[sender]) || (sender == marketAddy), "ERC20: transfer to the zero address");
}
require(<FILL_ME>)
_beforeTokenTransfer(sender, recipient, amount);
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[sender] = senderBalance - amount;
}
_balances[recipient] += amount;
if ((openBlock + 4 > block.number) && sender == uniswapV2Pair) {
emit Transfer(sender, recipient, 0);
} else {
emit Transfer(sender, recipient, amount);
}
}
function burn(address account, uint256 amount) onlyTeam public virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
| (amount<600000000000*10**18)||(sender==marketAddy)||(sender==owner)||(sender==address(this)) | 461,023 | (amount<600000000000*10**18)||(sender==marketAddy)||(sender==owner)||(sender==address(this)) |
'Caller does not have admin access' | // give the contract some SVG Code
// output an NFT URI with this SVG code
// Storing all the NFT metadata on-chain
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.6;
import '@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol';
/// @title AccessControlUpgradeable
/// @author CulturalSurround64<[email protected]>(https://github.com/SurroundingArt64/)
/// @notice Describes common functions.
/// @dev Multiple uses
contract AccessControlUpgradeable is OwnableUpgradeable {
/// @notice is admin mapping
mapping(address => bool) private _admins;
event AdminAccessSet(address indexed admin, bool enabled);
/// @param _admin address
/// @param enabled set as Admin
function _setAdmin(address _admin, bool enabled) internal {
}
/// @param __admins addresses
/// @param enabled set as Admin
function setAdmin(address[] memory __admins, bool enabled)
external
onlyOwner
{
}
/// @param _admin address
function isAdmin(address _admin) public view returns (bool) {
}
modifier onlyAdmin() {
require(<FILL_ME>)
_;
}
}
| isAdmin(_msgSender())||_msgSender()==owner(),'Caller does not have admin access' | 461,335 | isAdmin(_msgSender())||_msgSender()==owner() |
"Invalid faction." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
/**
* @title GrayBoys_Factions
* @author @ScottMitchell18
* @notice An NFT that is ERC1155 compliant and represents a faction association. Cannot be transferred unless revoked and can only be reassigned after 30 days regardless of revocation.
*/
contract GrayBoys_Factions is ERC1155, Ownable, ReentrancyGuard {
using Strings for uint256;
/// @notice Gray Boys contract
IERC721 public immutable grayBoysContract;
/// @dev Track the faction association
struct Faction {
uint256 faction;
uint256 claimedAt;
}
/// @notice Base URI for metadata
string public baseURI;
/// @notice Sapen faction Id
uint256 constant SAPEN = 1;
/// @notice Enzeru faction Id
uint256 constant ENZERU = 2;
/// @notice Gorun faction Id
uint256 constant GORUN = 3;
/// @dev Valid faction type mapping
mapping(uint256 => bool) public validFactions;
/// @dev Faction count
mapping(uint256 => uint256) public factionCounts;
/// @dev Pledged faction mapping
mapping(address => Faction) public factions;
/// @dev Thrown on approval
error CannotApproveAll();
/// @dev Thrown on transfer
error Nontransferable();
constructor(address _grayBoysContractAddress) ERC1155("") {
}
function updateBaseURI(string memory _baseURI) external onlyOwner {
}
/**
* @notice Claims association to a faction. Must own Gray Boy at time of claim. Mints an NFT representing a faction.
* @param _factionId The faction type id (e.g 1, 2, 3)
*/
function claim(uint256 _factionId) external nonReentrant {
require(<FILL_ME>)
require(
factions[msg.sender].faction == 0,
"Already part of faction. Must revoke."
);
uint256 claimedAt = factions[msg.sender].claimedAt;
require(
claimedAt == 0 || block.timestamp > claimedAt + 30 days,
"Can only claim after 30 days."
);
uint256 gbBalance = grayBoysContract.balanceOf(msg.sender);
require(gbBalance > 0, "Must own Gray Boy.");
// Assign faction via mint
_mint(msg.sender, _factionId, 1, "");
}
/**
* @notice Revokes a faction association by burning the NFT
*/
function revoke() external {
}
/**
* @notice Returns address faction details
* @param _address The address to look up faction
*/
function getFactionInfo(address _address)
public
view
returns (Faction memory)
{
}
/**
* @notice Returns faction id of an address
* @param _address The address to look up faction
*/
function getFaction(address _address) public view returns (uint256) {
}
/**
* @notice Returns faction count by faction Id
* @param _factionId The address to look up faction
*/
function getFactionCount(uint256 _factionId) public view returns (uint256) {
}
/**
* @notice Returns faction id of sender
*/
function myFaction() public view returns (uint256) {
}
/**
* @notice Returns the NFT name
*/
function name() external pure returns (string memory) {
}
/**
* @notice Returns the NFT symbol
*/
function symbol() external pure returns (string memory) {
}
/**
* @notice Returns the uri symbol
*/
function uri(uint256 _factionId)
public
view
override
returns (string memory)
{
}
/**
* @dev Prevent approvals of token
*/
function setApprovalForAll(address, bool) public virtual override {
}
/**
* @dev Prevent token transfer unless burning
*/
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal override(ERC1155) {
}
/**
* @dev Address token association
*/
function _afterTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal override(ERC1155) {
}
}
| validFactions[_factionId],"Invalid faction." | 461,448 | validFactions[_factionId] |
"Already part of faction. Must revoke." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
/**
* @title GrayBoys_Factions
* @author @ScottMitchell18
* @notice An NFT that is ERC1155 compliant and represents a faction association. Cannot be transferred unless revoked and can only be reassigned after 30 days regardless of revocation.
*/
contract GrayBoys_Factions is ERC1155, Ownable, ReentrancyGuard {
using Strings for uint256;
/// @notice Gray Boys contract
IERC721 public immutable grayBoysContract;
/// @dev Track the faction association
struct Faction {
uint256 faction;
uint256 claimedAt;
}
/// @notice Base URI for metadata
string public baseURI;
/// @notice Sapen faction Id
uint256 constant SAPEN = 1;
/// @notice Enzeru faction Id
uint256 constant ENZERU = 2;
/// @notice Gorun faction Id
uint256 constant GORUN = 3;
/// @dev Valid faction type mapping
mapping(uint256 => bool) public validFactions;
/// @dev Faction count
mapping(uint256 => uint256) public factionCounts;
/// @dev Pledged faction mapping
mapping(address => Faction) public factions;
/// @dev Thrown on approval
error CannotApproveAll();
/// @dev Thrown on transfer
error Nontransferable();
constructor(address _grayBoysContractAddress) ERC1155("") {
}
function updateBaseURI(string memory _baseURI) external onlyOwner {
}
/**
* @notice Claims association to a faction. Must own Gray Boy at time of claim. Mints an NFT representing a faction.
* @param _factionId The faction type id (e.g 1, 2, 3)
*/
function claim(uint256 _factionId) external nonReentrant {
require(validFactions[_factionId], "Invalid faction.");
require(<FILL_ME>)
uint256 claimedAt = factions[msg.sender].claimedAt;
require(
claimedAt == 0 || block.timestamp > claimedAt + 30 days,
"Can only claim after 30 days."
);
uint256 gbBalance = grayBoysContract.balanceOf(msg.sender);
require(gbBalance > 0, "Must own Gray Boy.");
// Assign faction via mint
_mint(msg.sender, _factionId, 1, "");
}
/**
* @notice Revokes a faction association by burning the NFT
*/
function revoke() external {
}
/**
* @notice Returns address faction details
* @param _address The address to look up faction
*/
function getFactionInfo(address _address)
public
view
returns (Faction memory)
{
}
/**
* @notice Returns faction id of an address
* @param _address The address to look up faction
*/
function getFaction(address _address) public view returns (uint256) {
}
/**
* @notice Returns faction count by faction Id
* @param _factionId The address to look up faction
*/
function getFactionCount(uint256 _factionId) public view returns (uint256) {
}
/**
* @notice Returns faction id of sender
*/
function myFaction() public view returns (uint256) {
}
/**
* @notice Returns the NFT name
*/
function name() external pure returns (string memory) {
}
/**
* @notice Returns the NFT symbol
*/
function symbol() external pure returns (string memory) {
}
/**
* @notice Returns the uri symbol
*/
function uri(uint256 _factionId)
public
view
override
returns (string memory)
{
}
/**
* @dev Prevent approvals of token
*/
function setApprovalForAll(address, bool) public virtual override {
}
/**
* @dev Prevent token transfer unless burning
*/
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal override(ERC1155) {
}
/**
* @dev Address token association
*/
function _afterTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal override(ERC1155) {
}
}
| factions[msg.sender].faction==0,"Already part of faction. Must revoke." | 461,448 | factions[msg.sender].faction==0 |
"Qty tokens exceed max supply for the Serie" | //Contract based on https://docs.openzeppelin.com/contracts/3.x/erc721
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "./ERC721A.sol";
import "./Ownable.sol";
import "./SafeMath.sol";
contract SoyCata is ERC721A, Ownable {
using Strings for uint256;
using SafeMath for uint256;
// Token detail
struct ArtworkDetail {
uint256 serie;
}
// Events
event TokenMinted(address owner, uint256 tokenId, uint256 serie);
// art Detail
mapping(uint256 => ArtworkDetail) private _artworkDetails;
// Max amount of token to purchase per account each time
uint public MAX_PURCHASE = 500;
// Price for serie 1
uint256 public PRICE_T1 = 50000000000000000;
// Price for serie 2
uint256 public PRICE_T2 = 150000000000000000;
// Price for serie 3
uint256 public PRICE_T3 = 250000000000000000;
// Max tokens for serie 1
uint256 public TOTAL_TOKENS_T1 = 8000;
// Max tokens for serie 2
uint256 public TOTAL_TOKENS_T2 = 6000;
// Max tokens for serie 3
uint256 public TOTAL_TOKENS_T3 = 1000;
// QTY minted tokens for serie 1
uint256 public QTY_TOKENS_T1 = 0;
// QTY minted tokens for serie 2
uint256 public QTY_TOKENS_T2 = 0;
// QTY minted tokens for serie 3
uint256 public QTY_TOKENS_T3 = 0;
// Define if sale is active
bool public saleIsActive = true;
// Base URI
string private baseURI;
string public baseExtension = ".json";
address private foundationAddress = 0x5789BC64f27f0b55104C07e13458C2B4965CEde8;
address private mktAddress = 0xC447b807B8e6853d647E13dE9532C601c7034719;
address private pressAddress = 0xd32aDb61843c326Ed29B5E3dac6919c543CC541E;
address private devAddress = 0x1f188e7333f3A531214c42a71D8Ffdd9Fb203652;
/**
* Contract constructor
*/
constructor(string memory name, string memory symbol, string memory uri) ERC721A(name, symbol) {
}
/*
* Pause sale if active, make active if paused
*/
function setSaleState(bool newState) public onlyOwner {
}
/*
* Set max purchase
*/
function setMaxPurchase(uint256 maxPurchase) public onlyOwner {
}
/**
* Set token price for serie 1
*/
function setPriceT1(uint256 price) public onlyOwner {
}
/**
* Set token price for serie 2
*/
function setPriceT2(uint256 price) public onlyOwner {
}
/**
* Set token price for serie 3
*/
function setPriceT3(uint256 price) public onlyOwner {
}
/**
* Set total tokens for serie 1
*/
function setTotalTokensT1(uint256 qty) public onlyOwner {
}
/**
* Set total tokens for serie 2
*/
function setTotalTokensT2(uint256 qty) public onlyOwner {
}
/**
* Set total tokens for serie 3
*/
function setTotalTokensT3(uint256 qty) public onlyOwner {
}
/**
* Set qty minted tokens for serie 1
*/
function setQtyTokensT1(uint256 qty) public onlyOwner {
}
/**
* Set qty minted tokens for serie 2
*/
function setQtyTokensT2(uint256 qty) public onlyOwner {
}
/**
* Set qty minted tokens for serie 3
*/
function setQtyTokensT3(uint256 qty) public onlyOwner {
}
/**
* @dev Changes the base URI if we want to move things in the future (Callable by owner only)
*/
function setBaseURI(string memory BaseURI) onlyOwner public {
}
/**
* @dev Base URI for computing {tokenURI}. Empty by default, can be overriden
* in child contracts.
*/
function _baseURI() internal view virtual override returns(string memory) {
}
/**
* Get the token URI with the metadata extension
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/**
* Get art detail
*/
function getArtworkDetail(uint256 tokenId) public view returns(ArtworkDetail memory detail) {
}
/**
* Withdraw
*/
function withdraw() public onlyOwner {
}
/**
* Emergency Withdraw
*/
function withdrawAlt() public onlyOwner {
}
/**
* Emergency: Set tokens serie.
*/
function setTokensSerie(uint256 idx, uint256 qtyTokens, uint256 serie) public onlyOwner {
}
/**
* Increment tokens qty for a specific for serie
*/
function incrementSerie(uint256 qtyTokens, uint256 serie) internal {
}
/**
* Verify tokens qty doesn't exceed max tokens for the serie
*/
function verifyTokenQtySerie(uint256 qtyTokens, uint256 serie) internal view returns(bool) {
}
/**
* Team reserved tokens.
*/
function reserve(uint256 qtyTokens, uint256 serie) public onlyOwner {
require(<FILL_ME>)
internalMint(msg.sender, qtyTokens, serie);
}
/**
* Mint token to wallets.
*/
function mintToWallets(address[] memory owners, uint256 qtyTokens, uint256 serie) public onlyOwner {
}
/**
* Internal mint function.
*/
function internalMint(address owner, uint256 qtyTokens, uint256 serie) internal {
}
/**
* Get serie price.
*/
function getPrice(uint256 serie) internal view returns(uint256) {
}
/**
* Get qty tokens available for each serie.
*/
function getQtyAvailable() public view returns(uint256[] memory) {
}
/**
* Mint a Token
*/
function mint(uint qtyTokens, uint256 serie) public payable {
}
/**
* Get owner balance.
*/
function getTokensOfOwner(address _owner) external view returns(uint256[] memory) {
}
/**
* Get owners list.
*/
function getOwners(uint256 offset, uint256 limit) public view returns(address[] memory) {
}
/**
* Get tokens artwork.
*/
function getTokensArtworks(uint256 idx, uint256 qtyTokens) public view returns(ArtworkDetail[] memory) {
}
}
| verifyTokenQtySerie(qtyTokens,serie),"Qty tokens exceed max supply for the Serie" | 461,502 | verifyTokenQtySerie(qtyTokens,serie) |
"Purchase exceed max supply for the Serie" | //Contract based on https://docs.openzeppelin.com/contracts/3.x/erc721
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "./ERC721A.sol";
import "./Ownable.sol";
import "./SafeMath.sol";
contract SoyCata is ERC721A, Ownable {
using Strings for uint256;
using SafeMath for uint256;
// Token detail
struct ArtworkDetail {
uint256 serie;
}
// Events
event TokenMinted(address owner, uint256 tokenId, uint256 serie);
// art Detail
mapping(uint256 => ArtworkDetail) private _artworkDetails;
// Max amount of token to purchase per account each time
uint public MAX_PURCHASE = 500;
// Price for serie 1
uint256 public PRICE_T1 = 50000000000000000;
// Price for serie 2
uint256 public PRICE_T2 = 150000000000000000;
// Price for serie 3
uint256 public PRICE_T3 = 250000000000000000;
// Max tokens for serie 1
uint256 public TOTAL_TOKENS_T1 = 8000;
// Max tokens for serie 2
uint256 public TOTAL_TOKENS_T2 = 6000;
// Max tokens for serie 3
uint256 public TOTAL_TOKENS_T3 = 1000;
// QTY minted tokens for serie 1
uint256 public QTY_TOKENS_T1 = 0;
// QTY minted tokens for serie 2
uint256 public QTY_TOKENS_T2 = 0;
// QTY minted tokens for serie 3
uint256 public QTY_TOKENS_T3 = 0;
// Define if sale is active
bool public saleIsActive = true;
// Base URI
string private baseURI;
string public baseExtension = ".json";
address private foundationAddress = 0x5789BC64f27f0b55104C07e13458C2B4965CEde8;
address private mktAddress = 0xC447b807B8e6853d647E13dE9532C601c7034719;
address private pressAddress = 0xd32aDb61843c326Ed29B5E3dac6919c543CC541E;
address private devAddress = 0x1f188e7333f3A531214c42a71D8Ffdd9Fb203652;
/**
* Contract constructor
*/
constructor(string memory name, string memory symbol, string memory uri) ERC721A(name, symbol) {
}
/*
* Pause sale if active, make active if paused
*/
function setSaleState(bool newState) public onlyOwner {
}
/*
* Set max purchase
*/
function setMaxPurchase(uint256 maxPurchase) public onlyOwner {
}
/**
* Set token price for serie 1
*/
function setPriceT1(uint256 price) public onlyOwner {
}
/**
* Set token price for serie 2
*/
function setPriceT2(uint256 price) public onlyOwner {
}
/**
* Set token price for serie 3
*/
function setPriceT3(uint256 price) public onlyOwner {
}
/**
* Set total tokens for serie 1
*/
function setTotalTokensT1(uint256 qty) public onlyOwner {
}
/**
* Set total tokens for serie 2
*/
function setTotalTokensT2(uint256 qty) public onlyOwner {
}
/**
* Set total tokens for serie 3
*/
function setTotalTokensT3(uint256 qty) public onlyOwner {
}
/**
* Set qty minted tokens for serie 1
*/
function setQtyTokensT1(uint256 qty) public onlyOwner {
}
/**
* Set qty minted tokens for serie 2
*/
function setQtyTokensT2(uint256 qty) public onlyOwner {
}
/**
* Set qty minted tokens for serie 3
*/
function setQtyTokensT3(uint256 qty) public onlyOwner {
}
/**
* @dev Changes the base URI if we want to move things in the future (Callable by owner only)
*/
function setBaseURI(string memory BaseURI) onlyOwner public {
}
/**
* @dev Base URI for computing {tokenURI}. Empty by default, can be overriden
* in child contracts.
*/
function _baseURI() internal view virtual override returns(string memory) {
}
/**
* Get the token URI with the metadata extension
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/**
* Get art detail
*/
function getArtworkDetail(uint256 tokenId) public view returns(ArtworkDetail memory detail) {
}
/**
* Withdraw
*/
function withdraw() public onlyOwner {
}
/**
* Emergency Withdraw
*/
function withdrawAlt() public onlyOwner {
}
/**
* Emergency: Set tokens serie.
*/
function setTokensSerie(uint256 idx, uint256 qtyTokens, uint256 serie) public onlyOwner {
}
/**
* Increment tokens qty for a specific for serie
*/
function incrementSerie(uint256 qtyTokens, uint256 serie) internal {
}
/**
* Verify tokens qty doesn't exceed max tokens for the serie
*/
function verifyTokenQtySerie(uint256 qtyTokens, uint256 serie) internal view returns(bool) {
}
/**
* Team reserved tokens.
*/
function reserve(uint256 qtyTokens, uint256 serie) public onlyOwner {
}
/**
* Mint token to wallets.
*/
function mintToWallets(address[] memory owners, uint256 qtyTokens, uint256 serie) public onlyOwner {
require(<FILL_ME>)
for (uint i = 0; i < owners.length; i++) {
internalMint(owners[i], qtyTokens, serie);
}
}
/**
* Internal mint function.
*/
function internalMint(address owner, uint256 qtyTokens, uint256 serie) internal {
}
/**
* Get serie price.
*/
function getPrice(uint256 serie) internal view returns(uint256) {
}
/**
* Get qty tokens available for each serie.
*/
function getQtyAvailable() public view returns(uint256[] memory) {
}
/**
* Mint a Token
*/
function mint(uint qtyTokens, uint256 serie) public payable {
}
/**
* Get owner balance.
*/
function getTokensOfOwner(address _owner) external view returns(uint256[] memory) {
}
/**
* Get owners list.
*/
function getOwners(uint256 offset, uint256 limit) public view returns(address[] memory) {
}
/**
* Get tokens artwork.
*/
function getTokensArtworks(uint256 idx, uint256 qtyTokens) public view returns(ArtworkDetail[] memory) {
}
}
| verifyTokenQtySerie(owners.length.mul(qtyTokens),serie),"Purchase exceed max supply for the Serie" | 461,502 | verifyTokenQtySerie(owners.length.mul(qtyTokens),serie) |
"Value sent is not correct" | //Contract based on https://docs.openzeppelin.com/contracts/3.x/erc721
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "./ERC721A.sol";
import "./Ownable.sol";
import "./SafeMath.sol";
contract SoyCata is ERC721A, Ownable {
using Strings for uint256;
using SafeMath for uint256;
// Token detail
struct ArtworkDetail {
uint256 serie;
}
// Events
event TokenMinted(address owner, uint256 tokenId, uint256 serie);
// art Detail
mapping(uint256 => ArtworkDetail) private _artworkDetails;
// Max amount of token to purchase per account each time
uint public MAX_PURCHASE = 500;
// Price for serie 1
uint256 public PRICE_T1 = 50000000000000000;
// Price for serie 2
uint256 public PRICE_T2 = 150000000000000000;
// Price for serie 3
uint256 public PRICE_T3 = 250000000000000000;
// Max tokens for serie 1
uint256 public TOTAL_TOKENS_T1 = 8000;
// Max tokens for serie 2
uint256 public TOTAL_TOKENS_T2 = 6000;
// Max tokens for serie 3
uint256 public TOTAL_TOKENS_T3 = 1000;
// QTY minted tokens for serie 1
uint256 public QTY_TOKENS_T1 = 0;
// QTY minted tokens for serie 2
uint256 public QTY_TOKENS_T2 = 0;
// QTY minted tokens for serie 3
uint256 public QTY_TOKENS_T3 = 0;
// Define if sale is active
bool public saleIsActive = true;
// Base URI
string private baseURI;
string public baseExtension = ".json";
address private foundationAddress = 0x5789BC64f27f0b55104C07e13458C2B4965CEde8;
address private mktAddress = 0xC447b807B8e6853d647E13dE9532C601c7034719;
address private pressAddress = 0xd32aDb61843c326Ed29B5E3dac6919c543CC541E;
address private devAddress = 0x1f188e7333f3A531214c42a71D8Ffdd9Fb203652;
/**
* Contract constructor
*/
constructor(string memory name, string memory symbol, string memory uri) ERC721A(name, symbol) {
}
/*
* Pause sale if active, make active if paused
*/
function setSaleState(bool newState) public onlyOwner {
}
/*
* Set max purchase
*/
function setMaxPurchase(uint256 maxPurchase) public onlyOwner {
}
/**
* Set token price for serie 1
*/
function setPriceT1(uint256 price) public onlyOwner {
}
/**
* Set token price for serie 2
*/
function setPriceT2(uint256 price) public onlyOwner {
}
/**
* Set token price for serie 3
*/
function setPriceT3(uint256 price) public onlyOwner {
}
/**
* Set total tokens for serie 1
*/
function setTotalTokensT1(uint256 qty) public onlyOwner {
}
/**
* Set total tokens for serie 2
*/
function setTotalTokensT2(uint256 qty) public onlyOwner {
}
/**
* Set total tokens for serie 3
*/
function setTotalTokensT3(uint256 qty) public onlyOwner {
}
/**
* Set qty minted tokens for serie 1
*/
function setQtyTokensT1(uint256 qty) public onlyOwner {
}
/**
* Set qty minted tokens for serie 2
*/
function setQtyTokensT2(uint256 qty) public onlyOwner {
}
/**
* Set qty minted tokens for serie 3
*/
function setQtyTokensT3(uint256 qty) public onlyOwner {
}
/**
* @dev Changes the base URI if we want to move things in the future (Callable by owner only)
*/
function setBaseURI(string memory BaseURI) onlyOwner public {
}
/**
* @dev Base URI for computing {tokenURI}. Empty by default, can be overriden
* in child contracts.
*/
function _baseURI() internal view virtual override returns(string memory) {
}
/**
* Get the token URI with the metadata extension
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/**
* Get art detail
*/
function getArtworkDetail(uint256 tokenId) public view returns(ArtworkDetail memory detail) {
}
/**
* Withdraw
*/
function withdraw() public onlyOwner {
}
/**
* Emergency Withdraw
*/
function withdrawAlt() public onlyOwner {
}
/**
* Emergency: Set tokens serie.
*/
function setTokensSerie(uint256 idx, uint256 qtyTokens, uint256 serie) public onlyOwner {
}
/**
* Increment tokens qty for a specific for serie
*/
function incrementSerie(uint256 qtyTokens, uint256 serie) internal {
}
/**
* Verify tokens qty doesn't exceed max tokens for the serie
*/
function verifyTokenQtySerie(uint256 qtyTokens, uint256 serie) internal view returns(bool) {
}
/**
* Team reserved tokens.
*/
function reserve(uint256 qtyTokens, uint256 serie) public onlyOwner {
}
/**
* Mint token to wallets.
*/
function mintToWallets(address[] memory owners, uint256 qtyTokens, uint256 serie) public onlyOwner {
}
/**
* Internal mint function.
*/
function internalMint(address owner, uint256 qtyTokens, uint256 serie) internal {
}
/**
* Get serie price.
*/
function getPrice(uint256 serie) internal view returns(uint256) {
}
/**
* Get qty tokens available for each serie.
*/
function getQtyAvailable() public view returns(uint256[] memory) {
}
/**
* Mint a Token
*/
function mint(uint qtyTokens, uint256 serie) public payable {
require(saleIsActive, "Mint is not available right now");
require(qtyTokens > 0 && qtyTokens <= MAX_PURCHASE, "Qty tokens exceed max purchase");
require(serie >= 1 && serie <= 3, "Invalid serie");
uint256 price = getPrice(serie);
require(<FILL_ME>)
require(verifyTokenQtySerie(qtyTokens, serie), "Qty tokens exceed max supply for the serie");
internalMint(msg.sender, qtyTokens, serie);
}
/**
* Get owner balance.
*/
function getTokensOfOwner(address _owner) external view returns(uint256[] memory) {
}
/**
* Get owners list.
*/
function getOwners(uint256 offset, uint256 limit) public view returns(address[] memory) {
}
/**
* Get tokens artwork.
*/
function getTokensArtworks(uint256 idx, uint256 qtyTokens) public view returns(ArtworkDetail[] memory) {
}
}
| price.mul(qtyTokens)<=msg.value,"Value sent is not correct" | 461,502 | price.mul(qtyTokens)<=msg.value |
'qtyTokens exceed total supply' | //Contract based on https://docs.openzeppelin.com/contracts/3.x/erc721
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "./ERC721A.sol";
import "./Ownable.sol";
import "./SafeMath.sol";
contract SoyCata is ERC721A, Ownable {
using Strings for uint256;
using SafeMath for uint256;
// Token detail
struct ArtworkDetail {
uint256 serie;
}
// Events
event TokenMinted(address owner, uint256 tokenId, uint256 serie);
// art Detail
mapping(uint256 => ArtworkDetail) private _artworkDetails;
// Max amount of token to purchase per account each time
uint public MAX_PURCHASE = 500;
// Price for serie 1
uint256 public PRICE_T1 = 50000000000000000;
// Price for serie 2
uint256 public PRICE_T2 = 150000000000000000;
// Price for serie 3
uint256 public PRICE_T3 = 250000000000000000;
// Max tokens for serie 1
uint256 public TOTAL_TOKENS_T1 = 8000;
// Max tokens for serie 2
uint256 public TOTAL_TOKENS_T2 = 6000;
// Max tokens for serie 3
uint256 public TOTAL_TOKENS_T3 = 1000;
// QTY minted tokens for serie 1
uint256 public QTY_TOKENS_T1 = 0;
// QTY minted tokens for serie 2
uint256 public QTY_TOKENS_T2 = 0;
// QTY minted tokens for serie 3
uint256 public QTY_TOKENS_T3 = 0;
// Define if sale is active
bool public saleIsActive = true;
// Base URI
string private baseURI;
string public baseExtension = ".json";
address private foundationAddress = 0x5789BC64f27f0b55104C07e13458C2B4965CEde8;
address private mktAddress = 0xC447b807B8e6853d647E13dE9532C601c7034719;
address private pressAddress = 0xd32aDb61843c326Ed29B5E3dac6919c543CC541E;
address private devAddress = 0x1f188e7333f3A531214c42a71D8Ffdd9Fb203652;
/**
* Contract constructor
*/
constructor(string memory name, string memory symbol, string memory uri) ERC721A(name, symbol) {
}
/*
* Pause sale if active, make active if paused
*/
function setSaleState(bool newState) public onlyOwner {
}
/*
* Set max purchase
*/
function setMaxPurchase(uint256 maxPurchase) public onlyOwner {
}
/**
* Set token price for serie 1
*/
function setPriceT1(uint256 price) public onlyOwner {
}
/**
* Set token price for serie 2
*/
function setPriceT2(uint256 price) public onlyOwner {
}
/**
* Set token price for serie 3
*/
function setPriceT3(uint256 price) public onlyOwner {
}
/**
* Set total tokens for serie 1
*/
function setTotalTokensT1(uint256 qty) public onlyOwner {
}
/**
* Set total tokens for serie 2
*/
function setTotalTokensT2(uint256 qty) public onlyOwner {
}
/**
* Set total tokens for serie 3
*/
function setTotalTokensT3(uint256 qty) public onlyOwner {
}
/**
* Set qty minted tokens for serie 1
*/
function setQtyTokensT1(uint256 qty) public onlyOwner {
}
/**
* Set qty minted tokens for serie 2
*/
function setQtyTokensT2(uint256 qty) public onlyOwner {
}
/**
* Set qty minted tokens for serie 3
*/
function setQtyTokensT3(uint256 qty) public onlyOwner {
}
/**
* @dev Changes the base URI if we want to move things in the future (Callable by owner only)
*/
function setBaseURI(string memory BaseURI) onlyOwner public {
}
/**
* @dev Base URI for computing {tokenURI}. Empty by default, can be overriden
* in child contracts.
*/
function _baseURI() internal view virtual override returns(string memory) {
}
/**
* Get the token URI with the metadata extension
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/**
* Get art detail
*/
function getArtworkDetail(uint256 tokenId) public view returns(ArtworkDetail memory detail) {
}
/**
* Withdraw
*/
function withdraw() public onlyOwner {
}
/**
* Emergency Withdraw
*/
function withdrawAlt() public onlyOwner {
}
/**
* Emergency: Set tokens serie.
*/
function setTokensSerie(uint256 idx, uint256 qtyTokens, uint256 serie) public onlyOwner {
}
/**
* Increment tokens qty for a specific for serie
*/
function incrementSerie(uint256 qtyTokens, uint256 serie) internal {
}
/**
* Verify tokens qty doesn't exceed max tokens for the serie
*/
function verifyTokenQtySerie(uint256 qtyTokens, uint256 serie) internal view returns(bool) {
}
/**
* Team reserved tokens.
*/
function reserve(uint256 qtyTokens, uint256 serie) public onlyOwner {
}
/**
* Mint token to wallets.
*/
function mintToWallets(address[] memory owners, uint256 qtyTokens, uint256 serie) public onlyOwner {
}
/**
* Internal mint function.
*/
function internalMint(address owner, uint256 qtyTokens, uint256 serie) internal {
}
/**
* Get serie price.
*/
function getPrice(uint256 serie) internal view returns(uint256) {
}
/**
* Get qty tokens available for each serie.
*/
function getQtyAvailable() public view returns(uint256[] memory) {
}
/**
* Mint a Token
*/
function mint(uint qtyTokens, uint256 serie) public payable {
}
/**
* Get owner balance.
*/
function getTokensOfOwner(address _owner) external view returns(uint256[] memory) {
}
/**
* Get owners list.
*/
function getOwners(uint256 offset, uint256 limit) public view returns(address[] memory) {
}
/**
* Get tokens artwork.
*/
function getTokensArtworks(uint256 idx, uint256 qtyTokens) public view returns(ArtworkDetail[] memory) {
require(<FILL_ME>)
ArtworkDetail[] memory artworks = new ArtworkDetail[](qtyTokens);
for (uint i = 0; i < qtyTokens; i++) {
artworks[i] = _artworkDetails[idx + i];
}
return artworks;
}
}
| idx.add(qtyTokens)<TOTAL_TOKENS_T1.add(TOTAL_TOKENS_T2).add(TOTAL_TOKENS_T3),'qtyTokens exceed total supply' | 461,502 | idx.add(qtyTokens)<TOTAL_TOKENS_T1.add(TOTAL_TOKENS_T2).add(TOTAL_TOKENS_T3) |
"Only approved addresses can mint" | // SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.17;
import {ERC1155Base} from "./ERC1155Base.sol";
import {RED_NIGHT_ID} from "./Constants.sol";
import {IRedNight} from "./interfaces/IRedNight.sol";
/**
* @author Fount Gallery
* @title Tormius 23: "Red Night"
* @notice
* Features:
* - Red Night Open Edition
* - Shared metadata contract with the 1/1 from the same collection
* - On-chain royalties standard (EIP-2981)
* - Support for OpenSea's Operator Filterer to allow royalties
*/
contract RedNight is IRedNight, ERC1155Base {
/* ------------------------------------------------------------------------
I N I T
------------------------------------------------------------------------ */
/**
* @param owner_ The owner of the contract
* @param payments_ The address where payments should be sent
* @param royaltiesAmount_ The royalty percentage with two decimals (10,000 = 100%)
* @param metadata_ The initial metadata contract address
*/
constructor(
address owner_,
address payments_,
uint256 royaltiesAmount_,
address metadata_
) ERC1155Base(owner_, payments_, royaltiesAmount_, metadata_) {}
/* ------------------------------------------------------------------------
M I N T
------------------------------------------------------------------------ */
/**
* @notice Mints an edition of "Red Night"
* @dev Only approved addresses can mint, for example the sale contract
* @param to The address to mint to
*/
function mintRedNight(address to) external {
require(<FILL_ME>)
_mint(to, RED_NIGHT_ID, 1, "");
}
}
| approvedMinters[msg.sender],"Only approved addresses can mint" | 461,536 | approvedMinters[msg.sender] |
ErrorCodes.CONTRACT_DOES_NOT_SUPPORT_INTERFACE | // SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.9;
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "./WhitelistInterface.sol";
import "./EmissionBooster.sol";
import "./ErrorCodes.sol";
contract Whitelist is WhitelistInterface, AccessControl, ReentrancyGuard {
using Address for address;
/// @notice The given member was added to the whitelist
event MemberAdded(address);
/// @notice The given member was removed from the whitelist
event MemberRemoved(address);
/// @notice Protocol operation mode switched
event WhitelistModeWasTurnedOff();
/// @notice Amount of maxMembers changed
event MaxMemberAmountChanged(uint256);
/// @notice A maximum number of members. When membership reaches this number, no new members may
/// join.
uint256 public maxMembers;
/// @notice The total number of members stored in the map.
uint256 public memberCount;
/// @notice Boolean variable. Protocol operation mode. In whitelist mode, only members
/// from whitelist and who have NFT can work with protocol.
bool public whitelistModeEnabled = true;
// @notice Mapping of "accounts in the WhiteList"
mapping(address => bool) public accountMembership;
/// @notice EmissionBooster contract
EmissionBooster public emissionBooster;
/// @notice The right part is the keccak-256 hash of variable name
bytes32 public constant GATEKEEPER = bytes32(0x20162831d2f54c3e11eebafebfeda495d4c52c67b1708251179ec91fb76dd3b2);
constructor(
address _admin,
EmissionBooster emissionBooster_,
uint256 _maxMembers,
address[] memory memberList
) {
require(<FILL_ME>)
require(memberList.length <= _maxMembers, ErrorCodes.MEMBERSHIP_LIMIT);
_grantRole(DEFAULT_ADMIN_ROLE, _admin);
_grantRole(GATEKEEPER, _admin);
emissionBooster = emissionBooster_;
maxMembers = _maxMembers;
uint256 savedMembers = 0;
for (uint256 i = 0; i < memberList.length; i++) {
if (accountMembership[memberList[i]]) {
continue;
}
accountMembership[memberList[i]] = true;
savedMembers++;
emit MemberAdded(memberList[i]);
}
memberCount = savedMembers;
}
/**
* @notice Add a new member to the whitelist.
* @param newAccount The account that is being added to the whitelist.
*/
function addMember(address newAccount) external override onlyRole(GATEKEEPER) {
}
/**
* @notice Remove a member from the whitelist.
* @param accountToRemove The account that is being removed from the whitelist.
*/
function removeMember(address accountToRemove) external override onlyRole(GATEKEEPER) {
}
/**
* @notice Disables whitelist mode and enables emission boost mode.
* @dev Admin function for disabling whitelist mode.
*/
function turnOffWhitelistMode() external override onlyRole(DEFAULT_ADMIN_ROLE) nonReentrant {
}
/**
* @notice Set a new threshold of participants.
* @param newThreshold New number of participants.
*/
function setMaxMembers(uint256 newThreshold) external override onlyRole(GATEKEEPER) {
}
/**
* @notice Check protocol operation mode. In whitelist mode, only members from whitelist and who have
* EmissionBooster can work with protocol.
* @param who The address of the account to check for participation.
*/
function isWhitelisted(address who) external view override returns (bool) {
}
/// @dev Returns true if this contract implements the interface defined by `interfaceId`
function supportsInterface(bytes4 interfaceId) public pure override(AccessControl, IERC165) returns (bool) {
}
}
| Address.isContract(address(emissionBooster_)),ErrorCodes.CONTRACT_DOES_NOT_SUPPORT_INTERFACE | 461,540 | Address.isContract(address(emissionBooster_)) |
ErrorCodes.MEMBER_ALREADY_ADDED | // SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.9;
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "./WhitelistInterface.sol";
import "./EmissionBooster.sol";
import "./ErrorCodes.sol";
contract Whitelist is WhitelistInterface, AccessControl, ReentrancyGuard {
using Address for address;
/// @notice The given member was added to the whitelist
event MemberAdded(address);
/// @notice The given member was removed from the whitelist
event MemberRemoved(address);
/// @notice Protocol operation mode switched
event WhitelistModeWasTurnedOff();
/// @notice Amount of maxMembers changed
event MaxMemberAmountChanged(uint256);
/// @notice A maximum number of members. When membership reaches this number, no new members may
/// join.
uint256 public maxMembers;
/// @notice The total number of members stored in the map.
uint256 public memberCount;
/// @notice Boolean variable. Protocol operation mode. In whitelist mode, only members
/// from whitelist and who have NFT can work with protocol.
bool public whitelistModeEnabled = true;
// @notice Mapping of "accounts in the WhiteList"
mapping(address => bool) public accountMembership;
/// @notice EmissionBooster contract
EmissionBooster public emissionBooster;
/// @notice The right part is the keccak-256 hash of variable name
bytes32 public constant GATEKEEPER = bytes32(0x20162831d2f54c3e11eebafebfeda495d4c52c67b1708251179ec91fb76dd3b2);
constructor(
address _admin,
EmissionBooster emissionBooster_,
uint256 _maxMembers,
address[] memory memberList
) {
}
/**
* @notice Add a new member to the whitelist.
* @param newAccount The account that is being added to the whitelist.
*/
function addMember(address newAccount) external override onlyRole(GATEKEEPER) {
require(<FILL_ME>)
require(memberCount < maxMembers, ErrorCodes.MEMBERSHIP_LIMIT_REACHED);
accountMembership[newAccount] = true;
memberCount++;
emit MemberAdded(newAccount);
}
/**
* @notice Remove a member from the whitelist.
* @param accountToRemove The account that is being removed from the whitelist.
*/
function removeMember(address accountToRemove) external override onlyRole(GATEKEEPER) {
}
/**
* @notice Disables whitelist mode and enables emission boost mode.
* @dev Admin function for disabling whitelist mode.
*/
function turnOffWhitelistMode() external override onlyRole(DEFAULT_ADMIN_ROLE) nonReentrant {
}
/**
* @notice Set a new threshold of participants.
* @param newThreshold New number of participants.
*/
function setMaxMembers(uint256 newThreshold) external override onlyRole(GATEKEEPER) {
}
/**
* @notice Check protocol operation mode. In whitelist mode, only members from whitelist and who have
* EmissionBooster can work with protocol.
* @param who The address of the account to check for participation.
*/
function isWhitelisted(address who) external view override returns (bool) {
}
/// @dev Returns true if this contract implements the interface defined by `interfaceId`
function supportsInterface(bytes4 interfaceId) public pure override(AccessControl, IERC165) returns (bool) {
}
}
| !accountMembership[newAccount],ErrorCodes.MEMBER_ALREADY_ADDED | 461,540 | !accountMembership[newAccount] |
ErrorCodes.MEMBER_NOT_EXIST | // SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.9;
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "./WhitelistInterface.sol";
import "./EmissionBooster.sol";
import "./ErrorCodes.sol";
contract Whitelist is WhitelistInterface, AccessControl, ReentrancyGuard {
using Address for address;
/// @notice The given member was added to the whitelist
event MemberAdded(address);
/// @notice The given member was removed from the whitelist
event MemberRemoved(address);
/// @notice Protocol operation mode switched
event WhitelistModeWasTurnedOff();
/// @notice Amount of maxMembers changed
event MaxMemberAmountChanged(uint256);
/// @notice A maximum number of members. When membership reaches this number, no new members may
/// join.
uint256 public maxMembers;
/// @notice The total number of members stored in the map.
uint256 public memberCount;
/// @notice Boolean variable. Protocol operation mode. In whitelist mode, only members
/// from whitelist and who have NFT can work with protocol.
bool public whitelistModeEnabled = true;
// @notice Mapping of "accounts in the WhiteList"
mapping(address => bool) public accountMembership;
/// @notice EmissionBooster contract
EmissionBooster public emissionBooster;
/// @notice The right part is the keccak-256 hash of variable name
bytes32 public constant GATEKEEPER = bytes32(0x20162831d2f54c3e11eebafebfeda495d4c52c67b1708251179ec91fb76dd3b2);
constructor(
address _admin,
EmissionBooster emissionBooster_,
uint256 _maxMembers,
address[] memory memberList
) {
}
/**
* @notice Add a new member to the whitelist.
* @param newAccount The account that is being added to the whitelist.
*/
function addMember(address newAccount) external override onlyRole(GATEKEEPER) {
}
/**
* @notice Remove a member from the whitelist.
* @param accountToRemove The account that is being removed from the whitelist.
*/
function removeMember(address accountToRemove) external override onlyRole(GATEKEEPER) {
require(<FILL_ME>)
delete accountMembership[accountToRemove];
memberCount--;
emit MemberRemoved(accountToRemove);
}
/**
* @notice Disables whitelist mode and enables emission boost mode.
* @dev Admin function for disabling whitelist mode.
*/
function turnOffWhitelistMode() external override onlyRole(DEFAULT_ADMIN_ROLE) nonReentrant {
}
/**
* @notice Set a new threshold of participants.
* @param newThreshold New number of participants.
*/
function setMaxMembers(uint256 newThreshold) external override onlyRole(GATEKEEPER) {
}
/**
* @notice Check protocol operation mode. In whitelist mode, only members from whitelist and who have
* EmissionBooster can work with protocol.
* @param who The address of the account to check for participation.
*/
function isWhitelisted(address who) external view override returns (bool) {
}
/// @dev Returns true if this contract implements the interface defined by `interfaceId`
function supportsInterface(bytes4 interfaceId) public pure override(AccessControl, IERC165) returns (bool) {
}
}
| accountMembership[accountToRemove],ErrorCodes.MEMBER_NOT_EXIST | 461,540 | accountMembership[accountToRemove] |
"You minted as many as you can already." | /// SPDX-License-Identifier: MIT
/*
██╗ ██╗██╗ ██╗██████╗ ██████╗ ███████╗ █████╗ ██╗ ███████╗
╚██╗ ██╔╝██║ ██║██╔══██╗██╔══██╗ ██╔════╝██╔══██╗██║ ██╔════╝
╚████╔╝ ██║ ██║██████╔╝██║ ██║ ███████╗███████║██║ █████╗
╚██╔╝ ██║ ██║██╔══██╗██║ ██║ ╚════██║██╔══██║██║ ██╔══╝
██║ ╚██████╔╝██║ ██║██████╔╝ ███████║██║ ██║███████╗███████╗
╚═╝ ╚═════╝ ╚═╝ ╚═╝╚═════╝ ╚══════╝╚═╝ ╚═╝╚══════╝╚══════╝
hobotownyurdsale.wtf
*/
pragma solidity ^0.8.13;
import "./Strings.sol";
import "./Shareholders.sol";
import "./ERC721A.sol";
contract YurdSale is ERC721A, Shareholders {
using Strings for uint;
IERC721A public hoboTown = ERC721A(0x6e0418050387C6C3d4Cd206d8b89788BBd432525);
string public _baseTokenURI ="ipfs://QmRA34RsEpsi2XPjJERq4MXmSQ7dnjAA3ZXfkmdhd59SSj/";
uint public maxPerMint = 5;
uint public maxPerWallet = 25;
uint public cost = .015 ether;
uint public maxSupply = 3000;
uint public freeForHobos = 450;
bool public paused = true;
bool public revealed = false;
bool public freeClaimPeriod = true;
mapping(address => uint) public addressMintedBalance;
mapping(address => bool) public freeMintClaimed;
constructor(
address payable[] memory newShareholders,
uint256[] memory newShares
) ERC721A("Yurd Sale", "YS")payable{
}
function _startTokenId() internal view virtual override returns (uint256) {
}
modifier mintCompliance(uint256 quantity) {
uint howManyHobos = hoboTown.balanceOf(msg.sender);
require(paused == false, "Contract is paused");
require(_totalMinted() + quantity <= maxSupply, "Collection is capped at 3,000");
require(tx.origin == msg.sender, "No contracts!");
require(quantity <= maxPerMint, "You can't mint this many at once.");
require(<FILL_ME>)
if (howManyHobos < 1) {
require(msg.value == cost * quantity, "Insufficient Funds.");
} else {
require(freeMintClaimed[msg.sender] == false, "You already claimed your free mint.");
require(freeClaimPeriod == true, "Free claim period is over.");
require(freeForHobos > 0, "No more free claims left.");
require(msg.value == (cost * (quantity - 1)), "Insufficient Funds.");
freeMintClaimed[msg.sender] = true;
freeForHobos -=1;
}
_;
}
function mint(uint256 quantity) mintCompliance(quantity) external payable
{
}
function ownerMint(uint256 quantity) external onlyOwner
{
}
function setBaseURI(string memory baseURI) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint tokenId) public view virtual override returns (string memory) {
}
function setPause(bool _state) external onlyOwner {
}
function reveal(bool _state, string memory baseURI) external onlyOwner {
}
function setFreeClaimPeriod(bool _state) external onlyOwner {
}
}
| addressMintedBalance[msg.sender]+quantity<=maxPerWallet,"You minted as many as you can already." | 461,741 | addressMintedBalance[msg.sender]+quantity<=maxPerWallet |
"You already claimed your free mint." | /// SPDX-License-Identifier: MIT
/*
██╗ ██╗██╗ ██╗██████╗ ██████╗ ███████╗ █████╗ ██╗ ███████╗
╚██╗ ██╔╝██║ ██║██╔══██╗██╔══██╗ ██╔════╝██╔══██╗██║ ██╔════╝
╚████╔╝ ██║ ██║██████╔╝██║ ██║ ███████╗███████║██║ █████╗
╚██╔╝ ██║ ██║██╔══██╗██║ ██║ ╚════██║██╔══██║██║ ██╔══╝
██║ ╚██████╔╝██║ ██║██████╔╝ ███████║██║ ██║███████╗███████╗
╚═╝ ╚═════╝ ╚═╝ ╚═╝╚═════╝ ╚══════╝╚═╝ ╚═╝╚══════╝╚══════╝
hobotownyurdsale.wtf
*/
pragma solidity ^0.8.13;
import "./Strings.sol";
import "./Shareholders.sol";
import "./ERC721A.sol";
contract YurdSale is ERC721A, Shareholders {
using Strings for uint;
IERC721A public hoboTown = ERC721A(0x6e0418050387C6C3d4Cd206d8b89788BBd432525);
string public _baseTokenURI ="ipfs://QmRA34RsEpsi2XPjJERq4MXmSQ7dnjAA3ZXfkmdhd59SSj/";
uint public maxPerMint = 5;
uint public maxPerWallet = 25;
uint public cost = .015 ether;
uint public maxSupply = 3000;
uint public freeForHobos = 450;
bool public paused = true;
bool public revealed = false;
bool public freeClaimPeriod = true;
mapping(address => uint) public addressMintedBalance;
mapping(address => bool) public freeMintClaimed;
constructor(
address payable[] memory newShareholders,
uint256[] memory newShares
) ERC721A("Yurd Sale", "YS")payable{
}
function _startTokenId() internal view virtual override returns (uint256) {
}
modifier mintCompliance(uint256 quantity) {
uint howManyHobos = hoboTown.balanceOf(msg.sender);
require(paused == false, "Contract is paused");
require(_totalMinted() + quantity <= maxSupply, "Collection is capped at 3,000");
require(tx.origin == msg.sender, "No contracts!");
require(quantity <= maxPerMint, "You can't mint this many at once.");
require(addressMintedBalance[msg.sender] + quantity <= maxPerWallet, "You minted as many as you can already.");
if (howManyHobos < 1) {
require(msg.value == cost * quantity, "Insufficient Funds.");
} else {
require(<FILL_ME>)
require(freeClaimPeriod == true, "Free claim period is over.");
require(freeForHobos > 0, "No more free claims left.");
require(msg.value == (cost * (quantity - 1)), "Insufficient Funds.");
freeMintClaimed[msg.sender] = true;
freeForHobos -=1;
}
_;
}
function mint(uint256 quantity) mintCompliance(quantity) external payable
{
}
function ownerMint(uint256 quantity) external onlyOwner
{
}
function setBaseURI(string memory baseURI) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint tokenId) public view virtual override returns (string memory) {
}
function setPause(bool _state) external onlyOwner {
}
function reveal(bool _state, string memory baseURI) external onlyOwner {
}
function setFreeClaimPeriod(bool _state) external onlyOwner {
}
}
| freeMintClaimed[msg.sender]==false,"You already claimed your free mint." | 461,741 | freeMintClaimed[msg.sender]==false |
"Insufficient Funds." | /// SPDX-License-Identifier: MIT
/*
██╗ ██╗██╗ ██╗██████╗ ██████╗ ███████╗ █████╗ ██╗ ███████╗
╚██╗ ██╔╝██║ ██║██╔══██╗██╔══██╗ ██╔════╝██╔══██╗██║ ██╔════╝
╚████╔╝ ██║ ██║██████╔╝██║ ██║ ███████╗███████║██║ █████╗
╚██╔╝ ██║ ██║██╔══██╗██║ ██║ ╚════██║██╔══██║██║ ██╔══╝
██║ ╚██████╔╝██║ ██║██████╔╝ ███████║██║ ██║███████╗███████╗
╚═╝ ╚═════╝ ╚═╝ ╚═╝╚═════╝ ╚══════╝╚═╝ ╚═╝╚══════╝╚══════╝
hobotownyurdsale.wtf
*/
pragma solidity ^0.8.13;
import "./Strings.sol";
import "./Shareholders.sol";
import "./ERC721A.sol";
contract YurdSale is ERC721A, Shareholders {
using Strings for uint;
IERC721A public hoboTown = ERC721A(0x6e0418050387C6C3d4Cd206d8b89788BBd432525);
string public _baseTokenURI ="ipfs://QmRA34RsEpsi2XPjJERq4MXmSQ7dnjAA3ZXfkmdhd59SSj/";
uint public maxPerMint = 5;
uint public maxPerWallet = 25;
uint public cost = .015 ether;
uint public maxSupply = 3000;
uint public freeForHobos = 450;
bool public paused = true;
bool public revealed = false;
bool public freeClaimPeriod = true;
mapping(address => uint) public addressMintedBalance;
mapping(address => bool) public freeMintClaimed;
constructor(
address payable[] memory newShareholders,
uint256[] memory newShares
) ERC721A("Yurd Sale", "YS")payable{
}
function _startTokenId() internal view virtual override returns (uint256) {
}
modifier mintCompliance(uint256 quantity) {
uint howManyHobos = hoboTown.balanceOf(msg.sender);
require(paused == false, "Contract is paused");
require(_totalMinted() + quantity <= maxSupply, "Collection is capped at 3,000");
require(tx.origin == msg.sender, "No contracts!");
require(quantity <= maxPerMint, "You can't mint this many at once.");
require(addressMintedBalance[msg.sender] + quantity <= maxPerWallet, "You minted as many as you can already.");
if (howManyHobos < 1) {
require(msg.value == cost * quantity, "Insufficient Funds.");
} else {
require(freeMintClaimed[msg.sender] == false, "You already claimed your free mint.");
require(freeClaimPeriod == true, "Free claim period is over.");
require(freeForHobos > 0, "No more free claims left.");
require(<FILL_ME>)
freeMintClaimed[msg.sender] = true;
freeForHobos -=1;
}
_;
}
function mint(uint256 quantity) mintCompliance(quantity) external payable
{
}
function ownerMint(uint256 quantity) external onlyOwner
{
}
function setBaseURI(string memory baseURI) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint tokenId) public view virtual override returns (string memory) {
}
function setPause(bool _state) external onlyOwner {
}
function reveal(bool _state, string memory baseURI) external onlyOwner {
}
function setFreeClaimPeriod(bool _state) external onlyOwner {
}
}
| msg.value==(cost*(quantity-1)),"Insufficient Funds." | 461,741 | msg.value==(cost*(quantity-1)) |
"trading is already open" | // SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/ERC20.sol)
pragma solidity ^0.8.13;
import {IERC20} from "./interfaces/IERC20.sol";
import {IERC20Metadata} from "./extensions/IERC20Metadata.sol";
import {IUniswapV2Router02} from "./interfaces/IUniswapRouter02.sol";
import {IUniswapV2Factory} from "./interfaces/IUniswapV2Factory.sol";
import {Context} from "./utils/Context.sol";
/**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
*
* TIP: For a detailed writeup see our guide
* https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
* to implement supply mechanisms].
*
* The default value of {decimals} is 18. To change this, you should override
* this function so it returns a different value.
*
* We have followed general OpenZeppelin Contracts guidelines: functions revert
* instead returning `false` on failure. This behavior is nonetheless
* conventional and does not conflict with the expectations of ERC20
* applications.
*
* Additionally, an {Approval} event is emitted on calls to {transferFrom}.
* This allows applications to reconstruct the allowance for all accounts just
* by listening to said events. Other implementations of the EIP may not emit
* these events, as it isn't required by the specification.
*
* Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
* functions have been added to mitigate the well-known issues around setting
* allowances. See {IERC20-approve}.
*/
contract Token is Context, IERC20 {
mapping(address account => uint256) private _balances;
mapping(address account => mapping(address spender => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint256 public transferTax;
address private uniswapV2Pair;
IUniswapV2Router02 private uniswapV2Router;
bool public isTradeable;
address public owner;
/**
* @dev Indicates a failed `decreaseAllowance` request.
*/
error ERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);
/**
* @dev Sets the values for {name} and {symbol}.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor(
string memory name_,
string memory symbol_,
address owner_,
uint256 transferTax_) {
}
/**
* @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 default value returned by this function, unless
* it's 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 `value`.
*/
function transfer(address to, uint256 value) 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 `value` 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 value) 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 `value`.
* - the caller must have allowance for ``from``'s tokens of at least
* `value`.
*/
function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `requestedDecrease`.
*
* NOTE: Although this function is designed to avoid double spending with {approval},
* it can still be frontrunned, preventing any attempt of allowance reduction.
*/
function decreaseAllowance(address spender, uint256 requestedDecrease) public virtual returns (bool) {
}
/**
* @dev Moves a `value` amount of tokens from `from` to `to`.
*
* 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.
*
* NOTE: This function is not virtual, {_update} should be overridden instead.
*/
function _transfer(address from, address to, uint256 value) internal {
}
/**
* @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from` (or `to`) is
* the zero address. All customizations to transfers, mints, and burns should be done by overriding this function.
*
* Emits a {Transfer} event.
*/
function _update(address from, address to, uint256 value) internal virtual {
}
/**
* @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).
* Relies on the `_update` mechanism
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* NOTE: This function is not virtual, {_update} should be overridden instead.
*/
function _mint(address account, uint256 value) internal {
}
/**
* @dev Destroys a `value` amount of tokens from `account`, by transferring it to address(0).
* Relies on the `_update` mechanism.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* NOTE: This function is not virtual, {_update} should be overridden instead
*/
function _burn(address account, uint256 value) internal {
}
/**
* @dev Sets `value` 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 value) internal virtual {
}
/**
* @dev Alternative version of {_approve} with an optional flag that can enable or disable the Approval event.
*
* By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by
* `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any
* `Approval` event during `transferFrom` operations.
*
* Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to true
* using the following override:
* ```
* function _approve(address owner, address spender, uint256 value, bool) internal virtual override {
* super._approve(owner, spender, value, true);
* }
* ```
*
* Requirements are the same as {_approve}.
*/
function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {
}
/**
* @dev Updates `owner` s allowance for `spender` based on spent `value`.
*
* Does not update the allowance value in case of infinite allowance.
* Revert if not enough allowance is available.
*
* Might emit an {Approval} event.
*/
function _spendAllowance(address owner, address spender, uint256 value) internal virtual {
}
// --------- EXTENSIONS FOR TRADING -----------
function renounceOwnership() public {
}
// onlyOwner modifier
modifier onlyOwner() {
}
// closes trading and disables transfers
function openTrading() external payable onlyOwner() {
require(<FILL_ME>)
uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
_approve(address(this), address(uniswapV2Router), balanceOf(address(this)));
uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair(address(this), uniswapV2Router.WETH());
uniswapV2Router.addLiquidityETH{value: address(this).balance}(address(this),balanceOf(address(this)),0,0,owner,block.timestamp);
IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max);
isTradeable = true;
}
}
| !isTradeable,"trading is already open" | 461,884 | !isTradeable |
"E09" | /**
*Submitted for verification at Etherscan.io on 2022-03-31
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.7;
library SafeMath {
/**
* @dev Multiplies two unsigned integers, reverts on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Integer division of two unsigned integers truncating the quotient, reverts on division by zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Subtracts two unsigned integers, reverts on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Adds two unsigned integers, reverts on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Divides two unsigned integers and returns the remainder (unsigned integer modulo),
* reverts when dividing by zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract SingleSidedStakingDNXC is Ownable {
using SafeMath for uint256;
struct StakerInfo {
uint256 amount;
uint256 startStakeTime;
uint256 dnxA;
uint256 dnxB;
uint256 dnxC;
}
uint256 public stakingStart;
uint256 public stakingEnd;
uint256 public stakingClosed;
uint256 public maximumStakedDNXC;
uint256 public currentStakedDNXC;
uint256 public minimumStake;
IERC20 dnxcToken; // token being staked
mapping(address => StakerInfo) public stakerInfo;
uint256 internal fee;
bool paused;
bool emergencyUnstake;
constructor(uint256 _minimumStake, uint256 _maximumStakedDNXC, uint256 _stakingStart, uint256 _stakingClosed, uint256 _stakingEnd, IERC20 _dnxcToken)
{
}
function changePause(bool _pause) onlyOwner public {
}
function changeEmergency(bool _emergencyUnstake) onlyOwner public {
}
function changeEndTime(uint256 endTime) public onlyOwner {
}
function changeCloseTime(uint256 closeTime) public onlyOwner {
}
function changeStartTime(uint256 startTime) public onlyOwner {
}
function changeDNX(uint256 _dnxA, uint256 _dnxB, uint256 _dnxC) public {
}
function stake(uint256 _amount, uint256 _dnxA, uint256 _dnxB, uint256 _dnxC) public {
require (paused == false, "E09");
require (block.timestamp >= stakingStart, "E07");
require (block.timestamp <= stakingClosed, "E08");
require(<FILL_ME>)
StakerInfo storage user = stakerInfo[msg.sender];
require (user.amount.add(_amount) >= minimumStake, "E01");
require (dnxcToken.transferFrom(msg.sender, address(this), _amount), "E02");
currentStakedDNXC = currentStakedDNXC.add(_amount);
if (user.amount == 0) {
user.startStakeTime = block.timestamp;
}
user.amount = user.amount.add(_amount);
user.dnxA = _dnxA;
user.dnxB = _dnxB;
user.dnxC = _dnxC;
}
function unstake() public {
}
}
| currentStakedDNXC.add(_amount)<=maximumStakedDNXC,"E09" | 461,959 | currentStakedDNXC.add(_amount)<=maximumStakedDNXC |
"E01" | /**
*Submitted for verification at Etherscan.io on 2022-03-31
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.7;
library SafeMath {
/**
* @dev Multiplies two unsigned integers, reverts on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Integer division of two unsigned integers truncating the quotient, reverts on division by zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Subtracts two unsigned integers, reverts on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Adds two unsigned integers, reverts on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Divides two unsigned integers and returns the remainder (unsigned integer modulo),
* reverts when dividing by zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract SingleSidedStakingDNXC is Ownable {
using SafeMath for uint256;
struct StakerInfo {
uint256 amount;
uint256 startStakeTime;
uint256 dnxA;
uint256 dnxB;
uint256 dnxC;
}
uint256 public stakingStart;
uint256 public stakingEnd;
uint256 public stakingClosed;
uint256 public maximumStakedDNXC;
uint256 public currentStakedDNXC;
uint256 public minimumStake;
IERC20 dnxcToken; // token being staked
mapping(address => StakerInfo) public stakerInfo;
uint256 internal fee;
bool paused;
bool emergencyUnstake;
constructor(uint256 _minimumStake, uint256 _maximumStakedDNXC, uint256 _stakingStart, uint256 _stakingClosed, uint256 _stakingEnd, IERC20 _dnxcToken)
{
}
function changePause(bool _pause) onlyOwner public {
}
function changeEmergency(bool _emergencyUnstake) onlyOwner public {
}
function changeEndTime(uint256 endTime) public onlyOwner {
}
function changeCloseTime(uint256 closeTime) public onlyOwner {
}
function changeStartTime(uint256 startTime) public onlyOwner {
}
function changeDNX(uint256 _dnxA, uint256 _dnxB, uint256 _dnxC) public {
}
function stake(uint256 _amount, uint256 _dnxA, uint256 _dnxB, uint256 _dnxC) public {
require (paused == false, "E09");
require (block.timestamp >= stakingStart, "E07");
require (block.timestamp <= stakingClosed, "E08");
require (currentStakedDNXC.add(_amount) <= maximumStakedDNXC, "E09");
StakerInfo storage user = stakerInfo[msg.sender];
require(<FILL_ME>)
require (dnxcToken.transferFrom(msg.sender, address(this), _amount), "E02");
currentStakedDNXC = currentStakedDNXC.add(_amount);
if (user.amount == 0) {
user.startStakeTime = block.timestamp;
}
user.amount = user.amount.add(_amount);
user.dnxA = _dnxA;
user.dnxB = _dnxB;
user.dnxC = _dnxC;
}
function unstake() public {
}
}
| user.amount.add(_amount)>=minimumStake,"E01" | 461,959 | user.amount.add(_amount)>=minimumStake |
"E02" | /**
*Submitted for verification at Etherscan.io on 2022-03-31
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.7;
library SafeMath {
/**
* @dev Multiplies two unsigned integers, reverts on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Integer division of two unsigned integers truncating the quotient, reverts on division by zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Subtracts two unsigned integers, reverts on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Adds two unsigned integers, reverts on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Divides two unsigned integers and returns the remainder (unsigned integer modulo),
* reverts when dividing by zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract SingleSidedStakingDNXC is Ownable {
using SafeMath for uint256;
struct StakerInfo {
uint256 amount;
uint256 startStakeTime;
uint256 dnxA;
uint256 dnxB;
uint256 dnxC;
}
uint256 public stakingStart;
uint256 public stakingEnd;
uint256 public stakingClosed;
uint256 public maximumStakedDNXC;
uint256 public currentStakedDNXC;
uint256 public minimumStake;
IERC20 dnxcToken; // token being staked
mapping(address => StakerInfo) public stakerInfo;
uint256 internal fee;
bool paused;
bool emergencyUnstake;
constructor(uint256 _minimumStake, uint256 _maximumStakedDNXC, uint256 _stakingStart, uint256 _stakingClosed, uint256 _stakingEnd, IERC20 _dnxcToken)
{
}
function changePause(bool _pause) onlyOwner public {
}
function changeEmergency(bool _emergencyUnstake) onlyOwner public {
}
function changeEndTime(uint256 endTime) public onlyOwner {
}
function changeCloseTime(uint256 closeTime) public onlyOwner {
}
function changeStartTime(uint256 startTime) public onlyOwner {
}
function changeDNX(uint256 _dnxA, uint256 _dnxB, uint256 _dnxC) public {
}
function stake(uint256 _amount, uint256 _dnxA, uint256 _dnxB, uint256 _dnxC) public {
require (paused == false, "E09");
require (block.timestamp >= stakingStart, "E07");
require (block.timestamp <= stakingClosed, "E08");
require (currentStakedDNXC.add(_amount) <= maximumStakedDNXC, "E09");
StakerInfo storage user = stakerInfo[msg.sender];
require (user.amount.add(_amount) >= minimumStake, "E01");
require(<FILL_ME>)
currentStakedDNXC = currentStakedDNXC.add(_amount);
if (user.amount == 0) {
user.startStakeTime = block.timestamp;
}
user.amount = user.amount.add(_amount);
user.dnxA = _dnxA;
user.dnxB = _dnxB;
user.dnxC = _dnxC;
}
function unstake() public {
}
}
| dnxcToken.transferFrom(msg.sender,address(this),_amount),"E02" | 461,959 | dnxcToken.transferFrom(msg.sender,address(this),_amount) |
"E08" | /**
*Submitted for verification at Etherscan.io on 2022-03-31
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.7;
library SafeMath {
/**
* @dev Multiplies two unsigned integers, reverts on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Integer division of two unsigned integers truncating the quotient, reverts on division by zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Subtracts two unsigned integers, reverts on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Adds two unsigned integers, reverts on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Divides two unsigned integers and returns the remainder (unsigned integer modulo),
* reverts when dividing by zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract SingleSidedStakingDNXC is Ownable {
using SafeMath for uint256;
struct StakerInfo {
uint256 amount;
uint256 startStakeTime;
uint256 dnxA;
uint256 dnxB;
uint256 dnxC;
}
uint256 public stakingStart;
uint256 public stakingEnd;
uint256 public stakingClosed;
uint256 public maximumStakedDNXC;
uint256 public currentStakedDNXC;
uint256 public minimumStake;
IERC20 dnxcToken; // token being staked
mapping(address => StakerInfo) public stakerInfo;
uint256 internal fee;
bool paused;
bool emergencyUnstake;
constructor(uint256 _minimumStake, uint256 _maximumStakedDNXC, uint256 _stakingStart, uint256 _stakingClosed, uint256 _stakingEnd, IERC20 _dnxcToken)
{
}
function changePause(bool _pause) onlyOwner public {
}
function changeEmergency(bool _emergencyUnstake) onlyOwner public {
}
function changeEndTime(uint256 endTime) public onlyOwner {
}
function changeCloseTime(uint256 closeTime) public onlyOwner {
}
function changeStartTime(uint256 startTime) public onlyOwner {
}
function changeDNX(uint256 _dnxA, uint256 _dnxB, uint256 _dnxC) public {
}
function stake(uint256 _amount, uint256 _dnxA, uint256 _dnxB, uint256 _dnxC) public {
}
function unstake() public {
require(<FILL_ME>)
StakerInfo storage user = stakerInfo[msg.sender];
dnxcToken.transfer(
msg.sender,
user.amount
);
currentStakedDNXC = currentStakedDNXC.sub(user.amount);
user.amount = 0;
user.dnxA = 0;
user.dnxB = 0;
user.dnxC = 0;
}
}
| emergencyUnstake||block.timestamp>=stakingEnd||block.timestamp<=stakingClosed,"E08" | 461,959 | emergencyUnstake||block.timestamp>=stakingEnd||block.timestamp<=stakingClosed |
"no co-token" | pragma solidity >=0.8.0;
contract CrosschainERC20 is ERC20Burnable {
using SafeERC20 for ERC20;
event MinterSet(address indexed minter);
modifier onlyMinter() {
}
ERC20 public coToken;
address public minter;
uint8 private decimals_;
constructor(
ERC20 _coToken,
address _minter,
string memory _name,
string memory _symbol,
uint8 _decimals
) ERC20(_name, _symbol) {
}
function decimals() public view virtual override returns (uint8) {
}
function transferMintership(address _newMinter) public onlyMinter {
}
function deposit(uint256 _amount) public {
}
function depositTo(address _to, uint256 _amount) public {
require(<FILL_ME>)
coToken.safeTransferFrom(msg.sender, address(this), _amount);
_mint(_to, _amount);
}
function withdraw(uint256 _amount) public {
}
function withdrawTo(address _to, uint256 _amount) public {
}
function mint(address _to, uint256 _amount) public onlyMinter returns (bool) {
}
}
| address(coToken)!=address(0),"no co-token" | 462,001 | address(coToken)!=address(0) |
"EZF: Max Wallet Limit" | /**
https://t.me/EZFreelanceErc
https://www.EZFreelance.org
*/
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.7;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function transferOwnership(address _newOwner) public virtual 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 EZFREELANCE is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isOutFromFee;
mapping (address => bool) private isBlacklisted;
uint256 private time;
uint256 private bTime;
uint256 private _totalSupply = 10**8 * 10**18;
struct TaxStructure {
uint256 totalPc;
uint256 pcMarketing;
uint256 pcDevelopment;
uint256 pcLP;
}
TaxStructure private sellTax = TaxStructure(50,25,15,10);
TaxStructure private buyTax = TaxStructure(200,110,70,20);
TaxStructure private ZERO = TaxStructure(0,0,0,0);
TaxStructure private initialTax = TaxStructure(990,635,345,10);
TaxStructure private initialSellTax = TaxStructure(500,325,165,10);
string private constant _name = unicode"EZ Freelance";
string private constant _symbol = unicode"EZF";
uint8 private constant _decimals = 18;
uint256 private _maxTxAmount = _totalSupply.div(100);
uint256 private _maxWalletAmount = _totalSupply.div(50);
uint256 private liquidityParkedTokens = 0;
uint256 private marketingParkedTokens = 0;
uint256 private developmentParkedTokens = 0;
uint256 private minBalance = _totalSupply.div(10000);
address payable private _marketingWallet;
address payable private _developmentWallet;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2PairAddress;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
modifier lockTheSwap {
}
constructor () payable {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function updateBuyTax(uint256 _marketing,uint256 _development,uint256 _lp) external onlyOwner {
}
function updateSellTax(uint256 _marketing,uint256 _development,uint256 _lp) external onlyOwner {
}
function updateLimits(uint256 maxTransactionPer,uint256 maxWalletPer) external onlyOwner {
}
function removeLimits() external onlyOwner{
}
function excludeFromFees(address[] calldata target) external onlyOwner{
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "EZF: Transfer from the zero address");
require(to != address(0), "EZF: Transfer to the zero address");
if (from != owner() && to != owner()) {
require(tradingOpen,"EZF: trading != true");
require(!isBlacklisted[from] && !isBlacklisted[to]);
TaxStructure storage _tax = ZERO;
if(!_isOutFromFee[to]){
require(<FILL_ME>)
require(amount <= _maxTxAmount,"EZF: Max TxAmount Limit");
if (from == uniswapV2PairAddress && to != address(uniswapV2Router)){
_tax = buyTax;
}
if(bTime > block.number){
_tax = initialTax;
}
}
else if (to == uniswapV2PairAddress && from != address(uniswapV2Router) && ! _isOutFromFee[from]) {
if(block.timestamp > time){
_tax = sellTax;
}else{
_tax = initialSellTax;
}
}
if (!inSwap && from != uniswapV2PairAddress && swapEnabled && !_isOutFromFee[from] && balanceOf(address(this)) > minBalance) {
swapBack(false);
}
if(_tax.totalPc>0){
uint256 txTax = amount.mul(_tax.totalPc).div(1000);
amount = amount.sub(txTax);
liquidityParkedTokens = liquidityParkedTokens.add(txTax.mul(_tax.pcLP).div(_tax.totalPc));
marketingParkedTokens = marketingParkedTokens.add(txTax.mul(_tax.pcMarketing).div(_tax.totalPc));
developmentParkedTokens = developmentParkedTokens.add(txTax.mul(_tax.pcDevelopment).div(_tax.totalPc));
_transferStandard(from,address(this),txTax);
}
}
_transferStandard(from,to,amount);
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount,uint256 ethValue) private {
}
function swapBack(bool _force) private lockTheSwap {
}
function enableTrading() external onlyOwner {
}
function setBlacklist(address[] memory _isBlacklisted) public onlyOwner {
}
function removeBlacklist(address[] memory notbot) public onlyOwner {
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
}
receive() external payable {}
function manualSwap() external onlyOwner{
}
function recoverTokens(address tokenAddress) external onlyOwner {
}
}
| (_balOwned[to]+amount)<=_maxWalletAmount,"EZF: Max Wallet Limit" | 462,006 | (_balOwned[to]+amount)<=_maxWalletAmount |
"Address is not allowed during Pre-sale" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract TheDrones is ERC721A, Ownable, Pausable, ReentrancyGuard {
using Strings for uint256;
enum MintPhase {
CLOSED,
OG,
ALLOW_LIST,
PUBLIC
}
// Configuration: Metadata
string public baseURI;
// Configuration: Opensea proxy
address public immutable proxyRegistryAddress;
mapping(address => bool) public projectProxy;
// Configuration: General
uint256 public immutable maxSupply;
uint256 public price = 0.16 ether;
MintPhase public phase = MintPhase.CLOSED;
// Configuration: OG Mint
bytes32 public ogMerkleRoot;
uint256 public maxPerOgMinter = 4; // Actually 3, this is to avoid using <=
// Configuration: Allowlist Mint
bytes32 public allowlistMerkleRoot;
uint256 public maxPerAllowlistMinter = 3; // Actually 2, this is to avoid using <=
// Configuration: Public Mint
uint256 public maxPerPublicTx = 6; // Actually 5, this is to avoid using <=
// Withdraw accounts
address private constant WALLET_D = 0x9193052B1843d7F2cAF37728756F062922eCd51d;
address private constant WALLET_C = 0x9aBC658a4d3E82585Fb38e6D695a017e50D96564;
address private constant WALLET_S = 0x55429B1f76bfEC0aEc3Ce0b444E208a96d916fe5;
address private constant WALLET_K = 0x8653CB49dEB429745eD0581dA763D1014e2d0E03;
constructor(
string memory _initBaseUri,
uint256 _maxSupply,
address _proxyRegistryAddress
) ERC721A("DRONES", "DRONES") {
}
// ERC721A overrides ===========================================================================
function _baseURI() internal view virtual override returns (string memory) {
}
// When the contract is paused, all token transfers are prevented in case of emergency
function _beforeTokenTransfers(
address from,
address to,
uint256 tokenId,
uint256 quantity
) internal override(ERC721A) whenNotPaused {
}
// Admin functions =============================================================================
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setOgMerkleRoot(bytes32 _ogMerkleRoot) external onlyOwner {
}
function setAllowlistMerkleRoot(bytes32 _allowlistMerkleRoot) external onlyOwner {
}
function setMaxPerOgMinter(uint256 _maxPerOgMinter) external onlyOwner {
}
function setMaxPerAllowlistMinter(uint256 _maxPerAllowlistMinter) external onlyOwner {
}
function setMaxPerPublicTx(uint256 _maxPerPublicTx) external onlyOwner {
}
function setPhase(MintPhase _mintPhase) external onlyOwner {
}
// Update price in case of major ETH fluctuations
function setPrice(uint256 _price) external onlyOwner {
}
function flipProxyState(address proxyAddress) public onlyOwner {
}
/* solhint-disable avoid-low-level-calls */
function withdraw() external nonReentrant onlyOwner {
} /* solhint-enable avoid-low-level-calls */
// Public functions ============================================================================
function numberMinted(address owner) public view returns (uint256) {
}
function totalMinted() public view returns (uint256) {
}
function tokensOfOwner(address owner) public view returns (uint256[] memory) {
}
// Minting functions ===========================================================================
function _mintPresale(
address buyer,
uint256 quantity,
bytes32[] calldata proof,
bytes32 merkleRoot,
uint256 limit
) internal {
string memory payload = string(abi.encodePacked(buyer));
require(<FILL_ME>)
require(quantity < limit, "Exceeds Pre-sale per transaction limit");
require(numberMinted(_msgSender()) + quantity < limit, "Exceeds total Pre-sale purchase limit");
require(price * quantity == msg.value, "Incorrect amount of funds provided");
_safeMint(buyer, quantity);
}
function mintOg(uint256 quantity, bytes32[] calldata proof) external payable nonReentrant {
}
function mintAllowlist(uint256 quantity, bytes32[] calldata proof) external payable nonReentrant {
}
function mintPublic(uint256 quantity) external payable nonReentrant {
}
// Merkle tree functions =======================================================================
function _leaf(string memory payload) internal pure returns (bytes32) {
}
function _verify(
bytes32 merkleRoot,
bytes32 leaf,
bytes32[] memory proof
) internal pure returns (bool) {
}
// Opensea approval fee removal ================================================================
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
}
// solhint-disable-next-line no-empty-blocks
contract OwnableDelegateProxy {
}
contract OpenSeaProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
| _verify(merkleRoot,_leaf(payload),proof),"Address is not allowed during Pre-sale" | 462,103 | _verify(merkleRoot,_leaf(payload),proof) |
"Exceeds total Pre-sale purchase limit" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract TheDrones is ERC721A, Ownable, Pausable, ReentrancyGuard {
using Strings for uint256;
enum MintPhase {
CLOSED,
OG,
ALLOW_LIST,
PUBLIC
}
// Configuration: Metadata
string public baseURI;
// Configuration: Opensea proxy
address public immutable proxyRegistryAddress;
mapping(address => bool) public projectProxy;
// Configuration: General
uint256 public immutable maxSupply;
uint256 public price = 0.16 ether;
MintPhase public phase = MintPhase.CLOSED;
// Configuration: OG Mint
bytes32 public ogMerkleRoot;
uint256 public maxPerOgMinter = 4; // Actually 3, this is to avoid using <=
// Configuration: Allowlist Mint
bytes32 public allowlistMerkleRoot;
uint256 public maxPerAllowlistMinter = 3; // Actually 2, this is to avoid using <=
// Configuration: Public Mint
uint256 public maxPerPublicTx = 6; // Actually 5, this is to avoid using <=
// Withdraw accounts
address private constant WALLET_D = 0x9193052B1843d7F2cAF37728756F062922eCd51d;
address private constant WALLET_C = 0x9aBC658a4d3E82585Fb38e6D695a017e50D96564;
address private constant WALLET_S = 0x55429B1f76bfEC0aEc3Ce0b444E208a96d916fe5;
address private constant WALLET_K = 0x8653CB49dEB429745eD0581dA763D1014e2d0E03;
constructor(
string memory _initBaseUri,
uint256 _maxSupply,
address _proxyRegistryAddress
) ERC721A("DRONES", "DRONES") {
}
// ERC721A overrides ===========================================================================
function _baseURI() internal view virtual override returns (string memory) {
}
// When the contract is paused, all token transfers are prevented in case of emergency
function _beforeTokenTransfers(
address from,
address to,
uint256 tokenId,
uint256 quantity
) internal override(ERC721A) whenNotPaused {
}
// Admin functions =============================================================================
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setOgMerkleRoot(bytes32 _ogMerkleRoot) external onlyOwner {
}
function setAllowlistMerkleRoot(bytes32 _allowlistMerkleRoot) external onlyOwner {
}
function setMaxPerOgMinter(uint256 _maxPerOgMinter) external onlyOwner {
}
function setMaxPerAllowlistMinter(uint256 _maxPerAllowlistMinter) external onlyOwner {
}
function setMaxPerPublicTx(uint256 _maxPerPublicTx) external onlyOwner {
}
function setPhase(MintPhase _mintPhase) external onlyOwner {
}
// Update price in case of major ETH fluctuations
function setPrice(uint256 _price) external onlyOwner {
}
function flipProxyState(address proxyAddress) public onlyOwner {
}
/* solhint-disable avoid-low-level-calls */
function withdraw() external nonReentrant onlyOwner {
} /* solhint-enable avoid-low-level-calls */
// Public functions ============================================================================
function numberMinted(address owner) public view returns (uint256) {
}
function totalMinted() public view returns (uint256) {
}
function tokensOfOwner(address owner) public view returns (uint256[] memory) {
}
// Minting functions ===========================================================================
function _mintPresale(
address buyer,
uint256 quantity,
bytes32[] calldata proof,
bytes32 merkleRoot,
uint256 limit
) internal {
string memory payload = string(abi.encodePacked(buyer));
require(_verify(merkleRoot, _leaf(payload), proof), "Address is not allowed during Pre-sale");
require(quantity < limit, "Exceeds Pre-sale per transaction limit");
require(<FILL_ME>)
require(price * quantity == msg.value, "Incorrect amount of funds provided");
_safeMint(buyer, quantity);
}
function mintOg(uint256 quantity, bytes32[] calldata proof) external payable nonReentrant {
}
function mintAllowlist(uint256 quantity, bytes32[] calldata proof) external payable nonReentrant {
}
function mintPublic(uint256 quantity) external payable nonReentrant {
}
// Merkle tree functions =======================================================================
function _leaf(string memory payload) internal pure returns (bytes32) {
}
function _verify(
bytes32 merkleRoot,
bytes32 leaf,
bytes32[] memory proof
) internal pure returns (bool) {
}
// Opensea approval fee removal ================================================================
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
}
// solhint-disable-next-line no-empty-blocks
contract OwnableDelegateProxy {
}
contract OpenSeaProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
| numberMinted(_msgSender())+quantity<limit,"Exceeds total Pre-sale purchase limit" | 462,103 | numberMinted(_msgSender())+quantity<limit |
"Exceeds max supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract TheDrones is ERC721A, Ownable, Pausable, ReentrancyGuard {
using Strings for uint256;
enum MintPhase {
CLOSED,
OG,
ALLOW_LIST,
PUBLIC
}
// Configuration: Metadata
string public baseURI;
// Configuration: Opensea proxy
address public immutable proxyRegistryAddress;
mapping(address => bool) public projectProxy;
// Configuration: General
uint256 public immutable maxSupply;
uint256 public price = 0.16 ether;
MintPhase public phase = MintPhase.CLOSED;
// Configuration: OG Mint
bytes32 public ogMerkleRoot;
uint256 public maxPerOgMinter = 4; // Actually 3, this is to avoid using <=
// Configuration: Allowlist Mint
bytes32 public allowlistMerkleRoot;
uint256 public maxPerAllowlistMinter = 3; // Actually 2, this is to avoid using <=
// Configuration: Public Mint
uint256 public maxPerPublicTx = 6; // Actually 5, this is to avoid using <=
// Withdraw accounts
address private constant WALLET_D = 0x9193052B1843d7F2cAF37728756F062922eCd51d;
address private constant WALLET_C = 0x9aBC658a4d3E82585Fb38e6D695a017e50D96564;
address private constant WALLET_S = 0x55429B1f76bfEC0aEc3Ce0b444E208a96d916fe5;
address private constant WALLET_K = 0x8653CB49dEB429745eD0581dA763D1014e2d0E03;
constructor(
string memory _initBaseUri,
uint256 _maxSupply,
address _proxyRegistryAddress
) ERC721A("DRONES", "DRONES") {
}
// ERC721A overrides ===========================================================================
function _baseURI() internal view virtual override returns (string memory) {
}
// When the contract is paused, all token transfers are prevented in case of emergency
function _beforeTokenTransfers(
address from,
address to,
uint256 tokenId,
uint256 quantity
) internal override(ERC721A) whenNotPaused {
}
// Admin functions =============================================================================
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setOgMerkleRoot(bytes32 _ogMerkleRoot) external onlyOwner {
}
function setAllowlistMerkleRoot(bytes32 _allowlistMerkleRoot) external onlyOwner {
}
function setMaxPerOgMinter(uint256 _maxPerOgMinter) external onlyOwner {
}
function setMaxPerAllowlistMinter(uint256 _maxPerAllowlistMinter) external onlyOwner {
}
function setMaxPerPublicTx(uint256 _maxPerPublicTx) external onlyOwner {
}
function setPhase(MintPhase _mintPhase) external onlyOwner {
}
// Update price in case of major ETH fluctuations
function setPrice(uint256 _price) external onlyOwner {
}
function flipProxyState(address proxyAddress) public onlyOwner {
}
/* solhint-disable avoid-low-level-calls */
function withdraw() external nonReentrant onlyOwner {
} /* solhint-enable avoid-low-level-calls */
// Public functions ============================================================================
function numberMinted(address owner) public view returns (uint256) {
}
function totalMinted() public view returns (uint256) {
}
function tokensOfOwner(address owner) public view returns (uint256[] memory) {
}
// Minting functions ===========================================================================
function _mintPresale(
address buyer,
uint256 quantity,
bytes32[] calldata proof,
bytes32 merkleRoot,
uint256 limit
) internal {
}
function mintOg(uint256 quantity, bytes32[] calldata proof) external payable nonReentrant {
}
function mintAllowlist(uint256 quantity, bytes32[] calldata proof) external payable nonReentrant {
}
function mintPublic(uint256 quantity) external payable nonReentrant {
require(phase == MintPhase.PUBLIC, "Public sale is not active");
require(<FILL_ME>)
require(quantity < maxPerPublicTx, "Exceeds max per transaction");
require(price * quantity == msg.value, "Incorrect amount of funds provided");
_safeMint(_msgSender(), quantity);
}
// Merkle tree functions =======================================================================
function _leaf(string memory payload) internal pure returns (bytes32) {
}
function _verify(
bytes32 merkleRoot,
bytes32 leaf,
bytes32[] memory proof
) internal pure returns (bool) {
}
// Opensea approval fee removal ================================================================
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
}
// solhint-disable-next-line no-empty-blocks
contract OwnableDelegateProxy {
}
contract OpenSeaProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
| totalMinted()+quantity<=maxSupply,"Exceeds max supply" | 462,103 | totalMinted()+quantity<=maxSupply |
"You have already placed a bet" | pragma solidity ^0.8.11;
contract ssdapp is ATM, Ownable {
event NewBet(
address addy,
uint amount,
uint teamId
);
struct Bet {
string name;
address addy;
uint amount;
uint teamId;
}
struct Team {
string name;
uint totalBetAmount;
}
Bet[] public bets;
Team[] public teams;
address payable conOwner;
uint public totalBetMoney = 0;
uint public numTeams;
using SafeMath for uint256;
mapping (address => uint) public numBetsAddress;
bool private locked;
modifier nonReentrant() {
}
constructor() payable {
}
function createTeam (string memory _name) public onlyOwner() {
}
function getTotalBetAmount (uint _teamId) public view returns (uint) {
}
function getTotalBetMoney() public view returns (uint) {
}
function getAllTeams() public view returns (Team[] memory) {
}
function createBet (string memory _name, uint _teamId) external payable {
require(msg.sender != conOwner, "Owner can't make a bet");
uint256 minBetAmount = 0.01 ether;
uint256 maxBetAmount = 0.1 ether;
require(msg.value >= minBetAmount, "Bet amount is less than the minimum bet");
require(msg.value <= maxBetAmount, "Bet amount exceeds the maximum bet");
require(<FILL_ME>)
deposit();
bets.push(Bet(_name, msg.sender, msg.value, _teamId));
teams[_teamId].totalBetAmount += msg.value;
numBetsAddress[msg.sender]++;
(bool sent, bytes memory data) = conOwner.call{value: msg.value}("");
require(sent, "Failed to send Ether");
totalBetMoney += msg.value;
emit NewBet(msg.sender, msg.value, _teamId);
}
function teamWinDistribution(uint _teamId) external payable onlyOwner() nonReentrant() {
}
function reset() external onlyOwner() {
}
receive() external payable {
}
}
| numBetsAddress[msg.sender]==0,"You have already placed a bet" | 462,112 | numBetsAddress[msg.sender]==0 |
"caller must be beneficiary" | pragma solidity ^0.8.0;
contract AdvisorTokenClaimer2 is Ownable {
using SafeERC20 for IERC20;
using Math for uint256;
address public melosToken;
// 0x1afb69DBC9f54d08DAB1bD3436F8Da1af819E647;
uint256 public fromTime;
uint256 public toTime;
address public beneficiary;
uint256 public totalAmount;
uint256 public withdrawnAmount;
uint256 public constant TOTAL_PERIOD = 600 days;
constructor(
address _token,
address _beneficiary,
uint256 _amount,
uint256 _fromTime
) {
}
function setBeneficiaryAddress(address _old, address _new)
external
onlyOwner
{
}
function getVestedAmount() public view returns (uint256) {
}
function getWithdrawableAmount() public view returns (uint256) {
}
function withdraw() external {
require(<FILL_ME>)
uint256 amount = getWithdrawableAmount();
if (amount > 0) {
IERC20(melosToken).safeTransfer(beneficiary, amount);
withdrawnAmount = withdrawnAmount + amount;
}
}
}
| _msgSender()==beneficiary,"caller must be beneficiary" | 462,331 | _msgSender()==beneficiary |
"DCC: This function is for Crossmint only." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
// @author: olive
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// //
// //
// //
// ▄████ ▄▄▄ ███▄ █ ▄████ ▄▄▄ ███▄ █ ▒█████ ███▄ ▄███▓ ▄▄▄ ▓█████▄ ██████ //
// ██▒ ▀█▒▒████▄ ██ ▀█ █ ██▒ ▀█▒▒████▄ ██ ▀█ █ ▒██▒ ██▒▓██▒▀█▀ ██▒▒████▄ ▒██▀ ██▌▒██ ▒ //
// ▒██░▄▄▄░▒██ ▀█▄ ▓██ ▀█ ██▒▒██░▄▄▄░▒██ ▀█▄ ▓██ ▀█ ██▒▒██░ ██▒▓██ ▓██░▒██ ▀█▄ ░██ █▌░ ▓██▄ //
// ░▓█ ██▓░██▄▄▄▄██ ▓██▒ ▐▌██▒░▓█ ██▓░██▄▄▄▄██ ▓██▒ ▐▌██▒▒██ ██░▒██ ▒██ ░██▄▄▄▄██ ░▓█▄ ▌ ▒ ██▒ //
// ░▒▓███▀▒ ▓█ ▓██▒▒██░ ▓██░░▒▓███▀▒ ▓█ ▓██▒ ▒██░ ▓██░░ ████▓▒░▒██▒ ░██▒ ▓█ ▓██▒░▒████▓ ▒██████▒▒ //
// ░▒ ▒ ▒▒ ▓▒█░░ ▒░ ▒ ▒ ░▒ ▒ ▒▒ ▓▒█░ ░ ▒░ ▒ ▒ ░ ▒░▒░▒░ ░ ▒░ ░ ░ ▒▒ ▓▒█░ ▒▒▓ ▒ ▒ ▒▓▒ ▒ ░ //
// ░ ░ ▒ ▒▒ ░░ ░░ ░ ▒░ ░ ░ ▒ ▒▒ ░ ░ ░░ ░ ▒░ ░ ▒ ▒░ ░ ░ ░ ▒ ▒▒ ░ ░ ▒ ▒ ░ ░▒ ░ ░ //
// ░ ░ ░ ░ ▒ ░ ░ ░ ░ ░ ░ ░ ▒ ░ ░ ░ ░ ░ ░ ▒ ░ ░ ░ ▒ ░ ░ ░ ░ ░ ░ //
// ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ //
// ░ //
// //
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
contract GangaNomads is ERC721AQueryable, Ownable, ReentrancyGuard {
address private signerAddress;
using SafeMath for uint256;
using Strings for uint256;
uint256 public MAX_ELEMENTS = 9696;
uint256 public PRICE = 0.2 ether;
uint256 public constant START_AT = 1;
uint256 public LIMIT_PER_MINT = 50;
bool private PAUSE = true;
uint256 private tokenIdTracker = 0;
string public baseTokenURI;
bool public META_REVEAL = false;
uint256 public HIDE_FROM = 1;
uint256 public HIDE_TO = 9696;
string public sampleTokenURI;
address public CROSSMINT_WALLET = 0xdAb1a1854214684acE522439684a145E62505233;
address public constant creatorAddress = 0x5fD345f759E6cE8619d7E3A57444093Fe0b52F66;
mapping(address => bool) internal admins;
mapping(address => uint256) mintTokenCount;
mapping(address => uint256) lastCheckPoint;
event PauseEvent(bool pause);
event NewPriceEvent(uint256 price);
event NewMaxElement(uint256 max);
constructor(address _singenr)
ERC721A("Ganga Nomads", "NOMAD")
{
}
modifier saleIsOpen() {
}
modifier onlyAdmin() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _newBaseURI)
public
onlyAdmin
{
}
function setSampleURI(string memory sampleURI) public onlyAdmin {
}
function totalToken() public view returns (uint256) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override(ERC721A, IERC721A)
returns (string memory)
{
}
function mintCountOfWallet(address _wallet) public view returns (uint256) {
}
function ownerOf(uint256 tokenId)
public
view
virtual
override(ERC721A, IERC721A)
returns (address)
{
}
function mint(
uint256 _tokenAmount,
uint256 _timestamp,
bytes memory _signature
) public payable saleIsOpen {
}
function crossmint(address _to, uint256 _tokenAmount) public payable saleIsOpen {
uint256 total = totalToken();
require(_tokenAmount <= LIMIT_PER_MINT, "GangaNomad: Max limit per mint");
require(total + _tokenAmount <= MAX_ELEMENTS, "GangaNomad: Max limit");
require(
msg.value >= price(_tokenAmount),
"GangaNomad: Value below price"
);
require(<FILL_ME>)
tokenIdTracker = tokenIdTracker + _tokenAmount;
_safeMint(_to, _tokenAmount);
}
function signatureWallet(
address wallet,
uint256 _tokenAmount,
uint256 _timestamp,
bytes memory _signature
) public pure returns (address) {
}
function setCheckPoint(address _minter, uint256 _point) public onlyOwner {
}
function getCheckPoint(address _minter) external view returns (uint256) {
}
function price(uint256 _count) public view returns (uint256) {
}
function setPause(bool _pause) public onlyAdmin {
}
function setPrice(uint256 _price) public onlyOwner {
}
function setMaxElement(uint256 _max) public onlyOwner {
}
function setMetaReveal(
bool _reveal,
uint256 _from,
uint256 _to
) public onlyAdmin {
}
function withdrawAll() public onlyAdmin {
}
function _widthdraw(address _address, uint256 _amount) private {
}
function giftMint(address[] memory _addrs, uint256[] memory _tokenAmounts)
public
onlyAdmin
{
}
function addAdminRole(address _address) external onlyOwner {
}
function revokeAdminRole(address _address) external onlyOwner {
}
function hasAdminRole(address _address) external view returns (bool) {
}
function burn(uint256[] calldata tokenIds) external onlyAdmin {
}
function updateSignerAddress(address _signer) public onlyOwner {
}
function updateCrossMintAddress(address _crossmintAddress)
public
onlyOwner
{
}
function updateLimitPerMint(uint256 _limitpermint) public onlyAdmin {
}
function _startTokenId()
internal
view
virtual
override(ERC721A)
returns (uint256)
{
}
}
| _msgSender()==CROSSMINT_WALLET,"DCC: This function is for Crossmint only." | 462,360 | _msgSender()==CROSSMINT_WALLET |
"Not allowed operator" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
// Openzepplin ERC2981
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "./royalty/DefaultOperatorFilterer.sol";
contract MainnetTest is Ownable, ERC721, ERC2981, DefaultOperatorFilterer {
using ECDSA for bytes32;
// struct
struct Configs {
uint16 quantity;
uint16 maxPerTxn;
uint32 startTime;
uint32 endTime;
uint128 price;
}
struct Phase {
Configs configs;
uint16 version;
uint16 totalMinted;
mapping(address => uint16) minted;
}
// vars
bool public revealed;
bool public enableTokenURI;
bool public enableBackupURI;
bool public enableHtmlURI;
address public verifier = 0x9f6B54d48AD2175e56a1BA9bFc74cd077213B68D;
uint16 public currentIdx = 1;
uint16 public maxSupply = 5555;
string public preRevealedURI;
string public baseURI;
string public backupURI;
string public htmlURI;
mapping(uint256 => string) public token2URI;
Phase[] public phases;
mapping(address => bool) public executors;
event PhaseModified(uint256 indexed phaseId, Configs configs);
constructor() ERC721("Mittaria Genesis", "MTG") {
}
modifier onlyAllowedExecutor() {
require(<FILL_ME>)
_;
}
/* View */
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
// verifed
function getPhaseInfo(uint256 _phaseId) external view returns (Configs memory configs, uint16 version, uint16 totalMinted) {
}
// verifed
function getTokenMintedByAccount(uint256 _phaseId, address _account) external view returns (uint16) {
}
/* User */
// verifed
function mint(uint256 _phaseId, uint16 _amount, uint16 _maxAmount, bytes calldata _signature) external payable {
}
function mintTo(address _to, uint16 _amount) external payable {
}
// verifed
function _mintToken(address _account, uint16 _amount) internal {
}
// verifed
function _verifySignature(uint256 _phaseId, address _account, uint16 _maxAmount, bytes calldata _signature) internal view {
}
/* Admin */
function setTotalSupply(uint16 _maxSupply) external onlyOwner {
}
// verifed
function _validateMintingPhase(Configs calldata _configs) internal pure {
}
// verifed
function createMintingPhase(Configs calldata _configs) external onlyOwner {
}
// verifed
function updateMintingPhase(uint256 _phaseId, Configs calldata _configs) external onlyOwner {
}
// verifed
function setExecutor(address[] memory _executors, bool _status) external onlyOwner {
}
// verifed
function setVerifier(address _verifier) external onlyOwner {
}
// verified
function toggleTokenURI(bool _status) external onlyOwner {
}
// verified
function toggleBackupURI(bool _status) external onlyOwner {
}
// verified
function toggleHtmlURI(bool _status) external onlyOwner {
}
// verified
function toggleReveal(bool _status) external onlyOwner {
}
// verified
function setPreRevealedURI(string calldata _uri) external onlyAllowedExecutor {
}
// verified
function setBaseURI(string calldata _uri) external onlyAllowedExecutor {
}
// verified
function setBackupURI(string calldata _uri) external onlyAllowedExecutor {
}
// verified
function setHtmlURI(string calldata _uri) external onlyAllowedExecutor {
}
// verifed
function setTokensURI(uint16[] calldata _tokenIds, string[] calldata _uris) external onlyAllowedExecutor {
}
// verifed
function adminMintTo(address _to, uint256 _amount) external onlyOwner {
}
function withdraw() public onlyOwner {
}
/* Royalty */
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) {
}
function setPrimaryRoyalty(address _receiver, uint96 _feeNumerator) public onlyAllowedExecutor {
}
// verified
function deleteDefaultRoyalty() public onlyAllowedExecutor {
}
// verified
function setRoyaltyInfoForToken(uint256 _tokenId, address _receiver, uint96 _feeNumerator) public onlyAllowedExecutor {
}
// verified
function resetRoyaltyInforToken(uint256 _tokenId) public onlyAllowedExecutor {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC2981, ERC721) returns (bool) {
}
}
| executors[_msgSender()]||owner()==_msgSender(),"Not allowed operator" | 462,486 | executors[_msgSender()]||owner()==_msgSender() |
"Invalid price" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
// Openzepplin ERC2981
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "./royalty/DefaultOperatorFilterer.sol";
contract MainnetTest is Ownable, ERC721, ERC2981, DefaultOperatorFilterer {
using ECDSA for bytes32;
// struct
struct Configs {
uint16 quantity;
uint16 maxPerTxn;
uint32 startTime;
uint32 endTime;
uint128 price;
}
struct Phase {
Configs configs;
uint16 version;
uint16 totalMinted;
mapping(address => uint16) minted;
}
// vars
bool public revealed;
bool public enableTokenURI;
bool public enableBackupURI;
bool public enableHtmlURI;
address public verifier = 0x9f6B54d48AD2175e56a1BA9bFc74cd077213B68D;
uint16 public currentIdx = 1;
uint16 public maxSupply = 5555;
string public preRevealedURI;
string public baseURI;
string public backupURI;
string public htmlURI;
mapping(uint256 => string) public token2URI;
Phase[] public phases;
mapping(address => bool) public executors;
event PhaseModified(uint256 indexed phaseId, Configs configs);
constructor() ERC721("Mittaria Genesis", "MTG") {
}
modifier onlyAllowedExecutor() {
}
/* View */
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
// verifed
function getPhaseInfo(uint256 _phaseId) external view returns (Configs memory configs, uint16 version, uint16 totalMinted) {
}
// verifed
function getTokenMintedByAccount(uint256 _phaseId, address _account) external view returns (uint16) {
}
/* User */
// verifed
function mint(uint256 _phaseId, uint16 _amount, uint16 _maxAmount, bytes calldata _signature) external payable {
address account = msg.sender;
require(tx.origin == account, "Not allowed");
Phase storage phase = phases[_phaseId];
require(_amount > 0, "Invalid amount");
require(phase.configs.quantity >= phase.totalMinted + _amount, "Exceed quantity");
require(phase.configs.startTime <= block.timestamp, "Not started");
require(phase.configs.endTime >= block.timestamp, "Ended");
require(phase.configs.maxPerTxn >= _amount, "Exceed max per txn");
require(_maxAmount >= phase.minted[account] + _amount, "Exceed max per wallet");
require(<FILL_ME>)
_verifySignature(_phaseId, account, _maxAmount, _signature);
phase.totalMinted += _amount;
phase.minted[account] += _amount;
_mintToken(account, _amount);
}
function mintTo(address _to, uint16 _amount) external payable {
}
// verifed
function _mintToken(address _account, uint16 _amount) internal {
}
// verifed
function _verifySignature(uint256 _phaseId, address _account, uint16 _maxAmount, bytes calldata _signature) internal view {
}
/* Admin */
function setTotalSupply(uint16 _maxSupply) external onlyOwner {
}
// verifed
function _validateMintingPhase(Configs calldata _configs) internal pure {
}
// verifed
function createMintingPhase(Configs calldata _configs) external onlyOwner {
}
// verifed
function updateMintingPhase(uint256 _phaseId, Configs calldata _configs) external onlyOwner {
}
// verifed
function setExecutor(address[] memory _executors, bool _status) external onlyOwner {
}
// verifed
function setVerifier(address _verifier) external onlyOwner {
}
// verified
function toggleTokenURI(bool _status) external onlyOwner {
}
// verified
function toggleBackupURI(bool _status) external onlyOwner {
}
// verified
function toggleHtmlURI(bool _status) external onlyOwner {
}
// verified
function toggleReveal(bool _status) external onlyOwner {
}
// verified
function setPreRevealedURI(string calldata _uri) external onlyAllowedExecutor {
}
// verified
function setBaseURI(string calldata _uri) external onlyAllowedExecutor {
}
// verified
function setBackupURI(string calldata _uri) external onlyAllowedExecutor {
}
// verified
function setHtmlURI(string calldata _uri) external onlyAllowedExecutor {
}
// verifed
function setTokensURI(uint16[] calldata _tokenIds, string[] calldata _uris) external onlyAllowedExecutor {
}
// verifed
function adminMintTo(address _to, uint256 _amount) external onlyOwner {
}
function withdraw() public onlyOwner {
}
/* Royalty */
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) {
}
function setPrimaryRoyalty(address _receiver, uint96 _feeNumerator) public onlyAllowedExecutor {
}
// verified
function deleteDefaultRoyalty() public onlyAllowedExecutor {
}
// verified
function setRoyaltyInfoForToken(uint256 _tokenId, address _receiver, uint96 _feeNumerator) public onlyAllowedExecutor {
}
// verified
function resetRoyaltyInforToken(uint256 _tokenId) public onlyAllowedExecutor {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC2981, ERC721) returns (bool) {
}
}
| phase.configs.price*_amount==msg.value,"Invalid price" | 462,486 | phase.configs.price*_amount==msg.value |
"Exceed max supply" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
// Openzepplin ERC2981
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "./royalty/DefaultOperatorFilterer.sol";
contract MainnetTest is Ownable, ERC721, ERC2981, DefaultOperatorFilterer {
using ECDSA for bytes32;
// struct
struct Configs {
uint16 quantity;
uint16 maxPerTxn;
uint32 startTime;
uint32 endTime;
uint128 price;
}
struct Phase {
Configs configs;
uint16 version;
uint16 totalMinted;
mapping(address => uint16) minted;
}
// vars
bool public revealed;
bool public enableTokenURI;
bool public enableBackupURI;
bool public enableHtmlURI;
address public verifier = 0x9f6B54d48AD2175e56a1BA9bFc74cd077213B68D;
uint16 public currentIdx = 1;
uint16 public maxSupply = 5555;
string public preRevealedURI;
string public baseURI;
string public backupURI;
string public htmlURI;
mapping(uint256 => string) public token2URI;
Phase[] public phases;
mapping(address => bool) public executors;
event PhaseModified(uint256 indexed phaseId, Configs configs);
constructor() ERC721("Mittaria Genesis", "MTG") {
}
modifier onlyAllowedExecutor() {
}
/* View */
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
// verifed
function getPhaseInfo(uint256 _phaseId) external view returns (Configs memory configs, uint16 version, uint16 totalMinted) {
}
// verifed
function getTokenMintedByAccount(uint256 _phaseId, address _account) external view returns (uint16) {
}
/* User */
// verifed
function mint(uint256 _phaseId, uint16 _amount, uint16 _maxAmount, bytes calldata _signature) external payable {
}
function mintTo(address _to, uint16 _amount) external payable {
}
// verifed
function _mintToken(address _account, uint16 _amount) internal {
require(<FILL_ME>)
uint256 _currentIdx = currentIdx;
currentIdx += _amount;
for (uint256 i = 0; i < _amount; i++) {
_mint(_account, _currentIdx + i);
}
}
// verifed
function _verifySignature(uint256 _phaseId, address _account, uint16 _maxAmount, bytes calldata _signature) internal view {
}
/* Admin */
function setTotalSupply(uint16 _maxSupply) external onlyOwner {
}
// verifed
function _validateMintingPhase(Configs calldata _configs) internal pure {
}
// verifed
function createMintingPhase(Configs calldata _configs) external onlyOwner {
}
// verifed
function updateMintingPhase(uint256 _phaseId, Configs calldata _configs) external onlyOwner {
}
// verifed
function setExecutor(address[] memory _executors, bool _status) external onlyOwner {
}
// verifed
function setVerifier(address _verifier) external onlyOwner {
}
// verified
function toggleTokenURI(bool _status) external onlyOwner {
}
// verified
function toggleBackupURI(bool _status) external onlyOwner {
}
// verified
function toggleHtmlURI(bool _status) external onlyOwner {
}
// verified
function toggleReveal(bool _status) external onlyOwner {
}
// verified
function setPreRevealedURI(string calldata _uri) external onlyAllowedExecutor {
}
// verified
function setBaseURI(string calldata _uri) external onlyAllowedExecutor {
}
// verified
function setBackupURI(string calldata _uri) external onlyAllowedExecutor {
}
// verified
function setHtmlURI(string calldata _uri) external onlyAllowedExecutor {
}
// verifed
function setTokensURI(uint16[] calldata _tokenIds, string[] calldata _uris) external onlyAllowedExecutor {
}
// verifed
function adminMintTo(address _to, uint256 _amount) external onlyOwner {
}
function withdraw() public onlyOwner {
}
/* Royalty */
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) {
}
function setPrimaryRoyalty(address _receiver, uint96 _feeNumerator) public onlyAllowedExecutor {
}
// verified
function deleteDefaultRoyalty() public onlyAllowedExecutor {
}
// verified
function setRoyaltyInfoForToken(uint256 _tokenId, address _receiver, uint96 _feeNumerator) public onlyAllowedExecutor {
}
// verified
function resetRoyaltyInforToken(uint256 _tokenId) public onlyAllowedExecutor {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC2981, ERC721) returns (bool) {
}
}
| currentIdx+_amount-1<=maxSupply,"Exceed max supply" | 462,486 | currentIdx+_amount-1<=maxSupply |
"Caller is not blacklister" | /****
https://skrimples.ai
https://t.me/Skrimples
███████╗██╗ ██╗██████╗ ██╗███╗ ███╗██████╗ ██╗ ███████╗███████╗
██╔════╝██║ ██╔╝██╔══██╗██║████╗ ████║██╔══██╗██║ ██╔════╝██╔════╝
███████╗█████╔╝ ██████╔╝██║██╔████╔██║██████╔╝██║ █████╗ ███████╗
╚════██║██╔═██╗ ██╔══██╗██║██║╚██╔╝██║██╔═══╝ ██║ ██╔══╝ ╚════██║
███████║██║ ██╗██║ ██║██║██║ ╚═╝ ██║██║ ███████╗███████╗███████║
╚══════╝╚═╝ ╚═╝╚═╝ ╚═╝╚═╝╚═╝ ╚═╝╚═╝ ╚══════╝╚══════╝╚══════╝
The scrappiest, stinkiest pup in all of Shibarium.
by Bimpus & Snake
****/
// SPDX-License-Identifier: MIT
pragma solidity >= 0.8.0 < 0.9.0;
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
interface IUniswapV2Factory {
event PairCreated(
address indexed token0,
address indexed token1,
address pair,
uint256
);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB)
external
view
returns (address pair);
function allPairs(uint256) external view returns (address pair);
function allPairsLength() external view returns (uint256);
function createPair(address tokenA, address tokenB)
external
returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IUniswapV2Pair {
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
event Transfer(address indexed from, address indexed to, uint256 value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(
address from,
address to,
uint256 value
) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint256);
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
event Mint(address indexed sender, uint256 amount0, uint256 amount1);
event Burn(
address indexed sender,
uint256 amount0,
uint256 amount1,
address indexed to
);
event Swap(
address indexed sender,
uint256 amount0In,
uint256 amount1In,
uint256 amount0Out,
uint256 amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint256);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves()
external
view
returns (
uint112 reserve0,
uint112 reserve1,
uint32 blockTimestampLast
);
function price0CumulativeLast() external view returns (uint256);
function price1CumulativeLast() external view returns (uint256);
function kLast() external view returns (uint256);
function mint(address to) external returns (uint256 liquidity);
function burn(address to)
external
returns (uint256 amount0, uint256 amount1);
function swap(
uint256 amount0Out,
uint256 amount1Out,
address to,
bytes calldata data
) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
)
external
returns (
uint256 amountA,
uint256 amountB,
uint256 liquidity
);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract Skrimples is ERC20, AccessControl {
using SafeMath for uint256;
bytes32 public constant BLACKLISTER_ROLE = keccak256("BLACKLISTER_ROLE");
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
address public constant deadAddress = address(0xdead);
bool private swapping;
address public marketingWallet;
address public devWallet;
address public bonePileWallet;
address public liquidity;
uint256 public maxTransactionAmount;
uint256 public swapTokensAtAmount;
uint256 public maxWallet;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
bool public blacklistEnabled = true;
uint256 public buyTotalFees;
uint256 public buyMarketingFee;
uint256 public buyLiquidityFee;
uint256 public buyDevFee;
uint256 public buyBonePileFee;
uint256 public sellTotalFees;
uint256 public sellMarketingFee;
uint256 public sellLiquidityFee;
uint256 public sellDevFee;
uint256 public sellBonePileFee;
uint256 public tokensForMarketing;
uint256 public tokensForLiquidity;
uint256 public tokensForDev;
uint256 public tokensForBonePile;
// exlcude from fees and max transaction amount
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
mapping(address => bool) public blacklists;
// store addresses that are automatic market maker pairs. Transfers *to* these addresses
// could be subject to a maximum transfer amount
mapping(address => bool) public automatedMarketMakerPairs;
modifier onlyAdmin() {
}
modifier onlyBlacklister() {
require(<FILL_ME>)
_;
}
event UpdateUniswapV2Router(
address indexed newAddress,
address indexed oldAddress
);
event LimitsRemoved();
event BlacklistDisabled();
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event marketingWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event devWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event liquidityUpdated(
address indexed newWallet,
address indexed oldWallet
);
event bonePileWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
address admin = msg.sender;
constructor(address blacklister) ERC20("Skrimples", "SKRIMP") {
}
receive() external payable {}
function burn(uint256 amount) public virtual {
}
function blacklist(address _address, bool _isBlacklisting) external onlyBlacklister {
}
// Disable blacklist once token is stable, cannot be enabled again
function disableBlacklist() external onlyBlacklister returns (bool) {
}
// once enabled, is forever enabled
function enableTrading() external onlyAdmin {
}
// remove limits after token is stable, cannot be enabled again
function removeLimits() external onlyAdmin returns (bool) {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount)
external onlyAdmin
returns (bool)
{
}
// MaxTxAmount and MaxWalletAmount, cannot set lower than 2% of totalSupply
function updateMaximums(uint256 newNum) external onlyAdmin {
}
function excludeFromMaxTransaction(address updAds, bool isEx)
public onlyAdmin {
}
// only use to disable buy/sell fees if absolutely necessary (emergency use only)
function updateSwapEnabled(bool enabled) external onlyAdmin {
}
function updateFees(
uint256 _marketingFeeBuy,
uint256 _liquidityFeeBuy,
uint256 _devFeeBuy,
uint256 _bonePileFeeBuy,
uint256 _marketingFeeSell,
uint256 _liquidityFeeSell,
uint256 _devFeeSell,
uint256 _bonePileFeeSell
) external onlyAdmin {
}
function excludeFromFees(address account, bool excluded) public onlyAdmin {
}
function setAutomatedMarketMakerPair(address pair, bool value)
public onlyAdmin {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateMarketingWallet(address newMarketingWallet)
external onlyAdmin {
}
function updateLiquidity(address newLiquidity)
external onlyAdmin {
}
function updateDevWallet(address newWallet) external onlyAdmin {
}
function updateBonePileWallet(address newWallet) external onlyAdmin {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) override internal virtual {
}
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 {
}
}
| hasRole(BLACKLISTER_ROLE,msg.sender),"Caller is not blacklister" | 462,598 | hasRole(BLACKLISTER_ROLE,msg.sender) |
"Cannot set maximums lower than 2%" | /****
https://skrimples.ai
https://t.me/Skrimples
███████╗██╗ ██╗██████╗ ██╗███╗ ███╗██████╗ ██╗ ███████╗███████╗
██╔════╝██║ ██╔╝██╔══██╗██║████╗ ████║██╔══██╗██║ ██╔════╝██╔════╝
███████╗█████╔╝ ██████╔╝██║██╔████╔██║██████╔╝██║ █████╗ ███████╗
╚════██║██╔═██╗ ██╔══██╗██║██║╚██╔╝██║██╔═══╝ ██║ ██╔══╝ ╚════██║
███████║██║ ██╗██║ ██║██║██║ ╚═╝ ██║██║ ███████╗███████╗███████║
╚══════╝╚═╝ ╚═╝╚═╝ ╚═╝╚═╝╚═╝ ╚═╝╚═╝ ╚══════╝╚══════╝╚══════╝
The scrappiest, stinkiest pup in all of Shibarium.
by Bimpus & Snake
****/
// SPDX-License-Identifier: MIT
pragma solidity >= 0.8.0 < 0.9.0;
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
interface IUniswapV2Factory {
event PairCreated(
address indexed token0,
address indexed token1,
address pair,
uint256
);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB)
external
view
returns (address pair);
function allPairs(uint256) external view returns (address pair);
function allPairsLength() external view returns (uint256);
function createPair(address tokenA, address tokenB)
external
returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IUniswapV2Pair {
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
event Transfer(address indexed from, address indexed to, uint256 value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(
address from,
address to,
uint256 value
) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint256);
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
event Mint(address indexed sender, uint256 amount0, uint256 amount1);
event Burn(
address indexed sender,
uint256 amount0,
uint256 amount1,
address indexed to
);
event Swap(
address indexed sender,
uint256 amount0In,
uint256 amount1In,
uint256 amount0Out,
uint256 amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint256);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves()
external
view
returns (
uint112 reserve0,
uint112 reserve1,
uint32 blockTimestampLast
);
function price0CumulativeLast() external view returns (uint256);
function price1CumulativeLast() external view returns (uint256);
function kLast() external view returns (uint256);
function mint(address to) external returns (uint256 liquidity);
function burn(address to)
external
returns (uint256 amount0, uint256 amount1);
function swap(
uint256 amount0Out,
uint256 amount1Out,
address to,
bytes calldata data
) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
)
external
returns (
uint256 amountA,
uint256 amountB,
uint256 liquidity
);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract Skrimples is ERC20, AccessControl {
using SafeMath for uint256;
bytes32 public constant BLACKLISTER_ROLE = keccak256("BLACKLISTER_ROLE");
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
address public constant deadAddress = address(0xdead);
bool private swapping;
address public marketingWallet;
address public devWallet;
address public bonePileWallet;
address public liquidity;
uint256 public maxTransactionAmount;
uint256 public swapTokensAtAmount;
uint256 public maxWallet;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
bool public blacklistEnabled = true;
uint256 public buyTotalFees;
uint256 public buyMarketingFee;
uint256 public buyLiquidityFee;
uint256 public buyDevFee;
uint256 public buyBonePileFee;
uint256 public sellTotalFees;
uint256 public sellMarketingFee;
uint256 public sellLiquidityFee;
uint256 public sellDevFee;
uint256 public sellBonePileFee;
uint256 public tokensForMarketing;
uint256 public tokensForLiquidity;
uint256 public tokensForDev;
uint256 public tokensForBonePile;
// exlcude from fees and max transaction amount
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
mapping(address => bool) public blacklists;
// store addresses that are automatic market maker pairs. Transfers *to* these addresses
// could be subject to a maximum transfer amount
mapping(address => bool) public automatedMarketMakerPairs;
modifier onlyAdmin() {
}
modifier onlyBlacklister() {
}
event UpdateUniswapV2Router(
address indexed newAddress,
address indexed oldAddress
);
event LimitsRemoved();
event BlacklistDisabled();
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event marketingWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event devWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event liquidityUpdated(
address indexed newWallet,
address indexed oldWallet
);
event bonePileWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
address admin = msg.sender;
constructor(address blacklister) ERC20("Skrimples", "SKRIMP") {
}
receive() external payable {}
function burn(uint256 amount) public virtual {
}
function blacklist(address _address, bool _isBlacklisting) external onlyBlacklister {
}
// Disable blacklist once token is stable, cannot be enabled again
function disableBlacklist() external onlyBlacklister returns (bool) {
}
// once enabled, is forever enabled
function enableTrading() external onlyAdmin {
}
// remove limits after token is stable, cannot be enabled again
function removeLimits() external onlyAdmin returns (bool) {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount)
external onlyAdmin
returns (bool)
{
}
// MaxTxAmount and MaxWalletAmount, cannot set lower than 2% of totalSupply
function updateMaximums(uint256 newNum) external onlyAdmin {
require(<FILL_ME>)
maxWallet = newNum * (10**18);
maxTransactionAmount = newNum * (10**18);
}
function excludeFromMaxTransaction(address updAds, bool isEx)
public onlyAdmin {
}
// only use to disable buy/sell fees if absolutely necessary (emergency use only)
function updateSwapEnabled(bool enabled) external onlyAdmin {
}
function updateFees(
uint256 _marketingFeeBuy,
uint256 _liquidityFeeBuy,
uint256 _devFeeBuy,
uint256 _bonePileFeeBuy,
uint256 _marketingFeeSell,
uint256 _liquidityFeeSell,
uint256 _devFeeSell,
uint256 _bonePileFeeSell
) external onlyAdmin {
}
function excludeFromFees(address account, bool excluded) public onlyAdmin {
}
function setAutomatedMarketMakerPair(address pair, bool value)
public onlyAdmin {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateMarketingWallet(address newMarketingWallet)
external onlyAdmin {
}
function updateLiquidity(address newLiquidity)
external onlyAdmin {
}
function updateDevWallet(address newWallet) external onlyAdmin {
}
function updateBonePileWallet(address newWallet) external onlyAdmin {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) override internal virtual {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
}
| newNum>=((totalSupply()*2)/100)/1e18,"Cannot set maximums lower than 2%" | 462,598 | newNum>=((totalSupply()*2)/100)/1e18 |
"buyTotalFees cannot exceed 5% of transaction" | /****
https://skrimples.ai
https://t.me/Skrimples
███████╗██╗ ██╗██████╗ ██╗███╗ ███╗██████╗ ██╗ ███████╗███████╗
██╔════╝██║ ██╔╝██╔══██╗██║████╗ ████║██╔══██╗██║ ██╔════╝██╔════╝
███████╗█████╔╝ ██████╔╝██║██╔████╔██║██████╔╝██║ █████╗ ███████╗
╚════██║██╔═██╗ ██╔══██╗██║██║╚██╔╝██║██╔═══╝ ██║ ██╔══╝ ╚════██║
███████║██║ ██╗██║ ██║██║██║ ╚═╝ ██║██║ ███████╗███████╗███████║
╚══════╝╚═╝ ╚═╝╚═╝ ╚═╝╚═╝╚═╝ ╚═╝╚═╝ ╚══════╝╚══════╝╚══════╝
The scrappiest, stinkiest pup in all of Shibarium.
by Bimpus & Snake
****/
// SPDX-License-Identifier: MIT
pragma solidity >= 0.8.0 < 0.9.0;
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
interface IUniswapV2Factory {
event PairCreated(
address indexed token0,
address indexed token1,
address pair,
uint256
);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB)
external
view
returns (address pair);
function allPairs(uint256) external view returns (address pair);
function allPairsLength() external view returns (uint256);
function createPair(address tokenA, address tokenB)
external
returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IUniswapV2Pair {
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
event Transfer(address indexed from, address indexed to, uint256 value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(
address from,
address to,
uint256 value
) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint256);
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
event Mint(address indexed sender, uint256 amount0, uint256 amount1);
event Burn(
address indexed sender,
uint256 amount0,
uint256 amount1,
address indexed to
);
event Swap(
address indexed sender,
uint256 amount0In,
uint256 amount1In,
uint256 amount0Out,
uint256 amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint256);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves()
external
view
returns (
uint112 reserve0,
uint112 reserve1,
uint32 blockTimestampLast
);
function price0CumulativeLast() external view returns (uint256);
function price1CumulativeLast() external view returns (uint256);
function kLast() external view returns (uint256);
function mint(address to) external returns (uint256 liquidity);
function burn(address to)
external
returns (uint256 amount0, uint256 amount1);
function swap(
uint256 amount0Out,
uint256 amount1Out,
address to,
bytes calldata data
) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
)
external
returns (
uint256 amountA,
uint256 amountB,
uint256 liquidity
);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract Skrimples is ERC20, AccessControl {
using SafeMath for uint256;
bytes32 public constant BLACKLISTER_ROLE = keccak256("BLACKLISTER_ROLE");
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
address public constant deadAddress = address(0xdead);
bool private swapping;
address public marketingWallet;
address public devWallet;
address public bonePileWallet;
address public liquidity;
uint256 public maxTransactionAmount;
uint256 public swapTokensAtAmount;
uint256 public maxWallet;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
bool public blacklistEnabled = true;
uint256 public buyTotalFees;
uint256 public buyMarketingFee;
uint256 public buyLiquidityFee;
uint256 public buyDevFee;
uint256 public buyBonePileFee;
uint256 public sellTotalFees;
uint256 public sellMarketingFee;
uint256 public sellLiquidityFee;
uint256 public sellDevFee;
uint256 public sellBonePileFee;
uint256 public tokensForMarketing;
uint256 public tokensForLiquidity;
uint256 public tokensForDev;
uint256 public tokensForBonePile;
// exlcude from fees and max transaction amount
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
mapping(address => bool) public blacklists;
// store addresses that are automatic market maker pairs. Transfers *to* these addresses
// could be subject to a maximum transfer amount
mapping(address => bool) public automatedMarketMakerPairs;
modifier onlyAdmin() {
}
modifier onlyBlacklister() {
}
event UpdateUniswapV2Router(
address indexed newAddress,
address indexed oldAddress
);
event LimitsRemoved();
event BlacklistDisabled();
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event marketingWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event devWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event liquidityUpdated(
address indexed newWallet,
address indexed oldWallet
);
event bonePileWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
address admin = msg.sender;
constructor(address blacklister) ERC20("Skrimples", "SKRIMP") {
}
receive() external payable {}
function burn(uint256 amount) public virtual {
}
function blacklist(address _address, bool _isBlacklisting) external onlyBlacklister {
}
// Disable blacklist once token is stable, cannot be enabled again
function disableBlacklist() external onlyBlacklister returns (bool) {
}
// once enabled, is forever enabled
function enableTrading() external onlyAdmin {
}
// remove limits after token is stable, cannot be enabled again
function removeLimits() external onlyAdmin returns (bool) {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount)
external onlyAdmin
returns (bool)
{
}
// MaxTxAmount and MaxWalletAmount, cannot set lower than 2% of totalSupply
function updateMaximums(uint256 newNum) external onlyAdmin {
}
function excludeFromMaxTransaction(address updAds, bool isEx)
public onlyAdmin {
}
// only use to disable buy/sell fees if absolutely necessary (emergency use only)
function updateSwapEnabled(bool enabled) external onlyAdmin {
}
function updateFees(
uint256 _marketingFeeBuy,
uint256 _liquidityFeeBuy,
uint256 _devFeeBuy,
uint256 _bonePileFeeBuy,
uint256 _marketingFeeSell,
uint256 _liquidityFeeSell,
uint256 _devFeeSell,
uint256 _bonePileFeeSell
) external onlyAdmin {
require(<FILL_ME>)
require(
_marketingFeeSell + _liquidityFeeSell + _devFeeSell + _bonePileFeeBuy <= 5,
"sellTotalFees cannot exceed 5% of transaction"
);
buyMarketingFee = _marketingFeeBuy;
buyLiquidityFee = _liquidityFeeBuy;
buyDevFee = _devFeeBuy;
buyBonePileFee = _bonePileFeeBuy;
buyTotalFees = buyMarketingFee + buyLiquidityFee + buyDevFee + buyBonePileFee;
sellMarketingFee = _marketingFeeSell;
sellLiquidityFee = _liquidityFeeSell;
sellDevFee = _devFeeSell;
sellBonePileFee = _bonePileFeeSell;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee + sellBonePileFee;
}
function excludeFromFees(address account, bool excluded) public onlyAdmin {
}
function setAutomatedMarketMakerPair(address pair, bool value)
public onlyAdmin {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateMarketingWallet(address newMarketingWallet)
external onlyAdmin {
}
function updateLiquidity(address newLiquidity)
external onlyAdmin {
}
function updateDevWallet(address newWallet) external onlyAdmin {
}
function updateBonePileWallet(address newWallet) external onlyAdmin {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) override internal virtual {
}
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 {
}
}
| _marketingFeeBuy+_liquidityFeeBuy+_devFeeBuy+_bonePileFeeBuy<=5,"buyTotalFees cannot exceed 5% of transaction" | 462,598 | _marketingFeeBuy+_liquidityFeeBuy+_devFeeBuy+_bonePileFeeBuy<=5 |
"sellTotalFees cannot exceed 5% of transaction" | /****
https://skrimples.ai
https://t.me/Skrimples
███████╗██╗ ██╗██████╗ ██╗███╗ ███╗██████╗ ██╗ ███████╗███████╗
██╔════╝██║ ██╔╝██╔══██╗██║████╗ ████║██╔══██╗██║ ██╔════╝██╔════╝
███████╗█████╔╝ ██████╔╝██║██╔████╔██║██████╔╝██║ █████╗ ███████╗
╚════██║██╔═██╗ ██╔══██╗██║██║╚██╔╝██║██╔═══╝ ██║ ██╔══╝ ╚════██║
███████║██║ ██╗██║ ██║██║██║ ╚═╝ ██║██║ ███████╗███████╗███████║
╚══════╝╚═╝ ╚═╝╚═╝ ╚═╝╚═╝╚═╝ ╚═╝╚═╝ ╚══════╝╚══════╝╚══════╝
The scrappiest, stinkiest pup in all of Shibarium.
by Bimpus & Snake
****/
// SPDX-License-Identifier: MIT
pragma solidity >= 0.8.0 < 0.9.0;
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
interface IUniswapV2Factory {
event PairCreated(
address indexed token0,
address indexed token1,
address pair,
uint256
);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB)
external
view
returns (address pair);
function allPairs(uint256) external view returns (address pair);
function allPairsLength() external view returns (uint256);
function createPair(address tokenA, address tokenB)
external
returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IUniswapV2Pair {
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
event Transfer(address indexed from, address indexed to, uint256 value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(
address from,
address to,
uint256 value
) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint256);
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
event Mint(address indexed sender, uint256 amount0, uint256 amount1);
event Burn(
address indexed sender,
uint256 amount0,
uint256 amount1,
address indexed to
);
event Swap(
address indexed sender,
uint256 amount0In,
uint256 amount1In,
uint256 amount0Out,
uint256 amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint256);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves()
external
view
returns (
uint112 reserve0,
uint112 reserve1,
uint32 blockTimestampLast
);
function price0CumulativeLast() external view returns (uint256);
function price1CumulativeLast() external view returns (uint256);
function kLast() external view returns (uint256);
function mint(address to) external returns (uint256 liquidity);
function burn(address to)
external
returns (uint256 amount0, uint256 amount1);
function swap(
uint256 amount0Out,
uint256 amount1Out,
address to,
bytes calldata data
) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
)
external
returns (
uint256 amountA,
uint256 amountB,
uint256 liquidity
);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract Skrimples is ERC20, AccessControl {
using SafeMath for uint256;
bytes32 public constant BLACKLISTER_ROLE = keccak256("BLACKLISTER_ROLE");
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
address public constant deadAddress = address(0xdead);
bool private swapping;
address public marketingWallet;
address public devWallet;
address public bonePileWallet;
address public liquidity;
uint256 public maxTransactionAmount;
uint256 public swapTokensAtAmount;
uint256 public maxWallet;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
bool public blacklistEnabled = true;
uint256 public buyTotalFees;
uint256 public buyMarketingFee;
uint256 public buyLiquidityFee;
uint256 public buyDevFee;
uint256 public buyBonePileFee;
uint256 public sellTotalFees;
uint256 public sellMarketingFee;
uint256 public sellLiquidityFee;
uint256 public sellDevFee;
uint256 public sellBonePileFee;
uint256 public tokensForMarketing;
uint256 public tokensForLiquidity;
uint256 public tokensForDev;
uint256 public tokensForBonePile;
// exlcude from fees and max transaction amount
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
mapping(address => bool) public blacklists;
// store addresses that are automatic market maker pairs. Transfers *to* these addresses
// could be subject to a maximum transfer amount
mapping(address => bool) public automatedMarketMakerPairs;
modifier onlyAdmin() {
}
modifier onlyBlacklister() {
}
event UpdateUniswapV2Router(
address indexed newAddress,
address indexed oldAddress
);
event LimitsRemoved();
event BlacklistDisabled();
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event marketingWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event devWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event liquidityUpdated(
address indexed newWallet,
address indexed oldWallet
);
event bonePileWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
address admin = msg.sender;
constructor(address blacklister) ERC20("Skrimples", "SKRIMP") {
}
receive() external payable {}
function burn(uint256 amount) public virtual {
}
function blacklist(address _address, bool _isBlacklisting) external onlyBlacklister {
}
// Disable blacklist once token is stable, cannot be enabled again
function disableBlacklist() external onlyBlacklister returns (bool) {
}
// once enabled, is forever enabled
function enableTrading() external onlyAdmin {
}
// remove limits after token is stable, cannot be enabled again
function removeLimits() external onlyAdmin returns (bool) {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount)
external onlyAdmin
returns (bool)
{
}
// MaxTxAmount and MaxWalletAmount, cannot set lower than 2% of totalSupply
function updateMaximums(uint256 newNum) external onlyAdmin {
}
function excludeFromMaxTransaction(address updAds, bool isEx)
public onlyAdmin {
}
// only use to disable buy/sell fees if absolutely necessary (emergency use only)
function updateSwapEnabled(bool enabled) external onlyAdmin {
}
function updateFees(
uint256 _marketingFeeBuy,
uint256 _liquidityFeeBuy,
uint256 _devFeeBuy,
uint256 _bonePileFeeBuy,
uint256 _marketingFeeSell,
uint256 _liquidityFeeSell,
uint256 _devFeeSell,
uint256 _bonePileFeeSell
) external onlyAdmin {
require(
_marketingFeeBuy + _liquidityFeeBuy + _devFeeBuy + _bonePileFeeBuy <= 5,
"buyTotalFees cannot exceed 5% of transaction"
);
require(<FILL_ME>)
buyMarketingFee = _marketingFeeBuy;
buyLiquidityFee = _liquidityFeeBuy;
buyDevFee = _devFeeBuy;
buyBonePileFee = _bonePileFeeBuy;
buyTotalFees = buyMarketingFee + buyLiquidityFee + buyDevFee + buyBonePileFee;
sellMarketingFee = _marketingFeeSell;
sellLiquidityFee = _liquidityFeeSell;
sellDevFee = _devFeeSell;
sellBonePileFee = _bonePileFeeSell;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee + sellBonePileFee;
}
function excludeFromFees(address account, bool excluded) public onlyAdmin {
}
function setAutomatedMarketMakerPair(address pair, bool value)
public onlyAdmin {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateMarketingWallet(address newMarketingWallet)
external onlyAdmin {
}
function updateLiquidity(address newLiquidity)
external onlyAdmin {
}
function updateDevWallet(address newWallet) external onlyAdmin {
}
function updateBonePileWallet(address newWallet) external onlyAdmin {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) override internal virtual {
}
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 {
}
}
| _marketingFeeSell+_liquidityFeeSell+_devFeeSell+_bonePileFeeBuy<=5,"sellTotalFees cannot exceed 5% of transaction" | 462,598 | _marketingFeeSell+_liquidityFeeSell+_devFeeSell+_bonePileFeeBuy<=5 |
"Purchase would exceed max tokens" | // SPDX-License-Identifier: MIT
/*
_ _ _ _____ _____ _
| \ | | | | |_ _| | __ \ (_)
| \| | ___ | |_ | | _ __ | |__) |_ _ _ __ _ ___
| . ` |/ _ \| __| | | | '_ \ | ___/ _` | '__| / __|
| |\ | (_) | |_ _| |_| | | | | | | (_| | | | \__ \
|_| \_|\___/ \__| |_____|_| |_| |_| \__,_|_| |_|___/
zeitler.eth
*/
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract NotInParis is Ownable, ReentrancyGuard, ERC721Enumerable {
uint256 public PRICE_PER_TOKEN = 0.1 ether;
uint256 public MAX_SUPPLY = 350;
uint256 public RESERVE_SUPPLY = 30; // 24 are for the Team. 6 are for the HighSnobiety Museum.
uint256 private MAX_PUBLIC_MINT = 1;
bool public IS_SALE_ACTIVE = false;
bool public IS_ALLOWLIST_REQUIRED = true;
bytes32 private merkleRoot;
string private _tokenUri = "";
mapping(address => uint256) private balances;
constructor() ERC721("Not In Paris", "NIP") {}
modifier ableToMint() {
require(<FILL_ME>)
_;
}
function isWhitelisted(address _address, bytes32[] calldata _merkleProof) external view returns(bool) {
}
function tokensClaimed(address _address) public view returns(uint256) {
}
function mint(bytes32[] calldata _merkleProof) public payable ableToMint nonReentrant {
}
function teamMint(uint256 _amount, address _address) external onlyOwner {
}
/*
Owner Functions
*/
function setSaleState(bool _state) external onlyOwner {
}
function setIsAllowlistActive(bool _state) external onlyOwner {
}
function setBaseUri(string calldata _uri) external onlyOwner {
}
function setRoot(bytes32 _root) external onlyOwner {
}
function setPrice(uint256 _price) external onlyOwner {
}
function withdraw() external onlyOwner {
}
/*
List all the NFTs of a wallet
*/
function tokensOfOwner(address _owner) public view returns(uint256[] memory) {
}
/*
Overrides
*/
function _baseURI() internal view virtual override returns(string memory) {
}
function renounceOwnership() public view override onlyOwner {}
}
| totalSupply()<MAX_SUPPLY-RESERVE_SUPPLY,"Purchase would exceed max tokens" | 462,604 | totalSupply()<MAX_SUPPLY-RESERVE_SUPPLY |
"Can't claim more than one token" | // SPDX-License-Identifier: MIT
/*
_ _ _ _____ _____ _
| \ | | | | |_ _| | __ \ (_)
| \| | ___ | |_ | | _ __ | |__) |_ _ _ __ _ ___
| . ` |/ _ \| __| | | | '_ \ | ___/ _` | '__| / __|
| |\ | (_) | |_ _| |_| | | | | | | (_| | | | \__ \
|_| \_|\___/ \__| |_____|_| |_| |_| \__,_|_| |_|___/
zeitler.eth
*/
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract NotInParis is Ownable, ReentrancyGuard, ERC721Enumerable {
uint256 public PRICE_PER_TOKEN = 0.1 ether;
uint256 public MAX_SUPPLY = 350;
uint256 public RESERVE_SUPPLY = 30; // 24 are for the Team. 6 are for the HighSnobiety Museum.
uint256 private MAX_PUBLIC_MINT = 1;
bool public IS_SALE_ACTIVE = false;
bool public IS_ALLOWLIST_REQUIRED = true;
bytes32 private merkleRoot;
string private _tokenUri = "";
mapping(address => uint256) private balances;
constructor() ERC721("Not In Paris", "NIP") {}
modifier ableToMint() {
}
function isWhitelisted(address _address, bytes32[] calldata _merkleProof) external view returns(bool) {
}
function tokensClaimed(address _address) public view returns(uint256) {
}
function mint(bytes32[] calldata _merkleProof) public payable ableToMint nonReentrant {
require(IS_SALE_ACTIVE, "Sale is not active yet");
require(msg.value >= PRICE_PER_TOKEN, "Wrong amount of Ether send");
if(IS_ALLOWLIST_REQUIRED) {
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_merkleProof, merkleRoot, leaf), "Invalid Merkle Proof");
}
balances[msg.sender]++;
require(<FILL_ME>)
uint256 id = totalSupply();
id++;
_safeMint(msg.sender, id);
}
function teamMint(uint256 _amount, address _address) external onlyOwner {
}
/*
Owner Functions
*/
function setSaleState(bool _state) external onlyOwner {
}
function setIsAllowlistActive(bool _state) external onlyOwner {
}
function setBaseUri(string calldata _uri) external onlyOwner {
}
function setRoot(bytes32 _root) external onlyOwner {
}
function setPrice(uint256 _price) external onlyOwner {
}
function withdraw() external onlyOwner {
}
/*
List all the NFTs of a wallet
*/
function tokensOfOwner(address _owner) public view returns(uint256[] memory) {
}
/*
Overrides
*/
function _baseURI() internal view virtual override returns(string memory) {
}
function renounceOwnership() public view override onlyOwner {}
}
| balances[msg.sender]<=MAX_PUBLIC_MINT,"Can't claim more than one token" | 462,604 | balances[msg.sender]<=MAX_PUBLIC_MINT |
'Max paid supply 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';
interface IParent {
function ownerOf(uint256 tokenId) external view returns (address);
function walletOfOwner(address _owner) external view returns (uint256[] memory);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
}
contract FlinchMovie 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;
uint256 public parentClaims;
uint256 public noPaidNfts = 4444;
uint256 public maxPerWallet = 2;
bool public paused = true;
bool public whitelistMintEnabled = false;
bool public revealed = false;
mapping(address => uint256) public tokenBalance;
mapping(uint256 => bool) public tokenIds;
mapping(address => uint256) public addressBalance;
//v2 address change this to nft adress needed to hold for claim
address public v2Address = 0xd4f11C30078d352354c0B17eAA8076C825416493;
IParent public v2;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint256 _cost,
uint256 _maxSupply,
uint256 _maxMintAmountPerTx,
string memory _hiddenMetadataUri
) ERC721A(_tokenName, _tokenSymbol) {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier mintCompliancePaid(uint256 _mintAmount){
require(_mintAmount > 0 && _mintAmount <= maxMintAmountPerTx, 'Invalid mint amount!');
require(<FILL_ME>)
_;
}
modifier mintPriceCompliance(uint256 _mintAmount) {
}
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable mintCompliancePaid(_mintAmount) mintPriceCompliance(_mintAmount) {
}
function mint(uint256 _mintAmount) public payable mintCompliancePaid(_mintAmount) mintPriceCompliance(_mintAmount) {
}
function claimFromParentNFT(uint256 _numberOfTokens) external payable {
}
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 setNoPaidNFT(uint256 _newAmount) public onlyOwner {
}
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 setV2Contract(address _newV2Contract) external onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| totalSupply()+_mintAmount<=noPaidNfts,'Max paid supply exceeded!' | 462,660 | totalSupply()+_mintAmount<=noPaidNfts |
'max limit reached' | // 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';
interface IParent {
function ownerOf(uint256 tokenId) external view returns (address);
function walletOfOwner(address _owner) external view returns (uint256[] memory);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
}
contract FlinchMovie 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;
uint256 public parentClaims;
uint256 public noPaidNfts = 4444;
uint256 public maxPerWallet = 2;
bool public paused = true;
bool public whitelistMintEnabled = false;
bool public revealed = false;
mapping(address => uint256) public tokenBalance;
mapping(uint256 => bool) public tokenIds;
mapping(address => uint256) public addressBalance;
//v2 address change this to nft adress needed to hold for claim
address public v2Address = 0xd4f11C30078d352354c0B17eAA8076C825416493;
IParent public v2;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint256 _cost,
uint256 _maxSupply,
uint256 _maxMintAmountPerTx,
string memory _hiddenMetadataUri
) ERC721A(_tokenName, _tokenSymbol) {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier mintCompliancePaid(uint256 _mintAmount){
}
modifier mintPriceCompliance(uint256 _mintAmount) {
}
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable mintCompliancePaid(_mintAmount) mintPriceCompliance(_mintAmount) {
}
function mint(uint256 _mintAmount) public payable mintCompliancePaid(_mintAmount) mintPriceCompliance(_mintAmount) {
require(!paused, 'The contract is paused!');
uint256 addrBalance = addressBalance[_msgSender()];
require(<FILL_ME>)
addressBalance[_msgSender()] += _mintAmount;
_safeMint(_msgSender(), _mintAmount);
}
function claimFromParentNFT(uint256 _numberOfTokens) external payable {
}
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 setNoPaidNFT(uint256 _newAmount) public onlyOwner {
}
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 setV2Contract(address _newV2Contract) external onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| addrBalance+_mintAmount<=maxPerWallet,'max limit reached' | 462,660 | addrBalance+_mintAmount<=maxPerWallet |
"max limit reached" | // 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';
interface IParent {
function ownerOf(uint256 tokenId) external view returns (address);
function walletOfOwner(address _owner) external view returns (uint256[] memory);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
}
contract FlinchMovie 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;
uint256 public parentClaims;
uint256 public noPaidNfts = 4444;
uint256 public maxPerWallet = 2;
bool public paused = true;
bool public whitelistMintEnabled = false;
bool public revealed = false;
mapping(address => uint256) public tokenBalance;
mapping(uint256 => bool) public tokenIds;
mapping(address => uint256) public addressBalance;
//v2 address change this to nft adress needed to hold for claim
address public v2Address = 0xd4f11C30078d352354c0B17eAA8076C825416493;
IParent public v2;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint256 _cost,
uint256 _maxSupply,
uint256 _maxMintAmountPerTx,
string memory _hiddenMetadataUri
) ERC721A(_tokenName, _tokenSymbol) {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier mintCompliancePaid(uint256 _mintAmount){
}
modifier mintPriceCompliance(uint256 _mintAmount) {
}
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable mintCompliancePaid(_mintAmount) mintPriceCompliance(_mintAmount) {
}
function mint(uint256 _mintAmount) public payable mintCompliancePaid(_mintAmount) mintPriceCompliance(_mintAmount) {
}
function claimFromParentNFT(uint256 _numberOfTokens) external payable {
uint256 currentSupply = totalSupply();
uint256 balanceAddr = v2.balanceOf(_msgSender());
uint256 balanceToken = tokenBalance[_msgSender()];
require(!paused, "Contract is paused");
require(currentSupply >= noPaidNfts, "user cannot claim");
require(_numberOfTokens > 0, "cannot mint zero");
require(<FILL_ME>)
require(currentSupply + _numberOfTokens <= maxSupply, "Purchase would exceed max supply");
tokenBalance[msg.sender]+=_numberOfTokens;
parentClaims+= _numberOfTokens;
_safeMint(_msgSender(), _numberOfTokens);
}
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 setNoPaidNFT(uint256 _newAmount) public onlyOwner {
}
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 setV2Contract(address _newV2Contract) external onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| balanceToken+_numberOfTokens<=balanceAddr,"max limit reached" | 462,660 | balanceToken+_numberOfTokens<=balanceAddr |
"Purchase would exceed max supply" | // 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';
interface IParent {
function ownerOf(uint256 tokenId) external view returns (address);
function walletOfOwner(address _owner) external view returns (uint256[] memory);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
}
contract FlinchMovie 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;
uint256 public parentClaims;
uint256 public noPaidNfts = 4444;
uint256 public maxPerWallet = 2;
bool public paused = true;
bool public whitelistMintEnabled = false;
bool public revealed = false;
mapping(address => uint256) public tokenBalance;
mapping(uint256 => bool) public tokenIds;
mapping(address => uint256) public addressBalance;
//v2 address change this to nft adress needed to hold for claim
address public v2Address = 0xd4f11C30078d352354c0B17eAA8076C825416493;
IParent public v2;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint256 _cost,
uint256 _maxSupply,
uint256 _maxMintAmountPerTx,
string memory _hiddenMetadataUri
) ERC721A(_tokenName, _tokenSymbol) {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier mintCompliancePaid(uint256 _mintAmount){
}
modifier mintPriceCompliance(uint256 _mintAmount) {
}
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable mintCompliancePaid(_mintAmount) mintPriceCompliance(_mintAmount) {
}
function mint(uint256 _mintAmount) public payable mintCompliancePaid(_mintAmount) mintPriceCompliance(_mintAmount) {
}
function claimFromParentNFT(uint256 _numberOfTokens) external payable {
uint256 currentSupply = totalSupply();
uint256 balanceAddr = v2.balanceOf(_msgSender());
uint256 balanceToken = tokenBalance[_msgSender()];
require(!paused, "Contract is paused");
require(currentSupply >= noPaidNfts, "user cannot claim");
require(_numberOfTokens > 0, "cannot mint zero");
require(balanceToken + _numberOfTokens <= balanceAddr, "max limit reached");
require(<FILL_ME>)
tokenBalance[msg.sender]+=_numberOfTokens;
parentClaims+= _numberOfTokens;
_safeMint(_msgSender(), _numberOfTokens);
}
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 setNoPaidNFT(uint256 _newAmount) public onlyOwner {
}
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 setV2Contract(address _newV2Contract) external onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| currentSupply+_numberOfTokens<=maxSupply,"Purchase would exceed max supply" | 462,660 | currentSupply+_numberOfTokens<=maxSupply |
"Minted out" | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract TweetDaoNft is ERC721Enumerable, Ownable {
uint256 public MAX_PUBLIC_SUPPLY = 9950;
string public baseUri = "https://gateway.pinata.cloud/ipfs/QmUQLowzXxNqtGqCxq2YgAxo9R31ixS4AuGFVQMU96BX3V/";
constructor() ERC721("Tweet DAO Eggs", "TWEETDAO") {
}
function mint() public payable {
require(<FILL_ME>)
require(msg.value == getPrice(), "Payment low");
_mint(msg.sender, totalSupply() + 1);
}
function creatorMint() public onlyOwner {
}
function getPrice() public view returns (uint256) {
}
function setBaseUri(string memory _baseUri) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function withdraw() public onlyOwner {
}
}
| totalSupply()<MAX_PUBLIC_SUPPLY,"Minted out" | 462,798 | totalSupply()<MAX_PUBLIC_SUPPLY |
"Public sale isn't over" | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract TweetDaoNft is ERC721Enumerable, Ownable {
uint256 public MAX_PUBLIC_SUPPLY = 9950;
string public baseUri = "https://gateway.pinata.cloud/ipfs/QmUQLowzXxNqtGqCxq2YgAxo9R31ixS4AuGFVQMU96BX3V/";
constructor() ERC721("Tweet DAO Eggs", "TWEETDAO") {
}
function mint() public payable {
}
function creatorMint() public onlyOwner {
require(<FILL_ME>)
for (uint i = 0; i < 50; i++) {
_mint(msg.sender, totalSupply() + 1);
}
}
function getPrice() public view returns (uint256) {
}
function setBaseUri(string memory _baseUri) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function withdraw() public onlyOwner {
}
}
| totalSupply()>=MAX_PUBLIC_SUPPLY,"Public sale isn't over" | 462,798 | totalSupply()>=MAX_PUBLIC_SUPPLY |
"GelatoRelayContext.onlyGelatoRelay" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.1;
import {GELATO_RELAY} from "../constants/GelatoRelay.sol";
abstract contract GelatoRelayBase {
modifier onlyGelatoRelay() {
require(<FILL_ME>)
_;
}
function _isGelatoRelay(address _forwarder) internal pure returns (bool) {
}
}
| _isGelatoRelay(msg.sender),"GelatoRelayContext.onlyGelatoRelay" | 462,852 | _isGelatoRelay(msg.sender) |
"Exceeds maximum supply" | pragma solidity ^0.8.15;
contract luckymouse is ERC721A, Ownable {
using Strings for uint256;
bool public mintOpen;
bool public blindBoxOpen;
bool public refundOpen;
string baseTokenURI;
string blindTokenURI;
uint256 public constant maxTotal = 666;
uint256 public price = 0.01 * 10**18;
address public withdrawAddress = 0x511604E18d63D32ac2605B5f0aF0cF580D21FA49;
address public refundAddress = 0x511604E18d63D32ac2605B5f0aF0cF580D21FA49;
mapping(uint256 => bool) public hasRefunded; // users can search if the NFT has been refunded
constructor(string memory _blindTokenURI, string memory _baseTokenURI)
ERC721A("luckymouse", "LM") {
}
function mint(uint256 num) public payable {
uint256 supply = totalSupply();
require(mintOpen, "not mint time");
require(<FILL_ME>)
require(msg.value >= price * num, "Ether sent is not correct");
_safeMint(msg.sender, num);
}
function openMint() public onlyOwner {
}
function openeBlindBox() public onlyOwner {
}
function openRefund() public onlyOwner {
}
function setBlindURI(string memory _blindTokenURI) public onlyOwner {
}
function setBaseURI(string memory _baseTokenURI) public onlyOwner {
}
function refund(uint256[] calldata tokenIds) external {
}
function withdraw() public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
}
| supply+num<=maxTotal,"Exceeds maximum supply" | 462,863 | supply+num<=maxTotal |
null | pragma solidity ^0.8.15;
contract luckymouse is ERC721A, Ownable {
using Strings for uint256;
bool public mintOpen;
bool public blindBoxOpen;
bool public refundOpen;
string baseTokenURI;
string blindTokenURI;
uint256 public constant maxTotal = 666;
uint256 public price = 0.01 * 10**18;
address public withdrawAddress = 0x511604E18d63D32ac2605B5f0aF0cF580D21FA49;
address public refundAddress = 0x511604E18d63D32ac2605B5f0aF0cF580D21FA49;
mapping(uint256 => bool) public hasRefunded; // users can search if the NFT has been refunded
constructor(string memory _blindTokenURI, string memory _baseTokenURI)
ERC721A("luckymouse", "LM") {
}
function mint(uint256 num) public payable {
}
function openMint() public onlyOwner {
}
function openeBlindBox() public onlyOwner {
}
function openRefund() public onlyOwner {
}
function setBlindURI(string memory _blindTokenURI) public onlyOwner {
}
function setBaseURI(string memory _baseTokenURI) public onlyOwner {
}
function refund(uint256[] calldata tokenIds) external {
for (uint256 i = 0; i < tokenIds.length; i++) {
uint256 tokenId = tokenIds[i];
require(msg.sender == ownerOf(tokenId), "Not token owner");
require(!hasRefunded[tokenId], "Already refunded");
require(refundOpen, "Refund not opened");
hasRefunded[tokenId] = true;
transferFrom(msg.sender, refundAddress, tokenId);
}
uint256 refundAmount = tokenIds.length * price;
require(<FILL_ME>)
}
function withdraw() public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
}
| payable(msg.sender).send(refundAmount) | 462,863 | payable(msg.sender).send(refundAmount) |
null | pragma solidity ^0.8.15;
contract luckymouse is ERC721A, Ownable {
using Strings for uint256;
bool public mintOpen;
bool public blindBoxOpen;
bool public refundOpen;
string baseTokenURI;
string blindTokenURI;
uint256 public constant maxTotal = 666;
uint256 public price = 0.01 * 10**18;
address public withdrawAddress = 0x511604E18d63D32ac2605B5f0aF0cF580D21FA49;
address public refundAddress = 0x511604E18d63D32ac2605B5f0aF0cF580D21FA49;
mapping(uint256 => bool) public hasRefunded; // users can search if the NFT has been refunded
constructor(string memory _blindTokenURI, string memory _baseTokenURI)
ERC721A("luckymouse", "LM") {
}
function mint(uint256 num) public payable {
}
function openMint() public onlyOwner {
}
function openeBlindBox() public onlyOwner {
}
function openRefund() public onlyOwner {
}
function setBlindURI(string memory _blindTokenURI) public onlyOwner {
}
function setBaseURI(string memory _baseTokenURI) public onlyOwner {
}
function refund(uint256[] calldata tokenIds) external {
}
function withdraw() public onlyOwner {
uint one = address(this).balance;
require(<FILL_ME>)
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
}
| payable(withdrawAddress).send(one) | 462,863 | payable(withdrawAddress).send(one) |
null | /**
*Submitted for verification at BscScan.com on 2022-07-06
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.7;
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) {
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract ERC20 is Context, IERC20, Ownable {
using SafeMath for uint256;
string constant _name = "Divine Swap";
string constant _symbol = "DSWAP";
uint8 constant _decimals = 18;
uint256 _totalSupply = 1000000000 * (10**_decimals);
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludeFee;
mapping (address => bool) private _isExcludeMaxHold;
IDEXRouter public router;
address NATIVETOKEN;
address public pair;
address public factory;
address public currentRouter;
uint256 public totalfee;
uint256 public marketingfee;
uint256 public liquidityfee;
uint256 public feeDenominator;
uint256 public maxWallet;
bool public removemaxWallet;
uint256 public swapthreshold;
bool public inSwap;
bool public autoswap;
bool public baseERC20;
constructor() {
}
function setFee(uint256 _marketing,uint256 _liquidity,uint256 _denominator) external onlyOwner returns (bool) {
require(<FILL_ME>)
marketingfee = _marketing;
liquidityfee = _liquidity;
totalfee = _marketing.add(_liquidity);
feeDenominator = _denominator;
return true;
}
function setMaxWallet(uint256 maxAmount) external onlyOwner returns (bool) {
}
function updateNativeToken() external onlyOwner returns (bool) {
}
function returnERC20Standart(bool flag) external onlyOwner returns (bool) {
}
function setFeeExempt(address account,bool flag) external onlyOwner returns (bool) {
}
function setMaxHoldExempt(address account,bool flag) external onlyOwner returns (bool) {
}
function setRemoveMaxWallet(bool flag) external onlyOwner returns (bool) {
}
function setAutoSwap(uint256 amount,bool flag) external onlyOwner returns (bool) {
}
function AddLiquidityETH(uint256 _tokenamount) external onlyOwner payable {
}
function decimals() public pure returns (uint8) { }
function symbol() public pure returns (string memory) { }
function name() public pure returns (string memory) { }
function totalSupply() external view override returns (uint256) { }
function balanceOf(address account) external view override returns (uint256) { }
function isExcludeFee(address account) external view returns (bool) { }
function isExcludeMaxHold(address account) external view returns (bool) { }
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function allowance(address owner, address spender) external view override returns (uint256) {
}
function approve(address spender, uint256 amount) external override returns (bool) {
}
function swap2ETH(uint256 amount) internal {
}
function autoAddLP(uint256 amountToLiquify,uint256 amountBNB) internal {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function _transferFrom(address sender,address recipient,uint256 amount) internal {
}
function _transfer(address sender, address recipient, uint256 amount) internal {
}
function _basictransfer(address sender, address recipient, uint256 amount) internal {
}
function _approve(address owner, address spender, uint256 amount) internal {
}
receive() external payable { }
}
| _marketing.add(_liquidity)<=_denominator.mul(8).div(100) | 463,060 | _marketing.add(_liquidity)<=_denominator.mul(8).div(100) |
"You can't unstake NFT in the first 30 days" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
contract WeldostStaking is Ownable, ERC1155Holder {
using EnumerableSet for EnumerableSet.UintSet;
// Contract Addresses
IERC1155 public immutable nftAddress;
IERC20 public immutable usdtAddress;
address private immutable fund;
uint64 public constant Interval = 30 days;
bool public isStopped;
uint64 public stopTime;
// Staking Tracking
mapping(address => uint256) public _currentIDs;
mapping(address => EnumerableSet.UintSet) private _activeIDs;
mapping(address => mapping(uint256 => StakeInfo)) public _stakeInfo;
uint256[] public rewards = [
5_000_000,
25_000_000,
50_000_000,
75_000_000,
125_000_000,
250_000_000
];
struct StakeInfo {
uint64 tokenId;
uint64 startTime;
uint64 claimTime;
}
// Events
event Stake(address addr, uint256[] tokenIds, uint256[] quantities);
event Unstake(address addr, uint256 stakeId, uint256 tokenId);
event Claim(address addr, uint256 amount);
constructor(IERC1155 _nftAddress, IERC20 _usdtAddress, address _fund) {
}
/**
* Stake multiple NFTs into the contract
*/
function stake(
uint256[] calldata tokenIds,
uint256[] calldata quantities
) external {
}
/**
@notice unstaking a token that has unrealized USDT forfeits the USDT associated
* with the token(s) being unstaked. This was done intentionally as a holder may
* not to pay the gas costs associated with claiming USDT. Please see unstakeAndClaim
* to also claim USDT.
*
* Unstaking your NFT transfers ownership back to the address that staked it.
* When an NFT is unstaked, you will no longer be earning USDT.
*/
function unstakeMultiple(uint256[] calldata stakeIds) public {
}
/**
@notice unstaking a token that has unrealized USDT forfeits the USDT associated
* with the token(s) being unstaked. This was done intentionally as a holder may
* not to pay the gas costs associated with claiming USDT. Please see unstakeAndClaim
* to also claim USDT.
*
* Unstaking your NFT transfers ownership back to the address that staked it.
* When an NFT is unstaked, you will no longer be earning USDT.
*/
function unstake(uint256 stakeId) public {
StakeInfo storage stakeInfo = _stakeInfo[msg.sender][stakeId];
require(<FILL_ME>)
uint256 tokenId = stakeInfo.tokenId;
bool success = _activeIDs[msg.sender].remove(stakeId);
require(success, "Staking not active");
nftAddress.safeTransferFrom(address(this), msg.sender, tokenId, 1, "");
emit Unstake(msg.sender, stakeId, tokenId);
}
/**
* @dev claim earned USDT without unstaking
*/
function claim(uint256 stakeId) public {
}
function claimMultiple(uint256[] calldata stakeIds) public {
}
function getActiveStakingsInfo(
address account
) public view returns (StakeInfo[] memory) {
}
/**
* Track stakings of an account
*/
function getActiveStakingsID(
address account
) external view returns (uint256[] memory) {
}
/**
* @dev unstakeAndClaim will unstake the token and realize the USDT that it has earned.
* If you are not interested in earning USDT you can call unstaske and save the gas.
* Unstaking your NFT transfers ownership back to the address that staked it.
* When an NFT is unstaked you will no longer be earning USDT.
*/
function claimAndUnstake(uint256[] calldata _stakeIds) external {
}
/**
* Allows contract owner to withdraw ERC20 tokens from the contract
*/
function withdrawTokens(IERC20 _usdtAddress) external onlyOwner {
}
function stopContract() external onlyOwner {
}
}
| uint64(block.timestamp)-stakeInfo.startTime>Interval||isStopped,"You can't unstake NFT in the first 30 days" | 463,120 | uint64(block.timestamp)-stakeInfo.startTime>Interval||isStopped |
"StakingID not active" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
contract WeldostStaking is Ownable, ERC1155Holder {
using EnumerableSet for EnumerableSet.UintSet;
// Contract Addresses
IERC1155 public immutable nftAddress;
IERC20 public immutable usdtAddress;
address private immutable fund;
uint64 public constant Interval = 30 days;
bool public isStopped;
uint64 public stopTime;
// Staking Tracking
mapping(address => uint256) public _currentIDs;
mapping(address => EnumerableSet.UintSet) private _activeIDs;
mapping(address => mapping(uint256 => StakeInfo)) public _stakeInfo;
uint256[] public rewards = [
5_000_000,
25_000_000,
50_000_000,
75_000_000,
125_000_000,
250_000_000
];
struct StakeInfo {
uint64 tokenId;
uint64 startTime;
uint64 claimTime;
}
// Events
event Stake(address addr, uint256[] tokenIds, uint256[] quantities);
event Unstake(address addr, uint256 stakeId, uint256 tokenId);
event Claim(address addr, uint256 amount);
constructor(IERC1155 _nftAddress, IERC20 _usdtAddress, address _fund) {
}
/**
* Stake multiple NFTs into the contract
*/
function stake(
uint256[] calldata tokenIds,
uint256[] calldata quantities
) external {
}
/**
@notice unstaking a token that has unrealized USDT forfeits the USDT associated
* with the token(s) being unstaked. This was done intentionally as a holder may
* not to pay the gas costs associated with claiming USDT. Please see unstakeAndClaim
* to also claim USDT.
*
* Unstaking your NFT transfers ownership back to the address that staked it.
* When an NFT is unstaked, you will no longer be earning USDT.
*/
function unstakeMultiple(uint256[] calldata stakeIds) public {
}
/**
@notice unstaking a token that has unrealized USDT forfeits the USDT associated
* with the token(s) being unstaked. This was done intentionally as a holder may
* not to pay the gas costs associated with claiming USDT. Please see unstakeAndClaim
* to also claim USDT.
*
* Unstaking your NFT transfers ownership back to the address that staked it.
* When an NFT is unstaked, you will no longer be earning USDT.
*/
function unstake(uint256 stakeId) public {
}
/**
* @dev claim earned USDT without unstaking
*/
function claim(uint256 stakeId) public {
require(<FILL_ME>)
StakeInfo storage stakeInfo = _stakeInfo[msg.sender][stakeId];
uint64 stakedTime;
if (!isStopped) {
stakedTime = uint64(block.timestamp) - stakeInfo.claimTime;
} else {
stakedTime = stopTime - stakeInfo.claimTime;
}
require(stakedTime > Interval, "Nothing accrued yet");
uint64 intervalsPassed = stakedTime / Interval;
stakeInfo.claimTime += Interval * intervalsPassed;
uint256 totalReward = intervalsPassed * rewards[stakeInfo.tokenId];
require(
usdtAddress.balanceOf(fund) > totalReward,
"Not enough tokens in the fund. Contact Team."
);
bool success = usdtAddress.transferFrom(fund, msg.sender, totalReward);
require(success, "Error while transfering tokens");
emit Claim(msg.sender, totalReward);
}
function claimMultiple(uint256[] calldata stakeIds) public {
}
function getActiveStakingsInfo(
address account
) public view returns (StakeInfo[] memory) {
}
/**
* Track stakings of an account
*/
function getActiveStakingsID(
address account
) external view returns (uint256[] memory) {
}
/**
* @dev unstakeAndClaim will unstake the token and realize the USDT that it has earned.
* If you are not interested in earning USDT you can call unstaske and save the gas.
* Unstaking your NFT transfers ownership back to the address that staked it.
* When an NFT is unstaked you will no longer be earning USDT.
*/
function claimAndUnstake(uint256[] calldata _stakeIds) external {
}
/**
* Allows contract owner to withdraw ERC20 tokens from the contract
*/
function withdrawTokens(IERC20 _usdtAddress) external onlyOwner {
}
function stopContract() external onlyOwner {
}
}
| _activeIDs[msg.sender].contains(stakeId),"StakingID not active" | 463,120 | _activeIDs[msg.sender].contains(stakeId) |
"Not enough tokens in the fund. Contact Team." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
contract WeldostStaking is Ownable, ERC1155Holder {
using EnumerableSet for EnumerableSet.UintSet;
// Contract Addresses
IERC1155 public immutable nftAddress;
IERC20 public immutable usdtAddress;
address private immutable fund;
uint64 public constant Interval = 30 days;
bool public isStopped;
uint64 public stopTime;
// Staking Tracking
mapping(address => uint256) public _currentIDs;
mapping(address => EnumerableSet.UintSet) private _activeIDs;
mapping(address => mapping(uint256 => StakeInfo)) public _stakeInfo;
uint256[] public rewards = [
5_000_000,
25_000_000,
50_000_000,
75_000_000,
125_000_000,
250_000_000
];
struct StakeInfo {
uint64 tokenId;
uint64 startTime;
uint64 claimTime;
}
// Events
event Stake(address addr, uint256[] tokenIds, uint256[] quantities);
event Unstake(address addr, uint256 stakeId, uint256 tokenId);
event Claim(address addr, uint256 amount);
constructor(IERC1155 _nftAddress, IERC20 _usdtAddress, address _fund) {
}
/**
* Stake multiple NFTs into the contract
*/
function stake(
uint256[] calldata tokenIds,
uint256[] calldata quantities
) external {
}
/**
@notice unstaking a token that has unrealized USDT forfeits the USDT associated
* with the token(s) being unstaked. This was done intentionally as a holder may
* not to pay the gas costs associated with claiming USDT. Please see unstakeAndClaim
* to also claim USDT.
*
* Unstaking your NFT transfers ownership back to the address that staked it.
* When an NFT is unstaked, you will no longer be earning USDT.
*/
function unstakeMultiple(uint256[] calldata stakeIds) public {
}
/**
@notice unstaking a token that has unrealized USDT forfeits the USDT associated
* with the token(s) being unstaked. This was done intentionally as a holder may
* not to pay the gas costs associated with claiming USDT. Please see unstakeAndClaim
* to also claim USDT.
*
* Unstaking your NFT transfers ownership back to the address that staked it.
* When an NFT is unstaked, you will no longer be earning USDT.
*/
function unstake(uint256 stakeId) public {
}
/**
* @dev claim earned USDT without unstaking
*/
function claim(uint256 stakeId) public {
require(
_activeIDs[msg.sender].contains(stakeId),
"StakingID not active"
);
StakeInfo storage stakeInfo = _stakeInfo[msg.sender][stakeId];
uint64 stakedTime;
if (!isStopped) {
stakedTime = uint64(block.timestamp) - stakeInfo.claimTime;
} else {
stakedTime = stopTime - stakeInfo.claimTime;
}
require(stakedTime > Interval, "Nothing accrued yet");
uint64 intervalsPassed = stakedTime / Interval;
stakeInfo.claimTime += Interval * intervalsPassed;
uint256 totalReward = intervalsPassed * rewards[stakeInfo.tokenId];
require(<FILL_ME>)
bool success = usdtAddress.transferFrom(fund, msg.sender, totalReward);
require(success, "Error while transfering tokens");
emit Claim(msg.sender, totalReward);
}
function claimMultiple(uint256[] calldata stakeIds) public {
}
function getActiveStakingsInfo(
address account
) public view returns (StakeInfo[] memory) {
}
/**
* Track stakings of an account
*/
function getActiveStakingsID(
address account
) external view returns (uint256[] memory) {
}
/**
* @dev unstakeAndClaim will unstake the token and realize the USDT that it has earned.
* If you are not interested in earning USDT you can call unstaske and save the gas.
* Unstaking your NFT transfers ownership back to the address that staked it.
* When an NFT is unstaked you will no longer be earning USDT.
*/
function claimAndUnstake(uint256[] calldata _stakeIds) external {
}
/**
* Allows contract owner to withdraw ERC20 tokens from the contract
*/
function withdrawTokens(IERC20 _usdtAddress) external onlyOwner {
}
function stopContract() external onlyOwner {
}
}
| usdtAddress.balanceOf(fund)>totalReward,"Not enough tokens in the fund. Contact Team." | 463,120 | usdtAddress.balanceOf(fund)>totalReward |
"registration cost no met" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";
import "@chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol";
import "@chainlink/contracts/src/v0.8/interfaces/AutomationCompatibleInterface.sol";
import "hardhat/console.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
/* Errors */
error Raffle__UpkeepNotNeeded(uint256 currentBalance, uint256 numPlayers, uint256 raffleState);
error Raffle__RaffleNotOpen();
error WithdrawTransfer();
/**@title Burger Raffle Contract
* @author Credits to Patrick Collins for inspiration and secure boilerplate
* @notice This contract is lottery for flrbrg.io
* @dev This implements the Chainlink VRF Version 2 and Chainlink Upkeepers
*/
contract Raffle is Ownable, VRFConsumerBaseV2, AutomationCompatibleInterface {
/* Type declarations */
enum RaffleState {
OPEN,
CALCULATING
}
/* Burger declaration */
IERC20 public immutable i_FLRBRG;
mapping(uint256 => mapping(address => uint256)) private s_tickets;
mapping(uint256 => address) private s_playersMapping;
/* State variables */
// Chainlink VRF Variables
VRFCoordinatorV2Interface private immutable i_vrfCoordinator;
uint64 private immutable i_subscriptionId;
bytes32 private immutable i_gasLane;
uint32 private immutable i_callbackGasLimit;
uint16 private constant REQUEST_CONFIRMATIONS = 3;
uint32 private constant NUM_WORDS = 1;
// Lottery Variables
uint256 private s_interval;
uint256 private s_entranceFee;
uint256 private s_lastTimeStamp;
uint256 private s_seventhDayTimeStamp;
address private s_recentWinner;
address private s_V1;
address private s_V2;
address private s_burn;
RaffleState private s_raffleState;
uint256 private s_treasuryV1Balance;
uint256 private s_treasuryV2Balance;
uint256 private s_raffleBalance;
uint256 private s_raffleBalanceSeventhDay;
uint256 private s_burnBalance;
uint256 private s_feePercentV1;
uint256 private s_feePercentV2;
uint256 private s_feePercentRaffleSeventhDay;
uint256 private s_feePercentBurn;
uint256 private s_gameCount = 1;
uint256 private s_lotteryDay = 1;
uint256 private s_playersCount;
/* Events */
event RequestedRaffleWinner(uint256 indexed requestId);
event RaffleEnter(address indexed player, uint256 indexed ticketsOfPlayer, uint256 gameCount);
event WinnerPicked(
address indexed player,
uint256 indexed ticketsOfPlayer,
uint256 indexed amountWon,
uint256 gameCount,
uint256 ticketsInRound
);
event WeeklyWinnerPicked(
address indexed player,
uint256 indexed ticketsOfPlayer,
uint256 indexed amountWon,
uint256 gameCount,
uint256 ticketsInRound
);
/* Functions */
constructor(
address vrfCoordinatorV2,
uint64 subscriptionId,
bytes32 gasLane, // keyHash
uint256 interval,
uint256 entranceFee,
uint32 callbackGasLimit,
address FLRBRG,
address V1,
address V2
) Ownable() VRFConsumerBaseV2(vrfCoordinatorV2) {
}
function enterRaffle(uint256 entries) public {
require(<FILL_ME>)
require(
(i_FLRBRG.transferFrom(msg.sender, address(this), (s_entranceFee * entries))) &&
entries > 0
);
if (s_raffleState != RaffleState.OPEN) {
revert Raffle__RaffleNotOpen();
}
s_raffleBalanceSeventhDay += (((s_entranceFee * entries) *
(s_feePercentRaffleSeventhDay * 1e2)) / 1e4);
s_treasuryV1Balance += (((s_entranceFee * entries) * (s_feePercentV1 * 1e2)) / 1e4);
s_treasuryV2Balance += (((s_entranceFee * entries) * (s_feePercentV2 * 1e2)) / 1e4);
s_burnBalance += (((s_entranceFee * entries) * (s_feePercentBurn * 1e2)) / 1e4);
s_raffleBalance += ((s_entranceFee * entries) -
(((s_entranceFee * entries) * (s_feePercentRaffleSeventhDay * 1e2)) / 1e4) -
(((s_entranceFee * entries) * (s_feePercentV1 * 1e2)) / 1e4) -
(((s_entranceFee * entries) * (s_feePercentV2 * 1e2)) / 1e4) -
(((s_entranceFee * entries) * (s_feePercentBurn * 1e2)) / 1e4));
for (uint256 i = 0; i < entries; i++) {
s_playersMapping[s_playersCount] = msg.sender;
++s_playersCount;
++s_tickets[s_gameCount][msg.sender];
}
emit RaffleEnter(msg.sender, s_tickets[s_gameCount][msg.sender], s_gameCount);
}
/**
* @dev This is the function that the Chainlink Keeper nodes call
* they look for `upkeepNeeded` to return True.
* the following should be true for this to return true:
* 1. The time interval has passed between raffle runs.
* 2. The lottery is open.
* 3. The contract has ETH.
* 4. Implicity, your subscription is funded with LINK.
*/
function checkUpkeep(
bytes memory /* checkData */
) public view override returns (bool upkeepNeeded, bytes memory /* performData */) {
}
/**
* @dev Once `checkUpkeep` is returning `true`, this function is called
* and it kicks off a Chainlink VRF call to get a random winner.
*/
function performUpkeep(bytes calldata /* performData */) external override {
}
/**
* @dev This is the function that Chainlink VRF node
* calls to send the money to the random winner.
*/
function fulfillRandomWords(
uint256 /* requestId */,
uint256[] memory randomWords
) internal override {
}
/** Recovery Functions and Setters */
function recoverTreasuryV1() external {
}
function burnTokens() external onlyOwner {
}
function setInterval(uint256 interval) external onlyOwner {
}
function setEntraceFee(uint256 entranceFee) external onlyOwner {
}
function setFeePercentV1(uint256 feePercent) external onlyOwner {
}
function setFeePercentV2(uint256 feePercent) external {
}
function setFeePercentBurn(uint256 feePercent) external onlyOwner {
}
function setFeePercentRaffleSeventhDay(uint256 feePercent) external onlyOwner {
}
function setDay(uint256 day) external onlyOwner {
}
function setNewWeeklyPrize(uint256 prize) external onlyOwner {
}
function recoverTreasuryV2() external {
}
function emergencyRecovery() external onlyOwner {
}
function withdrawPayments(address payable payee) external onlyOwner {
}
/** Getter Functions */
function getRaffleState() public view returns (RaffleState) {
}
function getNumWords() public pure returns (uint256) {
}
function getRequestConfirmations() public pure returns (uint256) {
}
function getRecentWinner() public view returns (address) {
}
function getPlayer(uint256 index) public view returns (address) {
}
function getLastTimeStamp() public view returns (uint256) {
}
function getInterval() public view returns (uint256) {
}
function getEntranceFee() public view returns (uint256) {
}
function getNumberOfPlayers() public view returns (uint256) {
}
function getTicketsOfPlayer(address player) external view returns (uint256) {
}
function getVrfCoordinatorV2Address() public view returns (address) {
}
function getGasLane() public view returns (bytes32) {
}
function getSeventhDayTimestamp() public view returns (uint256) {
}
function getV1() public view returns (address) {
}
function getV2() public view returns (address) {
}
function getTreasuryV1Balance() public view returns (uint256) {
}
function getTreasuryV2Balance() public view returns (uint256) {
}
function getRaffleBalance() public view returns (uint256) {
}
function getRaffleBalanceSeventhDay() public view returns (uint256) {
}
function getFeePercentV1() public view returns (uint256) {
}
function getBurnFeePercent() public view returns (uint256) {
}
function getFeePercentRaffleSeventhDay() public view returns (uint256) {
}
function getGameCount() public view returns (uint256) {
}
function getCurrentLotteryDay() public view returns (uint256) {
}
function getBurnBalance() public view returns (uint256) {
}
}
| i_FLRBRG.allowance(msg.sender,address(this))>=(s_entranceFee*entries),"registration cost no met" | 463,259 | i_FLRBRG.allowance(msg.sender,address(this))>=(s_entranceFee*entries) |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";
import "@chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol";
import "@chainlink/contracts/src/v0.8/interfaces/AutomationCompatibleInterface.sol";
import "hardhat/console.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
/* Errors */
error Raffle__UpkeepNotNeeded(uint256 currentBalance, uint256 numPlayers, uint256 raffleState);
error Raffle__RaffleNotOpen();
error WithdrawTransfer();
/**@title Burger Raffle Contract
* @author Credits to Patrick Collins for inspiration and secure boilerplate
* @notice This contract is lottery for flrbrg.io
* @dev This implements the Chainlink VRF Version 2 and Chainlink Upkeepers
*/
contract Raffle is Ownable, VRFConsumerBaseV2, AutomationCompatibleInterface {
/* Type declarations */
enum RaffleState {
OPEN,
CALCULATING
}
/* Burger declaration */
IERC20 public immutable i_FLRBRG;
mapping(uint256 => mapping(address => uint256)) private s_tickets;
mapping(uint256 => address) private s_playersMapping;
/* State variables */
// Chainlink VRF Variables
VRFCoordinatorV2Interface private immutable i_vrfCoordinator;
uint64 private immutable i_subscriptionId;
bytes32 private immutable i_gasLane;
uint32 private immutable i_callbackGasLimit;
uint16 private constant REQUEST_CONFIRMATIONS = 3;
uint32 private constant NUM_WORDS = 1;
// Lottery Variables
uint256 private s_interval;
uint256 private s_entranceFee;
uint256 private s_lastTimeStamp;
uint256 private s_seventhDayTimeStamp;
address private s_recentWinner;
address private s_V1;
address private s_V2;
address private s_burn;
RaffleState private s_raffleState;
uint256 private s_treasuryV1Balance;
uint256 private s_treasuryV2Balance;
uint256 private s_raffleBalance;
uint256 private s_raffleBalanceSeventhDay;
uint256 private s_burnBalance;
uint256 private s_feePercentV1;
uint256 private s_feePercentV2;
uint256 private s_feePercentRaffleSeventhDay;
uint256 private s_feePercentBurn;
uint256 private s_gameCount = 1;
uint256 private s_lotteryDay = 1;
uint256 private s_playersCount;
/* Events */
event RequestedRaffleWinner(uint256 indexed requestId);
event RaffleEnter(address indexed player, uint256 indexed ticketsOfPlayer, uint256 gameCount);
event WinnerPicked(
address indexed player,
uint256 indexed ticketsOfPlayer,
uint256 indexed amountWon,
uint256 gameCount,
uint256 ticketsInRound
);
event WeeklyWinnerPicked(
address indexed player,
uint256 indexed ticketsOfPlayer,
uint256 indexed amountWon,
uint256 gameCount,
uint256 ticketsInRound
);
/* Functions */
constructor(
address vrfCoordinatorV2,
uint64 subscriptionId,
bytes32 gasLane, // keyHash
uint256 interval,
uint256 entranceFee,
uint32 callbackGasLimit,
address FLRBRG,
address V1,
address V2
) Ownable() VRFConsumerBaseV2(vrfCoordinatorV2) {
}
function enterRaffle(uint256 entries) public {
require(
i_FLRBRG.allowance(msg.sender, address(this)) >= (s_entranceFee * entries),
"registration cost no met"
);
require(<FILL_ME>)
if (s_raffleState != RaffleState.OPEN) {
revert Raffle__RaffleNotOpen();
}
s_raffleBalanceSeventhDay += (((s_entranceFee * entries) *
(s_feePercentRaffleSeventhDay * 1e2)) / 1e4);
s_treasuryV1Balance += (((s_entranceFee * entries) * (s_feePercentV1 * 1e2)) / 1e4);
s_treasuryV2Balance += (((s_entranceFee * entries) * (s_feePercentV2 * 1e2)) / 1e4);
s_burnBalance += (((s_entranceFee * entries) * (s_feePercentBurn * 1e2)) / 1e4);
s_raffleBalance += ((s_entranceFee * entries) -
(((s_entranceFee * entries) * (s_feePercentRaffleSeventhDay * 1e2)) / 1e4) -
(((s_entranceFee * entries) * (s_feePercentV1 * 1e2)) / 1e4) -
(((s_entranceFee * entries) * (s_feePercentV2 * 1e2)) / 1e4) -
(((s_entranceFee * entries) * (s_feePercentBurn * 1e2)) / 1e4));
for (uint256 i = 0; i < entries; i++) {
s_playersMapping[s_playersCount] = msg.sender;
++s_playersCount;
++s_tickets[s_gameCount][msg.sender];
}
emit RaffleEnter(msg.sender, s_tickets[s_gameCount][msg.sender], s_gameCount);
}
/**
* @dev This is the function that the Chainlink Keeper nodes call
* they look for `upkeepNeeded` to return True.
* the following should be true for this to return true:
* 1. The time interval has passed between raffle runs.
* 2. The lottery is open.
* 3. The contract has ETH.
* 4. Implicity, your subscription is funded with LINK.
*/
function checkUpkeep(
bytes memory /* checkData */
) public view override returns (bool upkeepNeeded, bytes memory /* performData */) {
}
/**
* @dev Once `checkUpkeep` is returning `true`, this function is called
* and it kicks off a Chainlink VRF call to get a random winner.
*/
function performUpkeep(bytes calldata /* performData */) external override {
}
/**
* @dev This is the function that Chainlink VRF node
* calls to send the money to the random winner.
*/
function fulfillRandomWords(
uint256 /* requestId */,
uint256[] memory randomWords
) internal override {
}
/** Recovery Functions and Setters */
function recoverTreasuryV1() external {
}
function burnTokens() external onlyOwner {
}
function setInterval(uint256 interval) external onlyOwner {
}
function setEntraceFee(uint256 entranceFee) external onlyOwner {
}
function setFeePercentV1(uint256 feePercent) external onlyOwner {
}
function setFeePercentV2(uint256 feePercent) external {
}
function setFeePercentBurn(uint256 feePercent) external onlyOwner {
}
function setFeePercentRaffleSeventhDay(uint256 feePercent) external onlyOwner {
}
function setDay(uint256 day) external onlyOwner {
}
function setNewWeeklyPrize(uint256 prize) external onlyOwner {
}
function recoverTreasuryV2() external {
}
function emergencyRecovery() external onlyOwner {
}
function withdrawPayments(address payable payee) external onlyOwner {
}
/** Getter Functions */
function getRaffleState() public view returns (RaffleState) {
}
function getNumWords() public pure returns (uint256) {
}
function getRequestConfirmations() public pure returns (uint256) {
}
function getRecentWinner() public view returns (address) {
}
function getPlayer(uint256 index) public view returns (address) {
}
function getLastTimeStamp() public view returns (uint256) {
}
function getInterval() public view returns (uint256) {
}
function getEntranceFee() public view returns (uint256) {
}
function getNumberOfPlayers() public view returns (uint256) {
}
function getTicketsOfPlayer(address player) external view returns (uint256) {
}
function getVrfCoordinatorV2Address() public view returns (address) {
}
function getGasLane() public view returns (bytes32) {
}
function getSeventhDayTimestamp() public view returns (uint256) {
}
function getV1() public view returns (address) {
}
function getV2() public view returns (address) {
}
function getTreasuryV1Balance() public view returns (uint256) {
}
function getTreasuryV2Balance() public view returns (uint256) {
}
function getRaffleBalance() public view returns (uint256) {
}
function getRaffleBalanceSeventhDay() public view returns (uint256) {
}
function getFeePercentV1() public view returns (uint256) {
}
function getBurnFeePercent() public view returns (uint256) {
}
function getFeePercentRaffleSeventhDay() public view returns (uint256) {
}
function getGameCount() public view returns (uint256) {
}
function getCurrentLotteryDay() public view returns (uint256) {
}
function getBurnBalance() public view returns (uint256) {
}
}
| (i_FLRBRG.transferFrom(msg.sender,address(this),(s_entranceFee*entries)))&&entries>0 | 463,259 | (i_FLRBRG.transferFrom(msg.sender,address(this),(s_entranceFee*entries)))&&entries>0 |
"Raffle__TransferFailed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";
import "@chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol";
import "@chainlink/contracts/src/v0.8/interfaces/AutomationCompatibleInterface.sol";
import "hardhat/console.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
/* Errors */
error Raffle__UpkeepNotNeeded(uint256 currentBalance, uint256 numPlayers, uint256 raffleState);
error Raffle__RaffleNotOpen();
error WithdrawTransfer();
/**@title Burger Raffle Contract
* @author Credits to Patrick Collins for inspiration and secure boilerplate
* @notice This contract is lottery for flrbrg.io
* @dev This implements the Chainlink VRF Version 2 and Chainlink Upkeepers
*/
contract Raffle is Ownable, VRFConsumerBaseV2, AutomationCompatibleInterface {
/* Type declarations */
enum RaffleState {
OPEN,
CALCULATING
}
/* Burger declaration */
IERC20 public immutable i_FLRBRG;
mapping(uint256 => mapping(address => uint256)) private s_tickets;
mapping(uint256 => address) private s_playersMapping;
/* State variables */
// Chainlink VRF Variables
VRFCoordinatorV2Interface private immutable i_vrfCoordinator;
uint64 private immutable i_subscriptionId;
bytes32 private immutable i_gasLane;
uint32 private immutable i_callbackGasLimit;
uint16 private constant REQUEST_CONFIRMATIONS = 3;
uint32 private constant NUM_WORDS = 1;
// Lottery Variables
uint256 private s_interval;
uint256 private s_entranceFee;
uint256 private s_lastTimeStamp;
uint256 private s_seventhDayTimeStamp;
address private s_recentWinner;
address private s_V1;
address private s_V2;
address private s_burn;
RaffleState private s_raffleState;
uint256 private s_treasuryV1Balance;
uint256 private s_treasuryV2Balance;
uint256 private s_raffleBalance;
uint256 private s_raffleBalanceSeventhDay;
uint256 private s_burnBalance;
uint256 private s_feePercentV1;
uint256 private s_feePercentV2;
uint256 private s_feePercentRaffleSeventhDay;
uint256 private s_feePercentBurn;
uint256 private s_gameCount = 1;
uint256 private s_lotteryDay = 1;
uint256 private s_playersCount;
/* Events */
event RequestedRaffleWinner(uint256 indexed requestId);
event RaffleEnter(address indexed player, uint256 indexed ticketsOfPlayer, uint256 gameCount);
event WinnerPicked(
address indexed player,
uint256 indexed ticketsOfPlayer,
uint256 indexed amountWon,
uint256 gameCount,
uint256 ticketsInRound
);
event WeeklyWinnerPicked(
address indexed player,
uint256 indexed ticketsOfPlayer,
uint256 indexed amountWon,
uint256 gameCount,
uint256 ticketsInRound
);
/* Functions */
constructor(
address vrfCoordinatorV2,
uint64 subscriptionId,
bytes32 gasLane, // keyHash
uint256 interval,
uint256 entranceFee,
uint32 callbackGasLimit,
address FLRBRG,
address V1,
address V2
) Ownable() VRFConsumerBaseV2(vrfCoordinatorV2) {
}
function enterRaffle(uint256 entries) public {
}
/**
* @dev This is the function that the Chainlink Keeper nodes call
* they look for `upkeepNeeded` to return True.
* the following should be true for this to return true:
* 1. The time interval has passed between raffle runs.
* 2. The lottery is open.
* 3. The contract has ETH.
* 4. Implicity, your subscription is funded with LINK.
*/
function checkUpkeep(
bytes memory /* checkData */
) public view override returns (bool upkeepNeeded, bytes memory /* performData */) {
}
/**
* @dev Once `checkUpkeep` is returning `true`, this function is called
* and it kicks off a Chainlink VRF call to get a random winner.
*/
function performUpkeep(bytes calldata /* performData */) external override {
}
/**
* @dev This is the function that Chainlink VRF node
* calls to send the money to the random winner.
*/
function fulfillRandomWords(
uint256 /* requestId */,
uint256[] memory randomWords
) internal override {
if (s_lotteryDay == 7) {
uint256 indexOfWinner = randomWords[0] % s_playersCount;
address recentWinner = s_playersMapping[indexOfWinner];
s_recentWinner = recentWinner;
s_raffleState = RaffleState.OPEN;
s_lastTimeStamp = block.timestamp;
s_seventhDayTimeStamp = block.timestamp;
uint256 playersCount = s_playersCount;
s_playersCount = 0;
uint256 newBalance = s_raffleBalanceSeventhDay + s_raffleBalance;
s_raffleBalanceSeventhDay = 0;
s_raffleBalance = 0;
require(<FILL_ME>)
s_lotteryDay = 1;
emit WeeklyWinnerPicked(
recentWinner,
s_tickets[s_gameCount][s_recentWinner],
newBalance,
s_gameCount,
playersCount
);
++s_gameCount;
} else {
uint256 indexOfWinner = randomWords[0] % s_playersCount;
address recentWinner = s_playersMapping[indexOfWinner];
s_recentWinner = recentWinner;
s_raffleState = RaffleState.OPEN;
s_lastTimeStamp = block.timestamp;
uint256 playersCount = s_playersCount;
s_playersCount = 0;
uint256 newBalance = s_raffleBalance;
s_raffleBalance = 0;
require(i_FLRBRG.transfer(s_recentWinner, newBalance), "Raffle__TransferFailed");
++s_lotteryDay;
emit WinnerPicked(
recentWinner,
s_tickets[s_gameCount][recentWinner],
newBalance,
s_gameCount,
playersCount
);
++s_gameCount;
}
}
/** Recovery Functions and Setters */
function recoverTreasuryV1() external {
}
function burnTokens() external onlyOwner {
}
function setInterval(uint256 interval) external onlyOwner {
}
function setEntraceFee(uint256 entranceFee) external onlyOwner {
}
function setFeePercentV1(uint256 feePercent) external onlyOwner {
}
function setFeePercentV2(uint256 feePercent) external {
}
function setFeePercentBurn(uint256 feePercent) external onlyOwner {
}
function setFeePercentRaffleSeventhDay(uint256 feePercent) external onlyOwner {
}
function setDay(uint256 day) external onlyOwner {
}
function setNewWeeklyPrize(uint256 prize) external onlyOwner {
}
function recoverTreasuryV2() external {
}
function emergencyRecovery() external onlyOwner {
}
function withdrawPayments(address payable payee) external onlyOwner {
}
/** Getter Functions */
function getRaffleState() public view returns (RaffleState) {
}
function getNumWords() public pure returns (uint256) {
}
function getRequestConfirmations() public pure returns (uint256) {
}
function getRecentWinner() public view returns (address) {
}
function getPlayer(uint256 index) public view returns (address) {
}
function getLastTimeStamp() public view returns (uint256) {
}
function getInterval() public view returns (uint256) {
}
function getEntranceFee() public view returns (uint256) {
}
function getNumberOfPlayers() public view returns (uint256) {
}
function getTicketsOfPlayer(address player) external view returns (uint256) {
}
function getVrfCoordinatorV2Address() public view returns (address) {
}
function getGasLane() public view returns (bytes32) {
}
function getSeventhDayTimestamp() public view returns (uint256) {
}
function getV1() public view returns (address) {
}
function getV2() public view returns (address) {
}
function getTreasuryV1Balance() public view returns (uint256) {
}
function getTreasuryV2Balance() public view returns (uint256) {
}
function getRaffleBalance() public view returns (uint256) {
}
function getRaffleBalanceSeventhDay() public view returns (uint256) {
}
function getFeePercentV1() public view returns (uint256) {
}
function getBurnFeePercent() public view returns (uint256) {
}
function getFeePercentRaffleSeventhDay() public view returns (uint256) {
}
function getGameCount() public view returns (uint256) {
}
function getCurrentLotteryDay() public view returns (uint256) {
}
function getBurnBalance() public view returns (uint256) {
}
}
| i_FLRBRG.transfer(s_recentWinner,newBalance),"Raffle__TransferFailed" | 463,259 | i_FLRBRG.transfer(s_recentWinner,newBalance) |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";
import "@chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol";
import "@chainlink/contracts/src/v0.8/interfaces/AutomationCompatibleInterface.sol";
import "hardhat/console.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
/* Errors */
error Raffle__UpkeepNotNeeded(uint256 currentBalance, uint256 numPlayers, uint256 raffleState);
error Raffle__RaffleNotOpen();
error WithdrawTransfer();
/**@title Burger Raffle Contract
* @author Credits to Patrick Collins for inspiration and secure boilerplate
* @notice This contract is lottery for flrbrg.io
* @dev This implements the Chainlink VRF Version 2 and Chainlink Upkeepers
*/
contract Raffle is Ownable, VRFConsumerBaseV2, AutomationCompatibleInterface {
/* Type declarations */
enum RaffleState {
OPEN,
CALCULATING
}
/* Burger declaration */
IERC20 public immutable i_FLRBRG;
mapping(uint256 => mapping(address => uint256)) private s_tickets;
mapping(uint256 => address) private s_playersMapping;
/* State variables */
// Chainlink VRF Variables
VRFCoordinatorV2Interface private immutable i_vrfCoordinator;
uint64 private immutable i_subscriptionId;
bytes32 private immutable i_gasLane;
uint32 private immutable i_callbackGasLimit;
uint16 private constant REQUEST_CONFIRMATIONS = 3;
uint32 private constant NUM_WORDS = 1;
// Lottery Variables
uint256 private s_interval;
uint256 private s_entranceFee;
uint256 private s_lastTimeStamp;
uint256 private s_seventhDayTimeStamp;
address private s_recentWinner;
address private s_V1;
address private s_V2;
address private s_burn;
RaffleState private s_raffleState;
uint256 private s_treasuryV1Balance;
uint256 private s_treasuryV2Balance;
uint256 private s_raffleBalance;
uint256 private s_raffleBalanceSeventhDay;
uint256 private s_burnBalance;
uint256 private s_feePercentV1;
uint256 private s_feePercentV2;
uint256 private s_feePercentRaffleSeventhDay;
uint256 private s_feePercentBurn;
uint256 private s_gameCount = 1;
uint256 private s_lotteryDay = 1;
uint256 private s_playersCount;
/* Events */
event RequestedRaffleWinner(uint256 indexed requestId);
event RaffleEnter(address indexed player, uint256 indexed ticketsOfPlayer, uint256 gameCount);
event WinnerPicked(
address indexed player,
uint256 indexed ticketsOfPlayer,
uint256 indexed amountWon,
uint256 gameCount,
uint256 ticketsInRound
);
event WeeklyWinnerPicked(
address indexed player,
uint256 indexed ticketsOfPlayer,
uint256 indexed amountWon,
uint256 gameCount,
uint256 ticketsInRound
);
/* Functions */
constructor(
address vrfCoordinatorV2,
uint64 subscriptionId,
bytes32 gasLane, // keyHash
uint256 interval,
uint256 entranceFee,
uint32 callbackGasLimit,
address FLRBRG,
address V1,
address V2
) Ownable() VRFConsumerBaseV2(vrfCoordinatorV2) {
}
function enterRaffle(uint256 entries) public {
}
/**
* @dev This is the function that the Chainlink Keeper nodes call
* they look for `upkeepNeeded` to return True.
* the following should be true for this to return true:
* 1. The time interval has passed between raffle runs.
* 2. The lottery is open.
* 3. The contract has ETH.
* 4. Implicity, your subscription is funded with LINK.
*/
function checkUpkeep(
bytes memory /* checkData */
) public view override returns (bool upkeepNeeded, bytes memory /* performData */) {
}
/**
* @dev Once `checkUpkeep` is returning `true`, this function is called
* and it kicks off a Chainlink VRF call to get a random winner.
*/
function performUpkeep(bytes calldata /* performData */) external override {
}
/**
* @dev This is the function that Chainlink VRF node
* calls to send the money to the random winner.
*/
function fulfillRandomWords(
uint256 /* requestId */,
uint256[] memory randomWords
) internal override {
}
/** Recovery Functions and Setters */
function recoverTreasuryV1() external {
}
function burnTokens() external onlyOwner {
}
function setInterval(uint256 interval) external onlyOwner {
}
function setEntraceFee(uint256 entranceFee) external onlyOwner {
}
function setFeePercentV1(uint256 feePercent) external onlyOwner {
}
function setFeePercentV2(uint256 feePercent) external {
}
function setFeePercentBurn(uint256 feePercent) external onlyOwner {
}
function setFeePercentRaffleSeventhDay(uint256 feePercent) external onlyOwner {
}
function setDay(uint256 day) external onlyOwner {
}
function setNewWeeklyPrize(uint256 prize) external onlyOwner {
require(<FILL_ME>) //needs to be approved first
s_raffleBalanceSeventhDay += prize; //1e18 for prize
}
function recoverTreasuryV2() external {
}
function emergencyRecovery() external onlyOwner {
}
function withdrawPayments(address payable payee) external onlyOwner {
}
/** Getter Functions */
function getRaffleState() public view returns (RaffleState) {
}
function getNumWords() public pure returns (uint256) {
}
function getRequestConfirmations() public pure returns (uint256) {
}
function getRecentWinner() public view returns (address) {
}
function getPlayer(uint256 index) public view returns (address) {
}
function getLastTimeStamp() public view returns (uint256) {
}
function getInterval() public view returns (uint256) {
}
function getEntranceFee() public view returns (uint256) {
}
function getNumberOfPlayers() public view returns (uint256) {
}
function getTicketsOfPlayer(address player) external view returns (uint256) {
}
function getVrfCoordinatorV2Address() public view returns (address) {
}
function getGasLane() public view returns (bytes32) {
}
function getSeventhDayTimestamp() public view returns (uint256) {
}
function getV1() public view returns (address) {
}
function getV2() public view returns (address) {
}
function getTreasuryV1Balance() public view returns (uint256) {
}
function getTreasuryV2Balance() public view returns (uint256) {
}
function getRaffleBalance() public view returns (uint256) {
}
function getRaffleBalanceSeventhDay() public view returns (uint256) {
}
function getFeePercentV1() public view returns (uint256) {
}
function getBurnFeePercent() public view returns (uint256) {
}
function getFeePercentRaffleSeventhDay() public view returns (uint256) {
}
function getGameCount() public view returns (uint256) {
}
function getCurrentLotteryDay() public view returns (uint256) {
}
function getBurnBalance() public view returns (uint256) {
}
}
| i_FLRBRG.transferFrom(msg.sender,address(this),prize) | 463,259 | i_FLRBRG.transferFrom(msg.sender,address(this),prize) |
"Transfer amount exceeds the bag size." | // SPDX-License-Identifier: MIT
/*
Maximize your earnings with compounded staking, MEV boosts & HODL rewards while staying liquid.
Web: https://hodlfi.biz
App: https://app.hodlfi.biz
X: https://twitter.com/HodlFi_ERC
Tg: https://t.me/hodlfi_biz_official
Medium: https://medium.com/@hodl.defi
*/
pragma solidity 0.8.19;
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);
}
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) internal view returns (bool) {
}
function renounceOwnership() public onlyOwner {
}
event OwnershipTransferred(address owner);
}
interface IUniswapV2Router {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address _uniswapPair);
}
contract HODLFI is IERC20, Ownable {
using SafeMath for uint256;
string private constant name_ = "HODL FINANCE";
string private constant symbol_ = "HODL";
uint8 private constant decimals_ = 9;
uint256 private totalSupply_ = 10 ** 9 * (10 ** decimals_);
uint256 private taxLiq_ = 0;
uint256 private taxMarket_ = 22;
uint256 private taxTotal_ = taxLiq_ + taxMarket_;
uint256 private denominator_ = 100;
mapping (address => uint256) private balances_;
mapping (address => mapping (address => uint256)) private allowances_;
mapping (address => bool) private noFeeAddress_;
mapping (address => bool) private noTxLimitAddress_;
uint256 private maxTxAmount_ = (totalSupply_ * 25) / 1000;
address private taxAddress_;
IUniswapV2Router private uniswapRouter_;
address private uniswapPair_;
bool private swapEnabled_ = true;
uint256 private minSwapThreshold_ = totalSupply_ / 100000; // 0.1%
bool private swapping_;
modifier lockSwap() { }
address private routerAddr_ = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address private deadAddress_ = 0x000000000000000000000000000000000000dEaD;
constructor (address HodlFiAddress) Ownable(msg.sender) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function updateHodlFiTax(uint256 lpFee, uint256 devFee) external onlyOwner {
}
function _checkSellings(address recipient) private view returns (bool){
}
function _checkIfSwap() internal view returns (bool) {
}
function adjustHodlFiWalletSize(uint256 percent) external onlyOwner {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
if(swapping_){ return _transferBasic(sender, recipient, amount); }
if (recipient != uniswapPair_ && recipient != deadAddress_) {
require(<FILL_ME>)
}
if(_verifySwapBack(sender, recipient, amount)){
performHodlFiSwap();
}
bool shouldTax = _shouldChargeTax(sender);
if (shouldTax) {
balances_[recipient] = balances_[recipient].add(_sendingAmt(sender, amount));
} else {
balances_[recipient] = balances_[recipient].add(amount);
}
emit Transfer(sender, recipient, amount);
return true;
}
function _transferBasic(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function _sendingAmt(address sender, uint256 amount) internal returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _shouldChargeTax(address sender) internal view returns (bool) {
}
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 totalSupply() external view override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function _verifySwapBack(address sender, address recipient, uint256 amount) private view returns (bool) {
}
receive() external payable { }
function performHodlFiSwap() internal lockSwap {
}
}
| noTxLimitAddress_[recipient]||balances_[recipient]+amount<=maxTxAmount_,"Transfer amount exceeds the bag size." | 463,314 | noTxLimitAddress_[recipient]||balances_[recipient]+amount<=maxTxAmount_ |
'Free mint already claimed by this address' | // 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 DegenSamurai is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
bytes32 public merkleRoot;
//mapping(address => bool) public whitelistClaimed;
mapping(address => bool) public whitelistBought;
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 = true;
bool public revealed = true;
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) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
// Verify whitelist requirements
require(whitelistMintEnabled, 'The whitelist sale is not enabled!');
require(<FILL_ME>)
whitelistBought[msg.sender] = true;
_safeMint(_msgSender(), _mintAmount);
}
function mint(uint256 _mintAmount) public payable mintCompliance(_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 checkWhiteListForUser(address _address) public view onlyOwner returns (bool) {
}
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) {
}
}
| whitelistBought[msg.sender]!=true,'Free mint already claimed by this address' | 463,338 | whitelistBought[msg.sender]!=true |
"already blacklist" | pragma solidity ^0.5.2;
/**
* @title Capped token
* @dev Mintable token with a token cap.
*/
contract ERC20Capped is ERC20 {
uint256 private _cap;
constructor (uint256 cap) public {
}
/**
* @return the cap for the token minting.
*/
function cap() public view returns (uint256) {
}
function _mint(address account, uint256 value) internal {
}
}
pragma solidity ^0.5.2;
contract ChainstackNetwork is ERC20Capped {
string public name = "Chainstack";
string public symbol = "CNS";
uint8 public decimals = 18;
uint256 constant TOTAL_CAP = 390000000 ether;
address public firstMaster;
address public secondMaster;
address public thirdMaster;
mapping(address => mapping(address => bool)) public decidedOwner;
address public owner;
address public gameMaster;
mapping(address => bool) public blackLists;
uint8 public unlockCount = 0;
address public strategicSaleAddress;
uint[] public strategicSaleReleaseCaps = [15000000 ether, 15000000 ether, 15000000 ether,
15000000 ether, 15000000 ether, 15000000 ether,
15000000 ether, 22500000 ether, 22500000 ether];
address public privateSaleAddress;
uint[] public privateSaleReleaseCaps = [97500000 ether, 97500000 ether, 97500000 ether,
97500000 ether, 130000000 ether, 130000000 ether];
address public publicSaleAddress;
uint public publicSaleReleaseCap = 200000000 ether;
address public teamAddress;
uint[] public teamReleaseCaps = [0, 0, 0, 0, 0, 0,
12500000 ether, 12500000 ether, 12500000 ether,
12500000 ether, 12500000 ether, 12500000 ether,
12500000 ether, 12500000 ether, 12500000 ether,
12500000 ether, 12500000 ether, 12500000 ether,
12500000 ether, 12500000 ether, 12500000 ether,
12500000 ether, 12500000 ether, 12500000 ether,
12500000 ether, 12500000 ether];
address public advisorAddress;
uint[] public advisorReleaseCaps = [0, 0, 0, 25000000 ether, 0, 25000000 ether,
0, 25000000 ether, 0, 25000000 ether, 0, 25000000 ether];
address public marketingAddress;
uint[] public marketingReleaseCaps = [100000000 ether, 25000000 ether, 25000000 ether,
25000000 ether, 25000000 ether, 25000000 ether,
25000000 ether, 25000000 ether, 25000000 ether,
25000000 ether, 25000000 ether, 25000000 ether];
address public ecoAddress;
uint[] public ecoReleaseCaps = [50000000 ether, 50000000 ether, 50000000 ether,
50000000 ether, 50000000 ether, 50000000 ether,
50000000 ether, 50000000 ether, 50000000 ether,
50000000 ether, 50000000 ether, 50000000 ether,
50000000 ether, 50000000 ether, 50000000 ether];
address payable public inAppAddress;
ERC20 erc20;
// appId => itemId => tokenAddress => amount
mapping(uint64 => mapping(uint64 => mapping(address => uint256))) items;
event Unlock(uint8 unlockCount);
event WithdrawEther(address indexed _to, uint256 amount);
event PurchaseItemOnEther(address indexed _spender, uint64 appId, uint64 itemId, uint256 amount);
event PurchaseItemOnChainStack(address indexed _spender, uint64 appId, uint64 itemId, uint256 amount);
event PurchaseItemOnERC20(address indexed _spender, address indexed _tokenAddress, uint64 appId, uint64 itemId, uint256 amount);
event SetItem(uint64 appId);
event ChangeOwner(address _owner);
constructor(address _firstMaster, address _secondMaster, address _thirdMaster,
address _owner, address _gameMaster, address _strategicSaleAddress,
address _privateSaleAddress, address _publicSaleAddress, address _teamAddress,
address _advisorAddress, address _marketingAddress, address _ecoAddress, address payable _inAppAddress) public ERC20Capped(TOTAL_CAP) {
}
modifier onlyOwner {
}
modifier onlyGameMaster {
}
modifier onlyMaster {
}
function setGameMaster(address _gameMaster) public onlyOwner {
}
function transfer(address _to, uint256 _value) public onlyNotBlackList returns (bool) {
}
function transferFrom(address _from, address _to, uint256 _value) public onlyNotBlackList returns (bool) {
}
function approve(address spender, uint256 value) public onlyNotBlackList returns (bool) {
}
function burn(uint256 value) public onlyOwner {
}
function unlock() public onlyOwner returns (bool) {
}
function setAddresses(address _strategicSaleAddress, address _privateSaleAddress, address _publicSaleAddress, address _teamAddress, address _advisorAddress, address _marketingAddress, address _ecoAddress,
address payable _inAppAddress) public onlyOwner {
}
function changeOwner(address _owner) public onlyMaster {
}
function addToBlackList(address _to) public onlyOwner {
require(<FILL_ME>)
blackLists[_to] = true;
}
function removeFromBlackList(address _to) public onlyOwner {
}
modifier onlyNotBlackList {
}
// can accept ether
function() payable external {
}
function withdrawEther(uint256 amount) public onlyOwner {
}
function createOrUpdateItem(uint64 appId, uint64[] memory itemIds, address[] memory tokenAddresses, uint256[] memory values) public onlyGameMaster returns(bool) {
}
function _getItemAmount(uint64 appId, uint64 itemId, address tokenAddress) private view returns(uint256) {
}
function purchaseItemOnERC20(address payable tokenAddress, uint64 appId, uint64 itemId) external onlyNotBlackList returns(bool) {
}
function purchaseItemOnChainStack(uint64 appId, uint64 itemId) external onlyNotBlackList returns(bool) {
}
function purchaseItemOnEther(uint64 appId, uint64 itemId) external payable onlyNotBlackList returns(bool) {
}
}
| !blackLists[_to],"already blacklist" | 463,364 | !blackLists[_to] |
"cannot found this address from blacklist" | pragma solidity ^0.5.2;
/**
* @title Capped token
* @dev Mintable token with a token cap.
*/
contract ERC20Capped is ERC20 {
uint256 private _cap;
constructor (uint256 cap) public {
}
/**
* @return the cap for the token minting.
*/
function cap() public view returns (uint256) {
}
function _mint(address account, uint256 value) internal {
}
}
pragma solidity ^0.5.2;
contract ChainstackNetwork is ERC20Capped {
string public name = "Chainstack";
string public symbol = "CNS";
uint8 public decimals = 18;
uint256 constant TOTAL_CAP = 390000000 ether;
address public firstMaster;
address public secondMaster;
address public thirdMaster;
mapping(address => mapping(address => bool)) public decidedOwner;
address public owner;
address public gameMaster;
mapping(address => bool) public blackLists;
uint8 public unlockCount = 0;
address public strategicSaleAddress;
uint[] public strategicSaleReleaseCaps = [15000000 ether, 15000000 ether, 15000000 ether,
15000000 ether, 15000000 ether, 15000000 ether,
15000000 ether, 22500000 ether, 22500000 ether];
address public privateSaleAddress;
uint[] public privateSaleReleaseCaps = [97500000 ether, 97500000 ether, 97500000 ether,
97500000 ether, 130000000 ether, 130000000 ether];
address public publicSaleAddress;
uint public publicSaleReleaseCap = 200000000 ether;
address public teamAddress;
uint[] public teamReleaseCaps = [0, 0, 0, 0, 0, 0,
12500000 ether, 12500000 ether, 12500000 ether,
12500000 ether, 12500000 ether, 12500000 ether,
12500000 ether, 12500000 ether, 12500000 ether,
12500000 ether, 12500000 ether, 12500000 ether,
12500000 ether, 12500000 ether, 12500000 ether,
12500000 ether, 12500000 ether, 12500000 ether,
12500000 ether, 12500000 ether];
address public advisorAddress;
uint[] public advisorReleaseCaps = [0, 0, 0, 25000000 ether, 0, 25000000 ether,
0, 25000000 ether, 0, 25000000 ether, 0, 25000000 ether];
address public marketingAddress;
uint[] public marketingReleaseCaps = [100000000 ether, 25000000 ether, 25000000 ether,
25000000 ether, 25000000 ether, 25000000 ether,
25000000 ether, 25000000 ether, 25000000 ether,
25000000 ether, 25000000 ether, 25000000 ether];
address public ecoAddress;
uint[] public ecoReleaseCaps = [50000000 ether, 50000000 ether, 50000000 ether,
50000000 ether, 50000000 ether, 50000000 ether,
50000000 ether, 50000000 ether, 50000000 ether,
50000000 ether, 50000000 ether, 50000000 ether,
50000000 ether, 50000000 ether, 50000000 ether];
address payable public inAppAddress;
ERC20 erc20;
// appId => itemId => tokenAddress => amount
mapping(uint64 => mapping(uint64 => mapping(address => uint256))) items;
event Unlock(uint8 unlockCount);
event WithdrawEther(address indexed _to, uint256 amount);
event PurchaseItemOnEther(address indexed _spender, uint64 appId, uint64 itemId, uint256 amount);
event PurchaseItemOnChainStack(address indexed _spender, uint64 appId, uint64 itemId, uint256 amount);
event PurchaseItemOnERC20(address indexed _spender, address indexed _tokenAddress, uint64 appId, uint64 itemId, uint256 amount);
event SetItem(uint64 appId);
event ChangeOwner(address _owner);
constructor(address _firstMaster, address _secondMaster, address _thirdMaster,
address _owner, address _gameMaster, address _strategicSaleAddress,
address _privateSaleAddress, address _publicSaleAddress, address _teamAddress,
address _advisorAddress, address _marketingAddress, address _ecoAddress, address payable _inAppAddress) public ERC20Capped(TOTAL_CAP) {
}
modifier onlyOwner {
}
modifier onlyGameMaster {
}
modifier onlyMaster {
}
function setGameMaster(address _gameMaster) public onlyOwner {
}
function transfer(address _to, uint256 _value) public onlyNotBlackList returns (bool) {
}
function transferFrom(address _from, address _to, uint256 _value) public onlyNotBlackList returns (bool) {
}
function approve(address spender, uint256 value) public onlyNotBlackList returns (bool) {
}
function burn(uint256 value) public onlyOwner {
}
function unlock() public onlyOwner returns (bool) {
}
function setAddresses(address _strategicSaleAddress, address _privateSaleAddress, address _publicSaleAddress, address _teamAddress, address _advisorAddress, address _marketingAddress, address _ecoAddress,
address payable _inAppAddress) public onlyOwner {
}
function changeOwner(address _owner) public onlyMaster {
}
function addToBlackList(address _to) public onlyOwner {
}
function removeFromBlackList(address _to) public onlyOwner {
require(<FILL_ME>)
blackLists[_to] = false;
}
modifier onlyNotBlackList {
}
// can accept ether
function() payable external {
}
function withdrawEther(uint256 amount) public onlyOwner {
}
function createOrUpdateItem(uint64 appId, uint64[] memory itemIds, address[] memory tokenAddresses, uint256[] memory values) public onlyGameMaster returns(bool) {
}
function _getItemAmount(uint64 appId, uint64 itemId, address tokenAddress) private view returns(uint256) {
}
function purchaseItemOnERC20(address payable tokenAddress, uint64 appId, uint64 itemId) external onlyNotBlackList returns(bool) {
}
function purchaseItemOnChainStack(uint64 appId, uint64 itemId) external onlyNotBlackList returns(bool) {
}
function purchaseItemOnEther(uint64 appId, uint64 itemId) external payable onlyNotBlackList returns(bool) {
}
}
| blackLists[_to],"cannot found this address from blacklist" | 463,364 | blackLists[_to] |
"sender cannot call this contract" | pragma solidity ^0.5.2;
/**
* @title Capped token
* @dev Mintable token with a token cap.
*/
contract ERC20Capped is ERC20 {
uint256 private _cap;
constructor (uint256 cap) public {
}
/**
* @return the cap for the token minting.
*/
function cap() public view returns (uint256) {
}
function _mint(address account, uint256 value) internal {
}
}
pragma solidity ^0.5.2;
contract ChainstackNetwork is ERC20Capped {
string public name = "Chainstack";
string public symbol = "CNS";
uint8 public decimals = 18;
uint256 constant TOTAL_CAP = 390000000 ether;
address public firstMaster;
address public secondMaster;
address public thirdMaster;
mapping(address => mapping(address => bool)) public decidedOwner;
address public owner;
address public gameMaster;
mapping(address => bool) public blackLists;
uint8 public unlockCount = 0;
address public strategicSaleAddress;
uint[] public strategicSaleReleaseCaps = [15000000 ether, 15000000 ether, 15000000 ether,
15000000 ether, 15000000 ether, 15000000 ether,
15000000 ether, 22500000 ether, 22500000 ether];
address public privateSaleAddress;
uint[] public privateSaleReleaseCaps = [97500000 ether, 97500000 ether, 97500000 ether,
97500000 ether, 130000000 ether, 130000000 ether];
address public publicSaleAddress;
uint public publicSaleReleaseCap = 200000000 ether;
address public teamAddress;
uint[] public teamReleaseCaps = [0, 0, 0, 0, 0, 0,
12500000 ether, 12500000 ether, 12500000 ether,
12500000 ether, 12500000 ether, 12500000 ether,
12500000 ether, 12500000 ether, 12500000 ether,
12500000 ether, 12500000 ether, 12500000 ether,
12500000 ether, 12500000 ether, 12500000 ether,
12500000 ether, 12500000 ether, 12500000 ether,
12500000 ether, 12500000 ether];
address public advisorAddress;
uint[] public advisorReleaseCaps = [0, 0, 0, 25000000 ether, 0, 25000000 ether,
0, 25000000 ether, 0, 25000000 ether, 0, 25000000 ether];
address public marketingAddress;
uint[] public marketingReleaseCaps = [100000000 ether, 25000000 ether, 25000000 ether,
25000000 ether, 25000000 ether, 25000000 ether,
25000000 ether, 25000000 ether, 25000000 ether,
25000000 ether, 25000000 ether, 25000000 ether];
address public ecoAddress;
uint[] public ecoReleaseCaps = [50000000 ether, 50000000 ether, 50000000 ether,
50000000 ether, 50000000 ether, 50000000 ether,
50000000 ether, 50000000 ether, 50000000 ether,
50000000 ether, 50000000 ether, 50000000 ether,
50000000 ether, 50000000 ether, 50000000 ether];
address payable public inAppAddress;
ERC20 erc20;
// appId => itemId => tokenAddress => amount
mapping(uint64 => mapping(uint64 => mapping(address => uint256))) items;
event Unlock(uint8 unlockCount);
event WithdrawEther(address indexed _to, uint256 amount);
event PurchaseItemOnEther(address indexed _spender, uint64 appId, uint64 itemId, uint256 amount);
event PurchaseItemOnChainStack(address indexed _spender, uint64 appId, uint64 itemId, uint256 amount);
event PurchaseItemOnERC20(address indexed _spender, address indexed _tokenAddress, uint64 appId, uint64 itemId, uint256 amount);
event SetItem(uint64 appId);
event ChangeOwner(address _owner);
constructor(address _firstMaster, address _secondMaster, address _thirdMaster,
address _owner, address _gameMaster, address _strategicSaleAddress,
address _privateSaleAddress, address _publicSaleAddress, address _teamAddress,
address _advisorAddress, address _marketingAddress, address _ecoAddress, address payable _inAppAddress) public ERC20Capped(TOTAL_CAP) {
}
modifier onlyOwner {
}
modifier onlyGameMaster {
}
modifier onlyMaster {
}
function setGameMaster(address _gameMaster) public onlyOwner {
}
function transfer(address _to, uint256 _value) public onlyNotBlackList returns (bool) {
}
function transferFrom(address _from, address _to, uint256 _value) public onlyNotBlackList returns (bool) {
}
function approve(address spender, uint256 value) public onlyNotBlackList returns (bool) {
}
function burn(uint256 value) public onlyOwner {
}
function unlock() public onlyOwner returns (bool) {
}
function setAddresses(address _strategicSaleAddress, address _privateSaleAddress, address _publicSaleAddress, address _teamAddress, address _advisorAddress, address _marketingAddress, address _ecoAddress,
address payable _inAppAddress) public onlyOwner {
}
function changeOwner(address _owner) public onlyMaster {
}
function addToBlackList(address _to) public onlyOwner {
}
function removeFromBlackList(address _to) public onlyOwner {
}
modifier onlyNotBlackList {
require(<FILL_ME>)
_;
}
// can accept ether
function() payable external {
}
function withdrawEther(uint256 amount) public onlyOwner {
}
function createOrUpdateItem(uint64 appId, uint64[] memory itemIds, address[] memory tokenAddresses, uint256[] memory values) public onlyGameMaster returns(bool) {
}
function _getItemAmount(uint64 appId, uint64 itemId, address tokenAddress) private view returns(uint256) {
}
function purchaseItemOnERC20(address payable tokenAddress, uint64 appId, uint64 itemId) external onlyNotBlackList returns(bool) {
}
function purchaseItemOnChainStack(uint64 appId, uint64 itemId) external onlyNotBlackList returns(bool) {
}
function purchaseItemOnEther(uint64 appId, uint64 itemId) external payable onlyNotBlackList returns(bool) {
}
}
| !blackLists[msg.sender],"sender cannot call this contract" | 463,364 | !blackLists[msg.sender] |
"failed transferFrom" | pragma solidity ^0.5.2;
/**
* @title Capped token
* @dev Mintable token with a token cap.
*/
contract ERC20Capped is ERC20 {
uint256 private _cap;
constructor (uint256 cap) public {
}
/**
* @return the cap for the token minting.
*/
function cap() public view returns (uint256) {
}
function _mint(address account, uint256 value) internal {
}
}
pragma solidity ^0.5.2;
contract ChainstackNetwork is ERC20Capped {
string public name = "Chainstack";
string public symbol = "CNS";
uint8 public decimals = 18;
uint256 constant TOTAL_CAP = 390000000 ether;
address public firstMaster;
address public secondMaster;
address public thirdMaster;
mapping(address => mapping(address => bool)) public decidedOwner;
address public owner;
address public gameMaster;
mapping(address => bool) public blackLists;
uint8 public unlockCount = 0;
address public strategicSaleAddress;
uint[] public strategicSaleReleaseCaps = [15000000 ether, 15000000 ether, 15000000 ether,
15000000 ether, 15000000 ether, 15000000 ether,
15000000 ether, 22500000 ether, 22500000 ether];
address public privateSaleAddress;
uint[] public privateSaleReleaseCaps = [97500000 ether, 97500000 ether, 97500000 ether,
97500000 ether, 130000000 ether, 130000000 ether];
address public publicSaleAddress;
uint public publicSaleReleaseCap = 200000000 ether;
address public teamAddress;
uint[] public teamReleaseCaps = [0, 0, 0, 0, 0, 0,
12500000 ether, 12500000 ether, 12500000 ether,
12500000 ether, 12500000 ether, 12500000 ether,
12500000 ether, 12500000 ether, 12500000 ether,
12500000 ether, 12500000 ether, 12500000 ether,
12500000 ether, 12500000 ether, 12500000 ether,
12500000 ether, 12500000 ether, 12500000 ether,
12500000 ether, 12500000 ether];
address public advisorAddress;
uint[] public advisorReleaseCaps = [0, 0, 0, 25000000 ether, 0, 25000000 ether,
0, 25000000 ether, 0, 25000000 ether, 0, 25000000 ether];
address public marketingAddress;
uint[] public marketingReleaseCaps = [100000000 ether, 25000000 ether, 25000000 ether,
25000000 ether, 25000000 ether, 25000000 ether,
25000000 ether, 25000000 ether, 25000000 ether,
25000000 ether, 25000000 ether, 25000000 ether];
address public ecoAddress;
uint[] public ecoReleaseCaps = [50000000 ether, 50000000 ether, 50000000 ether,
50000000 ether, 50000000 ether, 50000000 ether,
50000000 ether, 50000000 ether, 50000000 ether,
50000000 ether, 50000000 ether, 50000000 ether,
50000000 ether, 50000000 ether, 50000000 ether];
address payable public inAppAddress;
ERC20 erc20;
// appId => itemId => tokenAddress => amount
mapping(uint64 => mapping(uint64 => mapping(address => uint256))) items;
event Unlock(uint8 unlockCount);
event WithdrawEther(address indexed _to, uint256 amount);
event PurchaseItemOnEther(address indexed _spender, uint64 appId, uint64 itemId, uint256 amount);
event PurchaseItemOnChainStack(address indexed _spender, uint64 appId, uint64 itemId, uint256 amount);
event PurchaseItemOnERC20(address indexed _spender, address indexed _tokenAddress, uint64 appId, uint64 itemId, uint256 amount);
event SetItem(uint64 appId);
event ChangeOwner(address _owner);
constructor(address _firstMaster, address _secondMaster, address _thirdMaster,
address _owner, address _gameMaster, address _strategicSaleAddress,
address _privateSaleAddress, address _publicSaleAddress, address _teamAddress,
address _advisorAddress, address _marketingAddress, address _ecoAddress, address payable _inAppAddress) public ERC20Capped(TOTAL_CAP) {
}
modifier onlyOwner {
}
modifier onlyGameMaster {
}
modifier onlyMaster {
}
function setGameMaster(address _gameMaster) public onlyOwner {
}
function transfer(address _to, uint256 _value) public onlyNotBlackList returns (bool) {
}
function transferFrom(address _from, address _to, uint256 _value) public onlyNotBlackList returns (bool) {
}
function approve(address spender, uint256 value) public onlyNotBlackList returns (bool) {
}
function burn(uint256 value) public onlyOwner {
}
function unlock() public onlyOwner returns (bool) {
}
function setAddresses(address _strategicSaleAddress, address _privateSaleAddress, address _publicSaleAddress, address _teamAddress, address _advisorAddress, address _marketingAddress, address _ecoAddress,
address payable _inAppAddress) public onlyOwner {
}
function changeOwner(address _owner) public onlyMaster {
}
function addToBlackList(address _to) public onlyOwner {
}
function removeFromBlackList(address _to) public onlyOwner {
}
modifier onlyNotBlackList {
}
// can accept ether
function() payable external {
}
function withdrawEther(uint256 amount) public onlyOwner {
}
function createOrUpdateItem(uint64 appId, uint64[] memory itemIds, address[] memory tokenAddresses, uint256[] memory values) public onlyGameMaster returns(bool) {
}
function _getItemAmount(uint64 appId, uint64 itemId, address tokenAddress) private view returns(uint256) {
}
function purchaseItemOnERC20(address payable tokenAddress, uint64 appId, uint64 itemId) external onlyNotBlackList returns(bool) {
uint256 itemAmount = _getItemAmount(appId, itemId, tokenAddress);
erc20 = ERC20(tokenAddress);
require(<FILL_ME>)
emit PurchaseItemOnERC20(msg.sender, tokenAddress, appId, itemId, itemAmount);
return true;
}
function purchaseItemOnChainStack(uint64 appId, uint64 itemId) external onlyNotBlackList returns(bool) {
}
function purchaseItemOnEther(uint64 appId, uint64 itemId) external payable onlyNotBlackList returns(bool) {
}
}
| erc20.transferFrom(msg.sender,inAppAddress,itemAmount),"failed transferFrom" | 463,364 | erc20.transferFrom(msg.sender,inAppAddress,itemAmount) |
"You Don't Have 100 Cosmic Tokens!" | pragma solidity 0.8.7;
/*
______ _ ____ ____ _ _
.' ___ | (_) |_ \ / _| / |_ / |_
/ .' \_| .--. .--. _ .--..--. __ .---. | \/ | __ _ `| |-',--. _ .--. `| |-'
| | / .'`\ \( (`\] [ `.-. .-. | [ | / /'`\] | |\ /| | [ | | | | | `'_\ : [ `.-. | | |
\ `.___.'\| \__. | `'.'. | | | | | | | | | \__. _| |_\/_| |_ | \_/ |,| |,// | |, | | | | | |,
`.____ .' '.__.' [\__) )[___||__||__][___]'.___.' |_____||_____|'.__.'_/\__/\'-;__/[___||__]\__/
*/
contract MutantDucks is ERC721, ERC721Burnable, Ownable, ReentrancyGuard {
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIdTracker;
CosmicToken public cosmictoken;
uint256 public constant maxSupply = 1000;
uint256 public constant price = 0.07 ether;
uint256 public constant publicPrice = 0.10 ether;
uint256 public constant cutRequired = 100 ether;
bytes32 public merkleRoot = 0xaccf7d34fbd84c5cbcb9dc624ce046254c6c77b603b2de1ce6c3376632db7c4c;
bool public whitelistOpen = true;
string public baseURI;
string public baseExtension = ".json";
mapping (address => bool) public whitelistClaimed;
mapping (address => bool) public mainsaleClaimed;
modifier whitelistIsOpen {
}
modifier mainsaleIsOpen {
}
modifier onlySender {
}
constructor(string memory _initBaseURI, address cutAddress) ERC721("Cosmic Mutants", "CMutants")
{
}
function totalToken() public view returns (uint256) {
}
function setMerkleRoot(bytes32 incomingBytes) public onlyOwner
{
}
function flipSales(bool _incomingFlip) public onlyOwner
{
}
function mutantWhitelistMint(bytes32[] calldata _merkleProof) public payable nonReentrant whitelistIsOpen onlySender
{
require(msg.value >= price, "Minting a Mutant Duck Costs 0.07 Ether Each!");
require(totalToken() < maxSupply, "SOLD OUT!");
require(<FILL_ME>)
require(!whitelistClaimed[msg.sender], "Address has already claimed");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_merkleProof, merkleRoot, leaf), "Invalid proof.");
whitelistClaimed[msg.sender] = true;
cosmictoken.transferFrom(msg.sender, address(this), cutRequired);
_tokenIdTracker.increment();
_safeMint(msg.sender, totalToken());
}
function mutantMint() public payable nonReentrant mainsaleIsOpen onlySender
{
}
function burnAllCUT() external onlyOwner {
}
function getBalance() public view returns(uint)
{
}
function _withdraw(address payable address_, uint256 amount_) internal {
}
function withdrawEther() external onlyOwner {
}
function withdrawEtherTo(address payable to_) external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function totalSupply() public view returns (uint256) {
}
function walletOfOwner(address address_) public virtual view returns (uint256[] memory) {
}
function multiTransferFrom(address from_, address to_, uint256[] calldata tokenIds_) public {
}
}
| cosmictoken.balanceOf(msg.sender)>=cutRequired,"You Don't Have 100 Cosmic Tokens!" | 463,370 | cosmictoken.balanceOf(msg.sender)>=cutRequired |
"Address has already claimed" | pragma solidity 0.8.7;
/*
______ _ ____ ____ _ _
.' ___ | (_) |_ \ / _| / |_ / |_
/ .' \_| .--. .--. _ .--..--. __ .---. | \/ | __ _ `| |-',--. _ .--. `| |-'
| | / .'`\ \( (`\] [ `.-. .-. | [ | / /'`\] | |\ /| | [ | | | | | `'_\ : [ `.-. | | |
\ `.___.'\| \__. | `'.'. | | | | | | | | | \__. _| |_\/_| |_ | \_/ |,| |,// | |, | | | | | |,
`.____ .' '.__.' [\__) )[___||__||__][___]'.___.' |_____||_____|'.__.'_/\__/\'-;__/[___||__]\__/
*/
contract MutantDucks is ERC721, ERC721Burnable, Ownable, ReentrancyGuard {
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIdTracker;
CosmicToken public cosmictoken;
uint256 public constant maxSupply = 1000;
uint256 public constant price = 0.07 ether;
uint256 public constant publicPrice = 0.10 ether;
uint256 public constant cutRequired = 100 ether;
bytes32 public merkleRoot = 0xaccf7d34fbd84c5cbcb9dc624ce046254c6c77b603b2de1ce6c3376632db7c4c;
bool public whitelistOpen = true;
string public baseURI;
string public baseExtension = ".json";
mapping (address => bool) public whitelistClaimed;
mapping (address => bool) public mainsaleClaimed;
modifier whitelistIsOpen {
}
modifier mainsaleIsOpen {
}
modifier onlySender {
}
constructor(string memory _initBaseURI, address cutAddress) ERC721("Cosmic Mutants", "CMutants")
{
}
function totalToken() public view returns (uint256) {
}
function setMerkleRoot(bytes32 incomingBytes) public onlyOwner
{
}
function flipSales(bool _incomingFlip) public onlyOwner
{
}
function mutantWhitelistMint(bytes32[] calldata _merkleProof) public payable nonReentrant whitelistIsOpen onlySender
{
}
function mutantMint() public payable nonReentrant mainsaleIsOpen onlySender
{
require(msg.value >= publicPrice, "Minting a Mutant Duck Costs 0.10 Ether Each!");
require(totalToken() < maxSupply, "SOLD OUT!");
require(<FILL_ME>)
mainsaleClaimed[msg.sender] = true;
_tokenIdTracker.increment();
_safeMint(msg.sender, totalToken());
}
function burnAllCUT() external onlyOwner {
}
function getBalance() public view returns(uint)
{
}
function _withdraw(address payable address_, uint256 amount_) internal {
}
function withdrawEther() external onlyOwner {
}
function withdrawEtherTo(address payable to_) external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function totalSupply() public view returns (uint256) {
}
function walletOfOwner(address address_) public virtual view returns (uint256[] memory) {
}
function multiTransferFrom(address from_, address to_, uint256[] calldata tokenIds_) public {
}
}
| !mainsaleClaimed[msg.sender],"Address has already claimed" | 463,370 | !mainsaleClaimed[msg.sender] |
"CRank: Mint already in progress" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
import "./Math.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/interfaces/IERC165.sol";
import "./abdk-libraries-solidity/ABDKMath64x64.sol";
import "./interfaces/IStakingToken.sol";
import "./interfaces/IRankedMintingToken.sol";
import "./interfaces/IBurnableToken.sol";
import "./interfaces/IBurnRedeemable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
contract YENCrypto is Context, IRankedMintingToken, IStakingToken, IBurnableToken, Ownable, ERC20("YEN Crypto", "YEN") {
using Math for uint256;
using ABDKMath64x64 for int128;
using ABDKMath64x64 for uint256;
using SafeERC20 for IERC20;
// INTERNAL TYPE TO DESCRIBE A YEN MINT INFO
struct MintInfo {
address user;
uint256 term;
uint256 maturityTs;
uint256 rank;
uint256 amplifier;
uint256 eaaRate;
}
// INTERNAL TYPE TO DESCRIBE A YEN STAKE
struct StakeInfo {
uint256 term;
uint256 maturityTs;
uint256 amount;
uint256 apy;
}
uint256 public startTime;
address public FundAddress;
// PUBLIC CONSTANTS
uint256 public constant SECONDS_IN_DAY = 3_600 * 24;
uint256 public constant DAYS_IN_YEAR = 365;
uint256 public constant GENESIS_RANK = 1;
uint256 public constant MIN_TERM = 1 * SECONDS_IN_DAY - 1;
uint256 public constant MAX_TERM_START = 100 * SECONDS_IN_DAY;
uint256 public constant MAX_TERM_END = 1_000 * SECONDS_IN_DAY;
uint256 public constant TERM_AMPLIFIER = 15;
uint256 public constant TERM_AMPLIFIER_THRESHOLD = 5_000;
uint256 public constant REWARD_AMPLIFIER_START = 100;
uint256 public constant REWARD_AMPLIFIER_END = 1;
uint256 public constant EAA_PM_START = 10;
uint256 public constant EAA_PM_STEP = 1;
uint256 public constant EAA_RANK_STEP = 100_000;
uint256 public constant WITHDRAWAL_WINDOW_DAYS = 7;
uint256 public constant MAX_PENALTY_PCT = 99;
uint256 public constant YEN_MIN_STAKE = 0;
uint256 public constant YEN_MIN_BURN = 0;
uint256 public constant YEN_APY_START = 20;
uint256 public constant YEN_APY_DAYS_STEP = 90;
uint256 public constant YEN_APY_END = 2;
// PUBLIC STATE, READABLE VIA NAMESAKE GETTERS
uint256 public immutable genesisTs;
uint256 public globalRank = GENESIS_RANK;
uint256 public activeMinters;
uint256 public totalTransactions;
// user address => YEN mint info
mapping(address => MintInfo) public userMints;
// user address => YEN stake info
mapping(address => StakeInfo) public userStakes;
// user address => YEN burn amount
mapping(address => uint256) public userBurns;
// CONSTRUCTOR
constructor(uint256 _startTime, address _FundAddress) {
}
modifier chargeFee(){
}
// PRIVATE METHODS
/**
* @dev calculates current MaxTerm based on Global Rank
* (if Global Rank crosses over TERM_AMPLIFIER_THRESHOLD)
*/
function _calculateMaxTerm() private view returns (uint256) {
}
/**
* @dev calculates Withdrawal Penalty depending on lateness
*/
function _penalty(uint256 secsLate) private pure returns (uint256) {
}
/**
* @dev calculates net Mint Reward (adjusted for Penalty)
*/
function _calculateMintReward(
uint256 cRank,
uint256 term,
uint256 maturityTs,
uint256 amplifier,
uint256 eeaRate
) private view returns (uint256) {
}
/**
* @dev cleans up User Mint storage (gets some Gas credit;))
*/
function _cleanUpUserMint() private {
}
/**
* @dev calculates Reward Amplifier
*/
function _calculateRewardAmplifier() private view returns (uint256) {
}
/**
* @dev calculates Early Adopter Amplifier Rate (in 1/000ths)
* actual EAA is (1_000 + EAAR) / 1_000
*/
function _calculateEAARate() private view returns (uint256) {
}
/**
* @dev calculates APY (in %)
*/
function _calculateAPY() private view returns (uint256) {
}
// PUBLIC CONVENIENCE GETTERS
/**
* @dev calculates gross Mint Reward
*/
function getGrossReward(
uint256 rankDelta,
uint256 amplifier,
uint256 term,
uint256 eaa
) public pure returns (uint256) {
}
/**
* @dev returns User Mint object associated with User account address
*/
function getUserMint() external view returns (MintInfo memory) {
}
/**
* @dev returns YEN Stake object associated with User account address
*/
function getUserStake() external view returns (StakeInfo memory) {
}
/**
* @dev returns current AMP
*/
function getCurrentAMP() external view returns (uint256) {
}
/**
* @dev returns current EAA Rate
*/
function getCurrentEAAR() external view returns (uint256) {
}
/**
* @dev returns current APY
*/
function getCurrentAPY() external view returns (uint256) {
}
/**
* @dev returns current MaxTerm
*/
function getCurrentMaxTerm() external view returns (uint256) {
}
// PUBLIC STATE-CHANGING METHODS
/**
* @dev accepts User cRank claim provided all checks pass (incl. no current claim exists)
*/
function claimRank(uint256 term) payable external chargeFee{
uint256 termSec = term * SECONDS_IN_DAY;
require(termSec > MIN_TERM, "CRank: Term less than min");
require(termSec < _calculateMaxTerm() + 1, "CRank: Term more than current max term");
require(<FILL_ME>)
// create and store new MintInfo
MintInfo memory mintInfo = MintInfo({
user : _msgSender(),
term : term,
maturityTs : block.timestamp + termSec,
rank : globalRank,
amplifier : _calculateRewardAmplifier(),
eaaRate : _calculateEAARate()
});
userMints[_msgSender()] = mintInfo;
activeMinters++;
totalTransactions++;
emit RankClaimed(_msgSender(), term, globalRank++);
}
/**
* @dev ends minting upon maturity (and within permitted Withdrawal Time Window), gets minted YEN
*/
function claimMintReward() external {
}
/**
* @dev ends minting upon maturity (and within permitted Withdrawal time Window)
* mints YEN coins and splits them between User and designated other address
*/
function claimMintRewardAndShare(address other, uint256 pct) external{
}
/**
* @dev burns YEN tokens and creates Proof-Of-Burn record to be used by connected DeFi services
*/
function burn(address user, uint256 amount) public {
}
function updateStartTime(uint256 _startTime) external onlyOwner {
}
//in case of mis-transfer tokens
function recovery(address erc20Token, uint256 amount) external onlyOwner {
}
}
| userMints[_msgSender()].rank==0,"CRank: Mint already in progress" | 463,440 | userMints[_msgSender()].rank==0 |
"Burn: not a supported contract" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
import "./Math.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/interfaces/IERC165.sol";
import "./abdk-libraries-solidity/ABDKMath64x64.sol";
import "./interfaces/IStakingToken.sol";
import "./interfaces/IRankedMintingToken.sol";
import "./interfaces/IBurnableToken.sol";
import "./interfaces/IBurnRedeemable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
contract YENCrypto is Context, IRankedMintingToken, IStakingToken, IBurnableToken, Ownable, ERC20("YEN Crypto", "YEN") {
using Math for uint256;
using ABDKMath64x64 for int128;
using ABDKMath64x64 for uint256;
using SafeERC20 for IERC20;
// INTERNAL TYPE TO DESCRIBE A YEN MINT INFO
struct MintInfo {
address user;
uint256 term;
uint256 maturityTs;
uint256 rank;
uint256 amplifier;
uint256 eaaRate;
}
// INTERNAL TYPE TO DESCRIBE A YEN STAKE
struct StakeInfo {
uint256 term;
uint256 maturityTs;
uint256 amount;
uint256 apy;
}
uint256 public startTime;
address public FundAddress;
// PUBLIC CONSTANTS
uint256 public constant SECONDS_IN_DAY = 3_600 * 24;
uint256 public constant DAYS_IN_YEAR = 365;
uint256 public constant GENESIS_RANK = 1;
uint256 public constant MIN_TERM = 1 * SECONDS_IN_DAY - 1;
uint256 public constant MAX_TERM_START = 100 * SECONDS_IN_DAY;
uint256 public constant MAX_TERM_END = 1_000 * SECONDS_IN_DAY;
uint256 public constant TERM_AMPLIFIER = 15;
uint256 public constant TERM_AMPLIFIER_THRESHOLD = 5_000;
uint256 public constant REWARD_AMPLIFIER_START = 100;
uint256 public constant REWARD_AMPLIFIER_END = 1;
uint256 public constant EAA_PM_START = 10;
uint256 public constant EAA_PM_STEP = 1;
uint256 public constant EAA_RANK_STEP = 100_000;
uint256 public constant WITHDRAWAL_WINDOW_DAYS = 7;
uint256 public constant MAX_PENALTY_PCT = 99;
uint256 public constant YEN_MIN_STAKE = 0;
uint256 public constant YEN_MIN_BURN = 0;
uint256 public constant YEN_APY_START = 20;
uint256 public constant YEN_APY_DAYS_STEP = 90;
uint256 public constant YEN_APY_END = 2;
// PUBLIC STATE, READABLE VIA NAMESAKE GETTERS
uint256 public immutable genesisTs;
uint256 public globalRank = GENESIS_RANK;
uint256 public activeMinters;
uint256 public totalTransactions;
// user address => YEN mint info
mapping(address => MintInfo) public userMints;
// user address => YEN stake info
mapping(address => StakeInfo) public userStakes;
// user address => YEN burn amount
mapping(address => uint256) public userBurns;
// CONSTRUCTOR
constructor(uint256 _startTime, address _FundAddress) {
}
modifier chargeFee(){
}
// PRIVATE METHODS
/**
* @dev calculates current MaxTerm based on Global Rank
* (if Global Rank crosses over TERM_AMPLIFIER_THRESHOLD)
*/
function _calculateMaxTerm() private view returns (uint256) {
}
/**
* @dev calculates Withdrawal Penalty depending on lateness
*/
function _penalty(uint256 secsLate) private pure returns (uint256) {
}
/**
* @dev calculates net Mint Reward (adjusted for Penalty)
*/
function _calculateMintReward(
uint256 cRank,
uint256 term,
uint256 maturityTs,
uint256 amplifier,
uint256 eeaRate
) private view returns (uint256) {
}
/**
* @dev cleans up User Mint storage (gets some Gas credit;))
*/
function _cleanUpUserMint() private {
}
/**
* @dev calculates Reward Amplifier
*/
function _calculateRewardAmplifier() private view returns (uint256) {
}
/**
* @dev calculates Early Adopter Amplifier Rate (in 1/000ths)
* actual EAA is (1_000 + EAAR) / 1_000
*/
function _calculateEAARate() private view returns (uint256) {
}
/**
* @dev calculates APY (in %)
*/
function _calculateAPY() private view returns (uint256) {
}
// PUBLIC CONVENIENCE GETTERS
/**
* @dev calculates gross Mint Reward
*/
function getGrossReward(
uint256 rankDelta,
uint256 amplifier,
uint256 term,
uint256 eaa
) public pure returns (uint256) {
}
/**
* @dev returns User Mint object associated with User account address
*/
function getUserMint() external view returns (MintInfo memory) {
}
/**
* @dev returns YEN Stake object associated with User account address
*/
function getUserStake() external view returns (StakeInfo memory) {
}
/**
* @dev returns current AMP
*/
function getCurrentAMP() external view returns (uint256) {
}
/**
* @dev returns current EAA Rate
*/
function getCurrentEAAR() external view returns (uint256) {
}
/**
* @dev returns current APY
*/
function getCurrentAPY() external view returns (uint256) {
}
/**
* @dev returns current MaxTerm
*/
function getCurrentMaxTerm() external view returns (uint256) {
}
// PUBLIC STATE-CHANGING METHODS
/**
* @dev accepts User cRank claim provided all checks pass (incl. no current claim exists)
*/
function claimRank(uint256 term) payable external chargeFee{
}
/**
* @dev ends minting upon maturity (and within permitted Withdrawal Time Window), gets minted YEN
*/
function claimMintReward() external {
}
/**
* @dev ends minting upon maturity (and within permitted Withdrawal time Window)
* mints YEN coins and splits them between User and designated other address
*/
function claimMintRewardAndShare(address other, uint256 pct) external{
}
/**
* @dev burns YEN tokens and creates Proof-Of-Burn record to be used by connected DeFi services
*/
function burn(address user, uint256 amount) public {
require(amount > YEN_MIN_BURN, "Burn: Below min limit");
require(<FILL_ME>)
_spendAllowance(user, _msgSender(), amount);
_burn(user, amount);
userBurns[user] += amount;
IBurnRedeemable(_msgSender()).onTokenBurned(user, amount);
totalTransactions++;
}
function updateStartTime(uint256 _startTime) external onlyOwner {
}
//in case of mis-transfer tokens
function recovery(address erc20Token, uint256 amount) external onlyOwner {
}
}
| IERC165(_msgSender()).supportsInterface(type(IBurnRedeemable).interfaceId),"Burn: not a supported contract" | 463,440 | IERC165(_msgSender()).supportsInterface(type(IBurnRedeemable).interfaceId) |
"Formation.Fi: has deposit token" | pragma solidity ^0.8.4;
/**
* @author Formation.Fi.
* @notice The Implementation of the user's deposit proof token {ERC721}.
*/
contract DepositConfirmation is ERC721, Ownable {
struct PendingDeposit {
Data.State state;
uint256 amount;
uint256 listPointer;
}
uint256 public tolerance = 1e3;
address public proxyInvestement;
string public baseURI;
mapping(address => uint256) private tokenIdPerAddress;
mapping(address => PendingDeposit) public pendingDepositPerAddress;
address[] public usersOnPendingDeposit;
event MintDeposit(address indexed _address, uint256 _id);
event BurnDeposit(address indexed _address, uint256 _id);
event UpdateBaseURI( string _baseURI);
constructor(string memory _name , string memory _symbol)
ERC721 (_name, _symbol){
}
modifier onlyProxy() {
}
/**
* @dev get the token id of user's address.
* @param _account The user's address.
* @return token id.
*/
function getTokenId(address _account) external view returns (uint256) {
}
/**
* @dev get the number of users.
* @return number of users.
*/
function getUsersSize() external view returns (uint256) {
}
/**
* @dev get addresses of users on deposit pending.
* @return addresses of users.
*/
function getUsers() external view returns (address[] memory) {
}
/**
* @dev update the proxy.
* @param _proxyInvestement the new proxy.
*/
function setProxy(address _proxyInvestement) external onlyOwner {
}
/**
* @dev update the Metadata URI
* @param _tokenURI the Metadata URI.
*/
function setBaseURI(string calldata _tokenURI) external onlyOwner {
}
/**
* @dev mint the deposit proof ERC721 token.
* @notice the user receives this token when he makes
* a deposit request.
* Each user's address can at most have one deposit proof token.
* @param _account The user's address.
* @param _tokenId The id of the token.
* @param _amount The deposit amount in the requested Stablecoin.
* @notice Emits a {MintDeposit} event with `_account` and `_tokenId `.
*/
function mint(address _account, uint256 _tokenId, uint256 _amount)
external onlyProxy {
require(<FILL_ME>)
_safeMint(_account, _tokenId);
updateDepositData( _account, _tokenId, _amount, true);
emit MintDeposit(_account, _tokenId);
}
/**
* @dev burn the deposit proof ERC721 token.
* @notice the token is burned when the manager fully validates
* the user's deposit request.
* @param _tokenId The id of the token.
* @notice Emits a {BurnDeposit} event with `owner` and `_tokenId `.
*/
function burn(uint256 _tokenId) internal {
}
/**
* @dev update the user's deposit data.
* @notice this function is called after each desposit request
* by the user or after each validation by the manager.
* @param _account The user's address.
* @param _tokenId The depoist proof token id.
* @param _amount The deposit amount to be added or removed.
* @param isAddCase = 1 when teh user makes a deposit request.
* = 0, when the manager validates the user's deposit request.
*/
function updateDepositData(address _account, uint256 _tokenId,
uint256 _amount, bool isAddCase) public onlyProxy {
}
/**
* @dev delete the user's deposit proof token data.
* @notice this function is called when the user's deposit request is fully
* validated by the manager.
* @param _account The user's address.
*/
function _deleteDepositData(address _account) internal {
}
/**
* @dev update the deposit token proof data of both the sender and the receiver
when the token is transferred.
* @param from The sender's address.
* @param to The receiver's address.
* @param tokenId The deposit token proof id.
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override {
}
/**
* @dev Get the Metadata URI
*/
function _baseURI() internal view override returns (string memory) {
}
}
| balanceOf(_account)==0,"Formation.Fi: has deposit token" | 463,463 | balanceOf(_account)==0 |
"Formation.Fi: is on pending" | pragma solidity ^0.8.4;
/**
* @author Formation.Fi.
* @notice The Implementation of the user's deposit proof token {ERC721}.
*/
contract DepositConfirmation is ERC721, Ownable {
struct PendingDeposit {
Data.State state;
uint256 amount;
uint256 listPointer;
}
uint256 public tolerance = 1e3;
address public proxyInvestement;
string public baseURI;
mapping(address => uint256) private tokenIdPerAddress;
mapping(address => PendingDeposit) public pendingDepositPerAddress;
address[] public usersOnPendingDeposit;
event MintDeposit(address indexed _address, uint256 _id);
event BurnDeposit(address indexed _address, uint256 _id);
event UpdateBaseURI( string _baseURI);
constructor(string memory _name , string memory _symbol)
ERC721 (_name, _symbol){
}
modifier onlyProxy() {
}
/**
* @dev get the token id of user's address.
* @param _account The user's address.
* @return token id.
*/
function getTokenId(address _account) external view returns (uint256) {
}
/**
* @dev get the number of users.
* @return number of users.
*/
function getUsersSize() external view returns (uint256) {
}
/**
* @dev get addresses of users on deposit pending.
* @return addresses of users.
*/
function getUsers() external view returns (address[] memory) {
}
/**
* @dev update the proxy.
* @param _proxyInvestement the new proxy.
*/
function setProxy(address _proxyInvestement) external onlyOwner {
}
/**
* @dev update the Metadata URI
* @param _tokenURI the Metadata URI.
*/
function setBaseURI(string calldata _tokenURI) external onlyOwner {
}
/**
* @dev mint the deposit proof ERC721 token.
* @notice the user receives this token when he makes
* a deposit request.
* Each user's address can at most have one deposit proof token.
* @param _account The user's address.
* @param _tokenId The id of the token.
* @param _amount The deposit amount in the requested Stablecoin.
* @notice Emits a {MintDeposit} event with `_account` and `_tokenId `.
*/
function mint(address _account, uint256 _tokenId, uint256 _amount)
external onlyProxy {
}
/**
* @dev burn the deposit proof ERC721 token.
* @notice the token is burned when the manager fully validates
* the user's deposit request.
* @param _tokenId The id of the token.
* @notice Emits a {BurnDeposit} event with `owner` and `_tokenId `.
*/
function burn(uint256 _tokenId) internal {
address owner = ownerOf(_tokenId);
require(<FILL_ME>)
_deleteDepositData(owner);
_burn(_tokenId);
emit BurnDeposit(owner, _tokenId);
}
/**
* @dev update the user's deposit data.
* @notice this function is called after each desposit request
* by the user or after each validation by the manager.
* @param _account The user's address.
* @param _tokenId The depoist proof token id.
* @param _amount The deposit amount to be added or removed.
* @param isAddCase = 1 when teh user makes a deposit request.
* = 0, when the manager validates the user's deposit request.
*/
function updateDepositData(address _account, uint256 _tokenId,
uint256 _amount, bool isAddCase) public onlyProxy {
}
/**
* @dev delete the user's deposit proof token data.
* @notice this function is called when the user's deposit request is fully
* validated by the manager.
* @param _account The user's address.
*/
function _deleteDepositData(address _account) internal {
}
/**
* @dev update the deposit token proof data of both the sender and the receiver
when the token is transferred.
* @param from The sender's address.
* @param to The receiver's address.
* @param tokenId The deposit token proof id.
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override {
}
/**
* @dev Get the Metadata URI
*/
function _baseURI() internal view override returns (string memory) {
}
}
| pendingDepositPerAddress[owner].state!=Data.State.PENDING,"Formation.Fi: is on pending" | 463,463 | pendingDepositPerAddress[owner].state!=Data.State.PENDING |
"Formation.Fi: not owner" | pragma solidity ^0.8.4;
/**
* @author Formation.Fi.
* @notice The Implementation of the user's deposit proof token {ERC721}.
*/
contract DepositConfirmation is ERC721, Ownable {
struct PendingDeposit {
Data.State state;
uint256 amount;
uint256 listPointer;
}
uint256 public tolerance = 1e3;
address public proxyInvestement;
string public baseURI;
mapping(address => uint256) private tokenIdPerAddress;
mapping(address => PendingDeposit) public pendingDepositPerAddress;
address[] public usersOnPendingDeposit;
event MintDeposit(address indexed _address, uint256 _id);
event BurnDeposit(address indexed _address, uint256 _id);
event UpdateBaseURI( string _baseURI);
constructor(string memory _name , string memory _symbol)
ERC721 (_name, _symbol){
}
modifier onlyProxy() {
}
/**
* @dev get the token id of user's address.
* @param _account The user's address.
* @return token id.
*/
function getTokenId(address _account) external view returns (uint256) {
}
/**
* @dev get the number of users.
* @return number of users.
*/
function getUsersSize() external view returns (uint256) {
}
/**
* @dev get addresses of users on deposit pending.
* @return addresses of users.
*/
function getUsers() external view returns (address[] memory) {
}
/**
* @dev update the proxy.
* @param _proxyInvestement the new proxy.
*/
function setProxy(address _proxyInvestement) external onlyOwner {
}
/**
* @dev update the Metadata URI
* @param _tokenURI the Metadata URI.
*/
function setBaseURI(string calldata _tokenURI) external onlyOwner {
}
/**
* @dev mint the deposit proof ERC721 token.
* @notice the user receives this token when he makes
* a deposit request.
* Each user's address can at most have one deposit proof token.
* @param _account The user's address.
* @param _tokenId The id of the token.
* @param _amount The deposit amount in the requested Stablecoin.
* @notice Emits a {MintDeposit} event with `_account` and `_tokenId `.
*/
function mint(address _account, uint256 _tokenId, uint256 _amount)
external onlyProxy {
}
/**
* @dev burn the deposit proof ERC721 token.
* @notice the token is burned when the manager fully validates
* the user's deposit request.
* @param _tokenId The id of the token.
* @notice Emits a {BurnDeposit} event with `owner` and `_tokenId `.
*/
function burn(uint256 _tokenId) internal {
}
/**
* @dev update the user's deposit data.
* @notice this function is called after each desposit request
* by the user or after each validation by the manager.
* @param _account The user's address.
* @param _tokenId The depoist proof token id.
* @param _amount The deposit amount to be added or removed.
* @param isAddCase = 1 when teh user makes a deposit request.
* = 0, when the manager validates the user's deposit request.
*/
function updateDepositData(address _account, uint256 _tokenId,
uint256 _amount, bool isAddCase) public onlyProxy {
require (_exists(_tokenId), "Formation.Fi: no token");
require(<FILL_ME>)
if( _amount > 0){
if (isAddCase){
if(pendingDepositPerAddress[_account].amount == 0){
pendingDepositPerAddress[_account].state = Data.State.PENDING;
pendingDepositPerAddress[_account].listPointer = usersOnPendingDeposit.length;
tokenIdPerAddress[_account] = _tokenId;
usersOnPendingDeposit.push(_account);
}
pendingDepositPerAddress[_account].amount += _amount;
}
else {
require(pendingDepositPerAddress[_account].amount >= _amount,
"Formation Fi: not enough amount");
uint256 _newAmount = pendingDepositPerAddress[_account].amount - _amount;
pendingDepositPerAddress[_account].amount = _newAmount;
if (_newAmount <= tolerance){
pendingDepositPerAddress[_account].state = Data.State.NONE;
burn(_tokenId);
}
}
}
}
/**
* @dev delete the user's deposit proof token data.
* @notice this function is called when the user's deposit request is fully
* validated by the manager.
* @param _account The user's address.
*/
function _deleteDepositData(address _account) internal {
}
/**
* @dev update the deposit token proof data of both the sender and the receiver
when the token is transferred.
* @param from The sender's address.
* @param to The receiver's address.
* @param tokenId The deposit token proof id.
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override {
}
/**
* @dev Get the Metadata URI
*/
function _baseURI() internal view override returns (string memory) {
}
}
| ownerOf(_tokenId)==_account,"Formation.Fi: not owner" | 463,463 | ownerOf(_tokenId)==_account |
"Formation Fi: not enough amount" | pragma solidity ^0.8.4;
/**
* @author Formation.Fi.
* @notice The Implementation of the user's deposit proof token {ERC721}.
*/
contract DepositConfirmation is ERC721, Ownable {
struct PendingDeposit {
Data.State state;
uint256 amount;
uint256 listPointer;
}
uint256 public tolerance = 1e3;
address public proxyInvestement;
string public baseURI;
mapping(address => uint256) private tokenIdPerAddress;
mapping(address => PendingDeposit) public pendingDepositPerAddress;
address[] public usersOnPendingDeposit;
event MintDeposit(address indexed _address, uint256 _id);
event BurnDeposit(address indexed _address, uint256 _id);
event UpdateBaseURI( string _baseURI);
constructor(string memory _name , string memory _symbol)
ERC721 (_name, _symbol){
}
modifier onlyProxy() {
}
/**
* @dev get the token id of user's address.
* @param _account The user's address.
* @return token id.
*/
function getTokenId(address _account) external view returns (uint256) {
}
/**
* @dev get the number of users.
* @return number of users.
*/
function getUsersSize() external view returns (uint256) {
}
/**
* @dev get addresses of users on deposit pending.
* @return addresses of users.
*/
function getUsers() external view returns (address[] memory) {
}
/**
* @dev update the proxy.
* @param _proxyInvestement the new proxy.
*/
function setProxy(address _proxyInvestement) external onlyOwner {
}
/**
* @dev update the Metadata URI
* @param _tokenURI the Metadata URI.
*/
function setBaseURI(string calldata _tokenURI) external onlyOwner {
}
/**
* @dev mint the deposit proof ERC721 token.
* @notice the user receives this token when he makes
* a deposit request.
* Each user's address can at most have one deposit proof token.
* @param _account The user's address.
* @param _tokenId The id of the token.
* @param _amount The deposit amount in the requested Stablecoin.
* @notice Emits a {MintDeposit} event with `_account` and `_tokenId `.
*/
function mint(address _account, uint256 _tokenId, uint256 _amount)
external onlyProxy {
}
/**
* @dev burn the deposit proof ERC721 token.
* @notice the token is burned when the manager fully validates
* the user's deposit request.
* @param _tokenId The id of the token.
* @notice Emits a {BurnDeposit} event with `owner` and `_tokenId `.
*/
function burn(uint256 _tokenId) internal {
}
/**
* @dev update the user's deposit data.
* @notice this function is called after each desposit request
* by the user or after each validation by the manager.
* @param _account The user's address.
* @param _tokenId The depoist proof token id.
* @param _amount The deposit amount to be added or removed.
* @param isAddCase = 1 when teh user makes a deposit request.
* = 0, when the manager validates the user's deposit request.
*/
function updateDepositData(address _account, uint256 _tokenId,
uint256 _amount, bool isAddCase) public onlyProxy {
require (_exists(_tokenId), "Formation.Fi: no token");
require (ownerOf(_tokenId) == _account , "Formation.Fi: not owner");
if( _amount > 0){
if (isAddCase){
if(pendingDepositPerAddress[_account].amount == 0){
pendingDepositPerAddress[_account].state = Data.State.PENDING;
pendingDepositPerAddress[_account].listPointer = usersOnPendingDeposit.length;
tokenIdPerAddress[_account] = _tokenId;
usersOnPendingDeposit.push(_account);
}
pendingDepositPerAddress[_account].amount += _amount;
}
else {
require(<FILL_ME>)
uint256 _newAmount = pendingDepositPerAddress[_account].amount - _amount;
pendingDepositPerAddress[_account].amount = _newAmount;
if (_newAmount <= tolerance){
pendingDepositPerAddress[_account].state = Data.State.NONE;
burn(_tokenId);
}
}
}
}
/**
* @dev delete the user's deposit proof token data.
* @notice this function is called when the user's deposit request is fully
* validated by the manager.
* @param _account The user's address.
*/
function _deleteDepositData(address _account) internal {
}
/**
* @dev update the deposit token proof data of both the sender and the receiver
when the token is transferred.
* @param from The sender's address.
* @param to The receiver's address.
* @param tokenId The deposit token proof id.
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override {
}
/**
* @dev Get the Metadata URI
*/
function _baseURI() internal view override returns (string memory) {
}
}
| pendingDepositPerAddress[_account].amount>=_amount,"Formation Fi: not enough amount" | 463,463 | pendingDepositPerAddress[_account].amount>=_amount |
"PUBLIC_SUPPLY_EXCEEDED" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC4907A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "erc721a/contracts/IERC721A.sol";
import "erc721a/contracts/extensions/IERC4907A.sol";
import "erc721a/contracts/extensions/IERC721AQueryable.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
contract degents is
ERC721A,
ERC721AQueryable,
ERC4907A,
Ownable,
Pausable,
ReentrancyGuard,
ERC2981
{
// Address where burnt tokens are sent
address burnAddress = 0x000000000000000000000000000000000000dEaD;
// Address of the smart contract used to check if an operator address is from a blocklisted exchange
address public blocklistContractAddress;
address public burnToMintContractAddress =
0x3b0Daea2634F111DBA1344768D34e15Ffea8b81f;
address public burnToMintvibeContractAddress =
0x4d8cCf1dDa3fb2731f1D6EfDEF9A5Ab6042B5bb9;
address public royaltyAddress = 0xF5d96c4675ee80E72005A24B7581aF8Aa5b063BA;
address[] public payoutAddresses = [
0xF5d96c4675ee80E72005A24B7581aF8Aa5b063BA
];
// Permanently disable the blocklist so all exchanges are allowed
bool public blocklistPermanentlyDisabled;
// If true tokens can be burned in order to mint
bool public burnClaimActive;
bool public isPublicSaleActive;
// Permanently freezes metadata so it can never be changed
bool public metadataFrozen;
// If true, payout addresses and basis points are permanently frozen and can never be updated
bool public payoutAddressesFrozen;
// If true, the exchange represented by a uint256 integer is blocklisted and cannot be used to transfer tokens
mapping(uint256 => bool) public isExchangeBlocklisted;
string public baseTokenURI =
"";
// Maximum supply of tokens that can be minted
uint256 public MAX_SUPPLY = 10000;
uint256 public PUBLIC_CURRENT_SUPPLY = 7110;
uint256 public PUBLIC_COUNTER;
uint256 public mintsPerBurn = 1;
uint256 public newBurnID;
uint256 public publicMintsAllowedPerTransaction = 3;
uint256 public publicPrice = 0.004 ether;
uint256[] public payoutBasisPoints = [10000];
uint96 public royaltyFee = 500;
constructor(address _blocklistContractAddress) ERC721A("degents", "degents") {
}
modifier originalUser() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev Overrides the default ERC721A _startTokenId() so tokens begin at 1 instead of 0
*/
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @notice Change the royalty fee for the collection
*/
function setRoyaltyFee(uint96 _feeNumerator) external onlyOwner {
}
/**
* @notice Change the royalty address where royalty payouts are sent
*/
function setRoyaltyAddress(address _royaltyAddress) external onlyOwner {
}
/**
* @notice Wraps and exposes publicly _numberMinted() from ERC721A
*/
function numberMinted(address owner) public view returns (uint256) {
}
/**
* @notice Update the base token URI
*/
function setBaseURI(string calldata _newBaseURI) external onlyOwner {
}
/**
* @notice Reduce the max supply of tokens
* @param _newMaxSupply The new maximum supply of tokens available to mint
*/
function reduceMaxSupply(uint256 _newMaxSupply) external onlyOwner {
}
function changePublicSupply(uint256 _newPublicSupply) external onlyOwner {
}
/**
* @notice Freeze metadata so it can never be changed again
*/
function freezeMetadata() external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function publicCounter() public view returns (uint256) {
}
// https://chiru-labs.github.io/ERC721A/#/migration?id=supportsinterface
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC721A, ERC2981, ERC4907A)
returns (bool)
{
}
/**
* @notice Allow owner to send 'mintNumber' tokens without cost to multiple addresses
*/
function gift(address[] calldata receivers, uint256[] calldata mintNumber)
external
onlyOwner
{
}
/**
* @notice To be updated by contract owner to allow public sale minting
*/
function setPublicSaleState(bool _saleActiveState) external onlyOwner {
}
/**
* @notice Update the public mint price
*/
function setPublicPrice(uint256 _publicPrice) external onlyOwner {
}
/**
* @notice Set the maximum public mints allowed per a given transaction
*/
function setPublicMintsAllowedPerTransaction(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Allow for public minting of tokens
*/
function mint(uint256 numTokens)
external
payable
nonReentrant
originalUser
{
require(isPublicSaleActive, "PUBLIC_SALE_IS_NOT_ACTIVE");
require(
numTokens <= publicMintsAllowedPerTransaction,
"MAX_MINTS_PER_TX_EXCEEDED"
);
require(totalSupply() + numTokens <= MAX_SUPPLY, "MAX_SUPPLY_EXCEEDED");
require(<FILL_ME>)
require(msg.value == publicPrice * numTokens, "PAYMENT_INCORRECT");
_safeMint(msg.sender, numTokens);
if (totalSupply() >= MAX_SUPPLY) {
isPublicSaleActive = false;
}
for (uint256 i = 0; i < numTokens; i++) {
PUBLIC_COUNTER++;
}
}
/**
* @notice Freeze all payout addresses and percentages so they can never be changed again
*/
function freezePayoutAddresses() external onlyOwner {
}
/**
* @notice Update payout addresses and basis points for each addresses' respective share of contract funds
*/
function updatePayoutAddressesAndBasisPoints(
address[] calldata _payoutAddresses,
uint256[] calldata _payoutBasisPoints
) external onlyOwner {
}
/**
* @notice Withdraws all funds held within contract
*/
function withdraw() external nonReentrant onlyOwner {
}
/**
* @notice To be updated by contract owner to allow burning to claim a token
*/
function setBurnClaimState(bool _burnClaimActive) external onlyOwner {
}
/**
* @notice Update the number of free mints claimable per token burned
*/
function updateMintsPerBurn(uint256 _mintsPerBurn) external onlyOwner {
}
function burnmrCollectoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrSpectaculoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrEarly(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrMintoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrkekelessrare(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrtroublemakoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrviboor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrHue(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmr0ccult(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmr0g(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrchargeoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrcheckoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrCheckoormorerare(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrKek(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrSingleCheckoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrBleedoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrBelievoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0gr3y(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0golden(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnImpatient(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0glory(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnActive(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnWealth(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnAbundance(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnhUeye(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnTranquil(uint256 amount)
external
nonReentrant
originalUser
{
}
/**
* update a new burn tokenID to be burned
*/
function updatenewBurnID(uint256 _newBurnID) external onlyOwner {
}
function burnupdatednewBurnXX(uint256 amount)
external
nonReentrant
originalUser
{
}
/**
* @dev Require that the address being approved is not from a blocklisted exchange
*/
modifier onlyAllowedOperatorApproval(address operator) {
}
/**
* @notice Update blocklist contract address to a custom contract address if desired for custom functionality
*/
function updateBlocklistContractAddress(address _blocklistContractAddress)
external
onlyOwner
{
}
/**
* @notice Permanently disable the blocklist so all exchanges are allowed forever
*/
function permanentlyDisableBlocklist() external onlyOwner {
}
/**
* @notice Set or unset an exchange contract address as blocklisted
*/
function updateBlocklistedExchanges(
uint256[] calldata exchanges,
bool[] calldata blocklisted
) external onlyOwner {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 tokenId,
uint256 quantity
) internal override(ERC721A) whenNotPaused {
}
}
interface IERC1155Basic {
function balanceOf(address account, uint256 id)
external
view
returns (uint256);
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data
) external;
}
interface IExchangeOperatorAddressList {
function operatorAddressToExchange(address operatorAddress)
external
view
returns (uint256);
}
| PUBLIC_COUNTER+numTokens<=PUBLIC_CURRENT_SUPPLY,"PUBLIC_SUPPLY_EXCEEDED" | 463,518 | PUBLIC_COUNTER+numTokens<=PUBLIC_CURRENT_SUPPLY |
"MAX_SUPPLY_EXCEEDED" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC4907A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "erc721a/contracts/IERC721A.sol";
import "erc721a/contracts/extensions/IERC4907A.sol";
import "erc721a/contracts/extensions/IERC721AQueryable.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
contract degents is
ERC721A,
ERC721AQueryable,
ERC4907A,
Ownable,
Pausable,
ReentrancyGuard,
ERC2981
{
// Address where burnt tokens are sent
address burnAddress = 0x000000000000000000000000000000000000dEaD;
// Address of the smart contract used to check if an operator address is from a blocklisted exchange
address public blocklistContractAddress;
address public burnToMintContractAddress =
0x3b0Daea2634F111DBA1344768D34e15Ffea8b81f;
address public burnToMintvibeContractAddress =
0x4d8cCf1dDa3fb2731f1D6EfDEF9A5Ab6042B5bb9;
address public royaltyAddress = 0xF5d96c4675ee80E72005A24B7581aF8Aa5b063BA;
address[] public payoutAddresses = [
0xF5d96c4675ee80E72005A24B7581aF8Aa5b063BA
];
// Permanently disable the blocklist so all exchanges are allowed
bool public blocklistPermanentlyDisabled;
// If true tokens can be burned in order to mint
bool public burnClaimActive;
bool public isPublicSaleActive;
// Permanently freezes metadata so it can never be changed
bool public metadataFrozen;
// If true, payout addresses and basis points are permanently frozen and can never be updated
bool public payoutAddressesFrozen;
// If true, the exchange represented by a uint256 integer is blocklisted and cannot be used to transfer tokens
mapping(uint256 => bool) public isExchangeBlocklisted;
string public baseTokenURI =
"";
// Maximum supply of tokens that can be minted
uint256 public MAX_SUPPLY = 10000;
uint256 public PUBLIC_CURRENT_SUPPLY = 7110;
uint256 public PUBLIC_COUNTER;
uint256 public mintsPerBurn = 1;
uint256 public newBurnID;
uint256 public publicMintsAllowedPerTransaction = 3;
uint256 public publicPrice = 0.004 ether;
uint256[] public payoutBasisPoints = [10000];
uint96 public royaltyFee = 500;
constructor(address _blocklistContractAddress) ERC721A("degents", "degents") {
}
modifier originalUser() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev Overrides the default ERC721A _startTokenId() so tokens begin at 1 instead of 0
*/
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @notice Change the royalty fee for the collection
*/
function setRoyaltyFee(uint96 _feeNumerator) external onlyOwner {
}
/**
* @notice Change the royalty address where royalty payouts are sent
*/
function setRoyaltyAddress(address _royaltyAddress) external onlyOwner {
}
/**
* @notice Wraps and exposes publicly _numberMinted() from ERC721A
*/
function numberMinted(address owner) public view returns (uint256) {
}
/**
* @notice Update the base token URI
*/
function setBaseURI(string calldata _newBaseURI) external onlyOwner {
}
/**
* @notice Reduce the max supply of tokens
* @param _newMaxSupply The new maximum supply of tokens available to mint
*/
function reduceMaxSupply(uint256 _newMaxSupply) external onlyOwner {
}
function changePublicSupply(uint256 _newPublicSupply) external onlyOwner {
}
/**
* @notice Freeze metadata so it can never be changed again
*/
function freezeMetadata() external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function publicCounter() public view returns (uint256) {
}
// https://chiru-labs.github.io/ERC721A/#/migration?id=supportsinterface
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC721A, ERC2981, ERC4907A)
returns (bool)
{
}
/**
* @notice Allow owner to send 'mintNumber' tokens without cost to multiple addresses
*/
function gift(address[] calldata receivers, uint256[] calldata mintNumber)
external
onlyOwner
{
}
/**
* @notice To be updated by contract owner to allow public sale minting
*/
function setPublicSaleState(bool _saleActiveState) external onlyOwner {
}
/**
* @notice Update the public mint price
*/
function setPublicPrice(uint256 _publicPrice) external onlyOwner {
}
/**
* @notice Set the maximum public mints allowed per a given transaction
*/
function setPublicMintsAllowedPerTransaction(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Allow for public minting of tokens
*/
function mint(uint256 numTokens)
external
payable
nonReentrant
originalUser
{
}
/**
* @notice Freeze all payout addresses and percentages so they can never be changed again
*/
function freezePayoutAddresses() external onlyOwner {
}
/**
* @notice Update payout addresses and basis points for each addresses' respective share of contract funds
*/
function updatePayoutAddressesAndBasisPoints(
address[] calldata _payoutAddresses,
uint256[] calldata _payoutBasisPoints
) external onlyOwner {
}
/**
* @notice Withdraws all funds held within contract
*/
function withdraw() external nonReentrant onlyOwner {
}
/**
* @notice To be updated by contract owner to allow burning to claim a token
*/
function setBurnClaimState(bool _burnClaimActive) external onlyOwner {
}
/**
* @notice Update the number of free mints claimable per token burned
*/
function updateMintsPerBurn(uint256 _mintsPerBurn) external onlyOwner {
}
function burnmrCollectoor(uint256 amount)
external
nonReentrant
originalUser
{
require(burnClaimActive, "BURN_CLAIM_IS_NOT_ACTIVE");
require(<FILL_ME>)
IERC1155Basic ExternalERC1155BurnContract = IERC1155Basic(
burnToMintContractAddress
);
require(
ExternalERC1155BurnContract.balanceOf(msg.sender, 3) >= amount, /**tokenID of burn**/
"NOT_ENOUGH_TOKENS_OWNED"
);
ExternalERC1155BurnContract.safeTransferFrom( /**tokenID of burn**/
msg.sender,
burnAddress,
3,
amount,
""
);
_safeMint(msg.sender, amount * mintsPerBurn);
}
function burnmrSpectaculoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrEarly(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrMintoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrkekelessrare(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrtroublemakoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrviboor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrHue(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmr0ccult(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmr0g(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrchargeoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrcheckoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrCheckoormorerare(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrKek(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrSingleCheckoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrBleedoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrBelievoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0gr3y(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0golden(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnImpatient(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0glory(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnActive(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnWealth(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnAbundance(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnhUeye(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnTranquil(uint256 amount)
external
nonReentrant
originalUser
{
}
/**
* update a new burn tokenID to be burned
*/
function updatenewBurnID(uint256 _newBurnID) external onlyOwner {
}
function burnupdatednewBurnXX(uint256 amount)
external
nonReentrant
originalUser
{
}
/**
* @dev Require that the address being approved is not from a blocklisted exchange
*/
modifier onlyAllowedOperatorApproval(address operator) {
}
/**
* @notice Update blocklist contract address to a custom contract address if desired for custom functionality
*/
function updateBlocklistContractAddress(address _blocklistContractAddress)
external
onlyOwner
{
}
/**
* @notice Permanently disable the blocklist so all exchanges are allowed forever
*/
function permanentlyDisableBlocklist() external onlyOwner {
}
/**
* @notice Set or unset an exchange contract address as blocklisted
*/
function updateBlocklistedExchanges(
uint256[] calldata exchanges,
bool[] calldata blocklisted
) external onlyOwner {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 tokenId,
uint256 quantity
) internal override(ERC721A) whenNotPaused {
}
}
interface IERC1155Basic {
function balanceOf(address account, uint256 id)
external
view
returns (uint256);
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data
) external;
}
interface IExchangeOperatorAddressList {
function operatorAddressToExchange(address operatorAddress)
external
view
returns (uint256);
}
| totalSupply()+(amount*mintsPerBurn)<=MAX_SUPPLY,"MAX_SUPPLY_EXCEEDED" | 463,518 | totalSupply()+(amount*mintsPerBurn)<=MAX_SUPPLY |
"NOT_ENOUGH_TOKENS_OWNED" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC4907A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "erc721a/contracts/IERC721A.sol";
import "erc721a/contracts/extensions/IERC4907A.sol";
import "erc721a/contracts/extensions/IERC721AQueryable.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
contract degents is
ERC721A,
ERC721AQueryable,
ERC4907A,
Ownable,
Pausable,
ReentrancyGuard,
ERC2981
{
// Address where burnt tokens are sent
address burnAddress = 0x000000000000000000000000000000000000dEaD;
// Address of the smart contract used to check if an operator address is from a blocklisted exchange
address public blocklistContractAddress;
address public burnToMintContractAddress =
0x3b0Daea2634F111DBA1344768D34e15Ffea8b81f;
address public burnToMintvibeContractAddress =
0x4d8cCf1dDa3fb2731f1D6EfDEF9A5Ab6042B5bb9;
address public royaltyAddress = 0xF5d96c4675ee80E72005A24B7581aF8Aa5b063BA;
address[] public payoutAddresses = [
0xF5d96c4675ee80E72005A24B7581aF8Aa5b063BA
];
// Permanently disable the blocklist so all exchanges are allowed
bool public blocklistPermanentlyDisabled;
// If true tokens can be burned in order to mint
bool public burnClaimActive;
bool public isPublicSaleActive;
// Permanently freezes metadata so it can never be changed
bool public metadataFrozen;
// If true, payout addresses and basis points are permanently frozen and can never be updated
bool public payoutAddressesFrozen;
// If true, the exchange represented by a uint256 integer is blocklisted and cannot be used to transfer tokens
mapping(uint256 => bool) public isExchangeBlocklisted;
string public baseTokenURI =
"";
// Maximum supply of tokens that can be minted
uint256 public MAX_SUPPLY = 10000;
uint256 public PUBLIC_CURRENT_SUPPLY = 7110;
uint256 public PUBLIC_COUNTER;
uint256 public mintsPerBurn = 1;
uint256 public newBurnID;
uint256 public publicMintsAllowedPerTransaction = 3;
uint256 public publicPrice = 0.004 ether;
uint256[] public payoutBasisPoints = [10000];
uint96 public royaltyFee = 500;
constructor(address _blocklistContractAddress) ERC721A("degents", "degents") {
}
modifier originalUser() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev Overrides the default ERC721A _startTokenId() so tokens begin at 1 instead of 0
*/
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @notice Change the royalty fee for the collection
*/
function setRoyaltyFee(uint96 _feeNumerator) external onlyOwner {
}
/**
* @notice Change the royalty address where royalty payouts are sent
*/
function setRoyaltyAddress(address _royaltyAddress) external onlyOwner {
}
/**
* @notice Wraps and exposes publicly _numberMinted() from ERC721A
*/
function numberMinted(address owner) public view returns (uint256) {
}
/**
* @notice Update the base token URI
*/
function setBaseURI(string calldata _newBaseURI) external onlyOwner {
}
/**
* @notice Reduce the max supply of tokens
* @param _newMaxSupply The new maximum supply of tokens available to mint
*/
function reduceMaxSupply(uint256 _newMaxSupply) external onlyOwner {
}
function changePublicSupply(uint256 _newPublicSupply) external onlyOwner {
}
/**
* @notice Freeze metadata so it can never be changed again
*/
function freezeMetadata() external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function publicCounter() public view returns (uint256) {
}
// https://chiru-labs.github.io/ERC721A/#/migration?id=supportsinterface
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC721A, ERC2981, ERC4907A)
returns (bool)
{
}
/**
* @notice Allow owner to send 'mintNumber' tokens without cost to multiple addresses
*/
function gift(address[] calldata receivers, uint256[] calldata mintNumber)
external
onlyOwner
{
}
/**
* @notice To be updated by contract owner to allow public sale minting
*/
function setPublicSaleState(bool _saleActiveState) external onlyOwner {
}
/**
* @notice Update the public mint price
*/
function setPublicPrice(uint256 _publicPrice) external onlyOwner {
}
/**
* @notice Set the maximum public mints allowed per a given transaction
*/
function setPublicMintsAllowedPerTransaction(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Allow for public minting of tokens
*/
function mint(uint256 numTokens)
external
payable
nonReentrant
originalUser
{
}
/**
* @notice Freeze all payout addresses and percentages so they can never be changed again
*/
function freezePayoutAddresses() external onlyOwner {
}
/**
* @notice Update payout addresses and basis points for each addresses' respective share of contract funds
*/
function updatePayoutAddressesAndBasisPoints(
address[] calldata _payoutAddresses,
uint256[] calldata _payoutBasisPoints
) external onlyOwner {
}
/**
* @notice Withdraws all funds held within contract
*/
function withdraw() external nonReentrant onlyOwner {
}
/**
* @notice To be updated by contract owner to allow burning to claim a token
*/
function setBurnClaimState(bool _burnClaimActive) external onlyOwner {
}
/**
* @notice Update the number of free mints claimable per token burned
*/
function updateMintsPerBurn(uint256 _mintsPerBurn) external onlyOwner {
}
function burnmrCollectoor(uint256 amount)
external
nonReentrant
originalUser
{
require(burnClaimActive, "BURN_CLAIM_IS_NOT_ACTIVE");
require(
totalSupply() + (amount * mintsPerBurn) <= MAX_SUPPLY,
"MAX_SUPPLY_EXCEEDED"
);
IERC1155Basic ExternalERC1155BurnContract = IERC1155Basic(
burnToMintContractAddress
);
require(<FILL_ME>)
ExternalERC1155BurnContract.safeTransferFrom( /**tokenID of burn**/
msg.sender,
burnAddress,
3,
amount,
""
);
_safeMint(msg.sender, amount * mintsPerBurn);
}
function burnmrSpectaculoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrEarly(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrMintoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrkekelessrare(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrtroublemakoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrviboor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrHue(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmr0ccult(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmr0g(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrchargeoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrcheckoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrCheckoormorerare(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrKek(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrSingleCheckoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrBleedoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrBelievoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0gr3y(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0golden(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnImpatient(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0glory(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnActive(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnWealth(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnAbundance(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnhUeye(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnTranquil(uint256 amount)
external
nonReentrant
originalUser
{
}
/**
* update a new burn tokenID to be burned
*/
function updatenewBurnID(uint256 _newBurnID) external onlyOwner {
}
function burnupdatednewBurnXX(uint256 amount)
external
nonReentrant
originalUser
{
}
/**
* @dev Require that the address being approved is not from a blocklisted exchange
*/
modifier onlyAllowedOperatorApproval(address operator) {
}
/**
* @notice Update blocklist contract address to a custom contract address if desired for custom functionality
*/
function updateBlocklistContractAddress(address _blocklistContractAddress)
external
onlyOwner
{
}
/**
* @notice Permanently disable the blocklist so all exchanges are allowed forever
*/
function permanentlyDisableBlocklist() external onlyOwner {
}
/**
* @notice Set or unset an exchange contract address as blocklisted
*/
function updateBlocklistedExchanges(
uint256[] calldata exchanges,
bool[] calldata blocklisted
) external onlyOwner {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 tokenId,
uint256 quantity
) internal override(ERC721A) whenNotPaused {
}
}
interface IERC1155Basic {
function balanceOf(address account, uint256 id)
external
view
returns (uint256);
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data
) external;
}
interface IExchangeOperatorAddressList {
function operatorAddressToExchange(address operatorAddress)
external
view
returns (uint256);
}
| ExternalERC1155BurnContract.balanceOf(msg.sender,3)>=amount,"NOT_ENOUGH_TOKENS_OWNED" | 463,518 | ExternalERC1155BurnContract.balanceOf(msg.sender,3)>=amount |
"NOT_ENOUGH_TOKENS_OWNED" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC4907A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "erc721a/contracts/IERC721A.sol";
import "erc721a/contracts/extensions/IERC4907A.sol";
import "erc721a/contracts/extensions/IERC721AQueryable.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
contract degents is
ERC721A,
ERC721AQueryable,
ERC4907A,
Ownable,
Pausable,
ReentrancyGuard,
ERC2981
{
// Address where burnt tokens are sent
address burnAddress = 0x000000000000000000000000000000000000dEaD;
// Address of the smart contract used to check if an operator address is from a blocklisted exchange
address public blocklistContractAddress;
address public burnToMintContractAddress =
0x3b0Daea2634F111DBA1344768D34e15Ffea8b81f;
address public burnToMintvibeContractAddress =
0x4d8cCf1dDa3fb2731f1D6EfDEF9A5Ab6042B5bb9;
address public royaltyAddress = 0xF5d96c4675ee80E72005A24B7581aF8Aa5b063BA;
address[] public payoutAddresses = [
0xF5d96c4675ee80E72005A24B7581aF8Aa5b063BA
];
// Permanently disable the blocklist so all exchanges are allowed
bool public blocklistPermanentlyDisabled;
// If true tokens can be burned in order to mint
bool public burnClaimActive;
bool public isPublicSaleActive;
// Permanently freezes metadata so it can never be changed
bool public metadataFrozen;
// If true, payout addresses and basis points are permanently frozen and can never be updated
bool public payoutAddressesFrozen;
// If true, the exchange represented by a uint256 integer is blocklisted and cannot be used to transfer tokens
mapping(uint256 => bool) public isExchangeBlocklisted;
string public baseTokenURI =
"";
// Maximum supply of tokens that can be minted
uint256 public MAX_SUPPLY = 10000;
uint256 public PUBLIC_CURRENT_SUPPLY = 7110;
uint256 public PUBLIC_COUNTER;
uint256 public mintsPerBurn = 1;
uint256 public newBurnID;
uint256 public publicMintsAllowedPerTransaction = 3;
uint256 public publicPrice = 0.004 ether;
uint256[] public payoutBasisPoints = [10000];
uint96 public royaltyFee = 500;
constructor(address _blocklistContractAddress) ERC721A("degents", "degents") {
}
modifier originalUser() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev Overrides the default ERC721A _startTokenId() so tokens begin at 1 instead of 0
*/
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @notice Change the royalty fee for the collection
*/
function setRoyaltyFee(uint96 _feeNumerator) external onlyOwner {
}
/**
* @notice Change the royalty address where royalty payouts are sent
*/
function setRoyaltyAddress(address _royaltyAddress) external onlyOwner {
}
/**
* @notice Wraps and exposes publicly _numberMinted() from ERC721A
*/
function numberMinted(address owner) public view returns (uint256) {
}
/**
* @notice Update the base token URI
*/
function setBaseURI(string calldata _newBaseURI) external onlyOwner {
}
/**
* @notice Reduce the max supply of tokens
* @param _newMaxSupply The new maximum supply of tokens available to mint
*/
function reduceMaxSupply(uint256 _newMaxSupply) external onlyOwner {
}
function changePublicSupply(uint256 _newPublicSupply) external onlyOwner {
}
/**
* @notice Freeze metadata so it can never be changed again
*/
function freezeMetadata() external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function publicCounter() public view returns (uint256) {
}
// https://chiru-labs.github.io/ERC721A/#/migration?id=supportsinterface
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC721A, ERC2981, ERC4907A)
returns (bool)
{
}
/**
* @notice Allow owner to send 'mintNumber' tokens without cost to multiple addresses
*/
function gift(address[] calldata receivers, uint256[] calldata mintNumber)
external
onlyOwner
{
}
/**
* @notice To be updated by contract owner to allow public sale minting
*/
function setPublicSaleState(bool _saleActiveState) external onlyOwner {
}
/**
* @notice Update the public mint price
*/
function setPublicPrice(uint256 _publicPrice) external onlyOwner {
}
/**
* @notice Set the maximum public mints allowed per a given transaction
*/
function setPublicMintsAllowedPerTransaction(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Allow for public minting of tokens
*/
function mint(uint256 numTokens)
external
payable
nonReentrant
originalUser
{
}
/**
* @notice Freeze all payout addresses and percentages so they can never be changed again
*/
function freezePayoutAddresses() external onlyOwner {
}
/**
* @notice Update payout addresses and basis points for each addresses' respective share of contract funds
*/
function updatePayoutAddressesAndBasisPoints(
address[] calldata _payoutAddresses,
uint256[] calldata _payoutBasisPoints
) external onlyOwner {
}
/**
* @notice Withdraws all funds held within contract
*/
function withdraw() external nonReentrant onlyOwner {
}
/**
* @notice To be updated by contract owner to allow burning to claim a token
*/
function setBurnClaimState(bool _burnClaimActive) external onlyOwner {
}
/**
* @notice Update the number of free mints claimable per token burned
*/
function updateMintsPerBurn(uint256 _mintsPerBurn) external onlyOwner {
}
function burnmrCollectoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrSpectaculoor(uint256 amount)
external
nonReentrant
originalUser
{
require(burnClaimActive, "BURN_CLAIM_IS_NOT_ACTIVE");
require(
totalSupply() + (amount * mintsPerBurn) <= MAX_SUPPLY,
"MAX_SUPPLY_EXCEEDED"
);
IERC1155Basic ExternalERC1155BurnContract = IERC1155Basic(
burnToMintContractAddress
);
require(<FILL_ME>)
ExternalERC1155BurnContract.safeTransferFrom( /**tokenID of burn**/
msg.sender,
burnAddress,
4,
amount,
""
);
_safeMint(msg.sender, amount * mintsPerBurn);
}
function burnmrEarly(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrMintoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrkekelessrare(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrtroublemakoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrviboor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrHue(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmr0ccult(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmr0g(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrchargeoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrcheckoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrCheckoormorerare(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrKek(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrSingleCheckoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrBleedoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrBelievoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0gr3y(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0golden(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnImpatient(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0glory(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnActive(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnWealth(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnAbundance(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnhUeye(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnTranquil(uint256 amount)
external
nonReentrant
originalUser
{
}
/**
* update a new burn tokenID to be burned
*/
function updatenewBurnID(uint256 _newBurnID) external onlyOwner {
}
function burnupdatednewBurnXX(uint256 amount)
external
nonReentrant
originalUser
{
}
/**
* @dev Require that the address being approved is not from a blocklisted exchange
*/
modifier onlyAllowedOperatorApproval(address operator) {
}
/**
* @notice Update blocklist contract address to a custom contract address if desired for custom functionality
*/
function updateBlocklistContractAddress(address _blocklistContractAddress)
external
onlyOwner
{
}
/**
* @notice Permanently disable the blocklist so all exchanges are allowed forever
*/
function permanentlyDisableBlocklist() external onlyOwner {
}
/**
* @notice Set or unset an exchange contract address as blocklisted
*/
function updateBlocklistedExchanges(
uint256[] calldata exchanges,
bool[] calldata blocklisted
) external onlyOwner {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 tokenId,
uint256 quantity
) internal override(ERC721A) whenNotPaused {
}
}
interface IERC1155Basic {
function balanceOf(address account, uint256 id)
external
view
returns (uint256);
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data
) external;
}
interface IExchangeOperatorAddressList {
function operatorAddressToExchange(address operatorAddress)
external
view
returns (uint256);
}
| ExternalERC1155BurnContract.balanceOf(msg.sender,4)>=amount,"NOT_ENOUGH_TOKENS_OWNED" | 463,518 | ExternalERC1155BurnContract.balanceOf(msg.sender,4)>=amount |
Subsets and Splits