comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"MAX PER WALLET IS 5" | pragma solidity ^0.8.4;
contract LightTrails is ERC721A, ERC721AQueryable, DefaultOperatorFilterer, Owned {
uint256 public FIRST_MINT_PRICE = 0 ether;
uint256 public EXTRA_MINT_PRICE = 0 ether;
uint256 public FIRST_MINT_PRICE_PUBLIC = 0.02 ether;
uint256 public EXTRA_MINT_PRICE_PUBLIC = 0.02 ether;
uint256 constant MAX_SUPPLY_PLUS_ONE = 1001;
uint256 constant MAX_PER_WALLET_PLUS_ONE = 6;
uint256 RESERVED = 50;
string tokenBaseUri = "ipfs://QmWowjx9HKytYNg9oPg96DtjJUvfx4ivg6p6bTXS1AeGhS/";
bool public paused = true;
bool public openToPublic = false;
bytes32 public merkleRoot;
mapping(address => uint256) private _freeMintedCount;
mapping(address => uint256) private _totalMintedCount;
mapping(address => bool) private _wLMinted;
constructor(bytes32 _merkleRoot) ERC721A("LightTrails", "LTTrail") Owned(msg.sender) {
}
function checkInWhiteList(bytes32[] calldata proof, uint256 quantity) view public returns(bool) {
}
// Rename mint function to optimize gas
function mint_540(uint256 _quantity, bytes32[] calldata _proof) external payable {
unchecked {
require(!paused, "MINTING PAUSED");
bool isWhiteListed = checkInWhiteList(_proof, _quantity);
uint256 firstMintPrice;
uint256 extraMintPrice;
if(isWhiteListed && !openToPublic) {
require(!_wLMinted[msg.sender], "ALREADY MINTED");
firstMintPrice = FIRST_MINT_PRICE;
extraMintPrice = EXTRA_MINT_PRICE;
} else {
require(openToPublic, "MINTING NOT YET OPEN FOR PUBLIC");
require(<FILL_ME>)
firstMintPrice = FIRST_MINT_PRICE_PUBLIC;
extraMintPrice = EXTRA_MINT_PRICE_PUBLIC;
}
uint256 _totalSupply = totalSupply();
require(_totalSupply + _quantity + RESERVED < MAX_SUPPLY_PLUS_ONE, "MAX SUPPLY REACHED");
uint256 payForCount = _quantity;
uint256 payForFirstMint = 0;
uint256 freeMintCount = _freeMintedCount[msg.sender];
if (freeMintCount < 1) {
if (_quantity > 1) {
payForCount = _quantity - 1;
} else {
payForCount = 0;
}
payForFirstMint = 1;
if(isWhiteListed && !openToPublic) {
_freeMintedCount[msg.sender] = 0;
} else {
_freeMintedCount[msg.sender] = 1;
}
}
if(isWhiteListed && !openToPublic) {
_wLMinted[msg.sender] = true;
} else {
_totalMintedCount[msg.sender] += _quantity;
}
require(
msg.value >= (payForCount * extraMintPrice + payForFirstMint * firstMintPrice),
"INCORRECT ETH AMOUNT"
);
_mint(msg.sender, _quantity);
}
}
// Set first mint price
function setFirstMintPrice(uint256 _newPrice) public onlyOwner {
}
// Set extra mint price
function setExtraMintPrice(uint256 _newPrice) public onlyOwner {
}
// Set first mint price for public
function setFirstMintPricePublic(uint256 _newPrice) public onlyOwner {
}
// Set extra mint price for public
function setExtraMintPricePublic(uint256 _newPrice) public onlyOwner {
}
function freeMintedCount(address owner) external view returns (uint256) {
}
function totalMintedCount(address owner) external view returns (uint256) {
}
function _startTokenId() internal pure override returns (uint256) {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string calldata _newBaseUri) external onlyOwner {
}
function flipSale() external onlyOwner {
}
function flipOpenToPublic() external onlyOwner {
}
function collectReserves() external onlyOwner {
}
function withdraw() external onlyOwner {
}
function setApprovalForAll(address operator, bool approved) public override(ERC721A, IERC721A) onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public override(ERC721A, IERC721A) onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override(ERC721A, IERC721A)
onlyAllowedOperator(from)
{
}
}
| _totalMintedCount[msg.sender]+_quantity<MAX_PER_WALLET_PLUS_ONE,"MAX PER WALLET IS 5" | 261,834 | _totalMintedCount[msg.sender]+_quantity<MAX_PER_WALLET_PLUS_ONE |
"MAX SUPPLY REACHED" | pragma solidity ^0.8.4;
contract LightTrails is ERC721A, ERC721AQueryable, DefaultOperatorFilterer, Owned {
uint256 public FIRST_MINT_PRICE = 0 ether;
uint256 public EXTRA_MINT_PRICE = 0 ether;
uint256 public FIRST_MINT_PRICE_PUBLIC = 0.02 ether;
uint256 public EXTRA_MINT_PRICE_PUBLIC = 0.02 ether;
uint256 constant MAX_SUPPLY_PLUS_ONE = 1001;
uint256 constant MAX_PER_WALLET_PLUS_ONE = 6;
uint256 RESERVED = 50;
string tokenBaseUri = "ipfs://QmWowjx9HKytYNg9oPg96DtjJUvfx4ivg6p6bTXS1AeGhS/";
bool public paused = true;
bool public openToPublic = false;
bytes32 public merkleRoot;
mapping(address => uint256) private _freeMintedCount;
mapping(address => uint256) private _totalMintedCount;
mapping(address => bool) private _wLMinted;
constructor(bytes32 _merkleRoot) ERC721A("LightTrails", "LTTrail") Owned(msg.sender) {
}
function checkInWhiteList(bytes32[] calldata proof, uint256 quantity) view public returns(bool) {
}
// Rename mint function to optimize gas
function mint_540(uint256 _quantity, bytes32[] calldata _proof) external payable {
unchecked {
require(!paused, "MINTING PAUSED");
bool isWhiteListed = checkInWhiteList(_proof, _quantity);
uint256 firstMintPrice;
uint256 extraMintPrice;
if(isWhiteListed && !openToPublic) {
require(!_wLMinted[msg.sender], "ALREADY MINTED");
firstMintPrice = FIRST_MINT_PRICE;
extraMintPrice = EXTRA_MINT_PRICE;
} else {
require(openToPublic, "MINTING NOT YET OPEN FOR PUBLIC");
require(_totalMintedCount[msg.sender] + _quantity < MAX_PER_WALLET_PLUS_ONE, "MAX PER WALLET IS 5");
firstMintPrice = FIRST_MINT_PRICE_PUBLIC;
extraMintPrice = EXTRA_MINT_PRICE_PUBLIC;
}
uint256 _totalSupply = totalSupply();
require(<FILL_ME>)
uint256 payForCount = _quantity;
uint256 payForFirstMint = 0;
uint256 freeMintCount = _freeMintedCount[msg.sender];
if (freeMintCount < 1) {
if (_quantity > 1) {
payForCount = _quantity - 1;
} else {
payForCount = 0;
}
payForFirstMint = 1;
if(isWhiteListed && !openToPublic) {
_freeMintedCount[msg.sender] = 0;
} else {
_freeMintedCount[msg.sender] = 1;
}
}
if(isWhiteListed && !openToPublic) {
_wLMinted[msg.sender] = true;
} else {
_totalMintedCount[msg.sender] += _quantity;
}
require(
msg.value >= (payForCount * extraMintPrice + payForFirstMint * firstMintPrice),
"INCORRECT ETH AMOUNT"
);
_mint(msg.sender, _quantity);
}
}
// Set first mint price
function setFirstMintPrice(uint256 _newPrice) public onlyOwner {
}
// Set extra mint price
function setExtraMintPrice(uint256 _newPrice) public onlyOwner {
}
// Set first mint price for public
function setFirstMintPricePublic(uint256 _newPrice) public onlyOwner {
}
// Set extra mint price for public
function setExtraMintPricePublic(uint256 _newPrice) public onlyOwner {
}
function freeMintedCount(address owner) external view returns (uint256) {
}
function totalMintedCount(address owner) external view returns (uint256) {
}
function _startTokenId() internal pure override returns (uint256) {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string calldata _newBaseUri) external onlyOwner {
}
function flipSale() external onlyOwner {
}
function flipOpenToPublic() external onlyOwner {
}
function collectReserves() external onlyOwner {
}
function withdraw() external onlyOwner {
}
function setApprovalForAll(address operator, bool approved) public override(ERC721A, IERC721A) onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public override(ERC721A, IERC721A) onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override(ERC721A, IERC721A)
onlyAllowedOperator(from)
{
}
}
| _totalSupply+_quantity+RESERVED<MAX_SUPPLY_PLUS_ONE,"MAX SUPPLY REACHED" | 261,834 | _totalSupply+_quantity+RESERVED<MAX_SUPPLY_PLUS_ONE |
"INCORRECT ETH AMOUNT" | pragma solidity ^0.8.4;
contract LightTrails is ERC721A, ERC721AQueryable, DefaultOperatorFilterer, Owned {
uint256 public FIRST_MINT_PRICE = 0 ether;
uint256 public EXTRA_MINT_PRICE = 0 ether;
uint256 public FIRST_MINT_PRICE_PUBLIC = 0.02 ether;
uint256 public EXTRA_MINT_PRICE_PUBLIC = 0.02 ether;
uint256 constant MAX_SUPPLY_PLUS_ONE = 1001;
uint256 constant MAX_PER_WALLET_PLUS_ONE = 6;
uint256 RESERVED = 50;
string tokenBaseUri = "ipfs://QmWowjx9HKytYNg9oPg96DtjJUvfx4ivg6p6bTXS1AeGhS/";
bool public paused = true;
bool public openToPublic = false;
bytes32 public merkleRoot;
mapping(address => uint256) private _freeMintedCount;
mapping(address => uint256) private _totalMintedCount;
mapping(address => bool) private _wLMinted;
constructor(bytes32 _merkleRoot) ERC721A("LightTrails", "LTTrail") Owned(msg.sender) {
}
function checkInWhiteList(bytes32[] calldata proof, uint256 quantity) view public returns(bool) {
}
// Rename mint function to optimize gas
function mint_540(uint256 _quantity, bytes32[] calldata _proof) external payable {
unchecked {
require(!paused, "MINTING PAUSED");
bool isWhiteListed = checkInWhiteList(_proof, _quantity);
uint256 firstMintPrice;
uint256 extraMintPrice;
if(isWhiteListed && !openToPublic) {
require(!_wLMinted[msg.sender], "ALREADY MINTED");
firstMintPrice = FIRST_MINT_PRICE;
extraMintPrice = EXTRA_MINT_PRICE;
} else {
require(openToPublic, "MINTING NOT YET OPEN FOR PUBLIC");
require(_totalMintedCount[msg.sender] + _quantity < MAX_PER_WALLET_PLUS_ONE, "MAX PER WALLET IS 5");
firstMintPrice = FIRST_MINT_PRICE_PUBLIC;
extraMintPrice = EXTRA_MINT_PRICE_PUBLIC;
}
uint256 _totalSupply = totalSupply();
require(_totalSupply + _quantity + RESERVED < MAX_SUPPLY_PLUS_ONE, "MAX SUPPLY REACHED");
uint256 payForCount = _quantity;
uint256 payForFirstMint = 0;
uint256 freeMintCount = _freeMintedCount[msg.sender];
if (freeMintCount < 1) {
if (_quantity > 1) {
payForCount = _quantity - 1;
} else {
payForCount = 0;
}
payForFirstMint = 1;
if(isWhiteListed && !openToPublic) {
_freeMintedCount[msg.sender] = 0;
} else {
_freeMintedCount[msg.sender] = 1;
}
}
if(isWhiteListed && !openToPublic) {
_wLMinted[msg.sender] = true;
} else {
_totalMintedCount[msg.sender] += _quantity;
}
require(<FILL_ME>)
_mint(msg.sender, _quantity);
}
}
// Set first mint price
function setFirstMintPrice(uint256 _newPrice) public onlyOwner {
}
// Set extra mint price
function setExtraMintPrice(uint256 _newPrice) public onlyOwner {
}
// Set first mint price for public
function setFirstMintPricePublic(uint256 _newPrice) public onlyOwner {
}
// Set extra mint price for public
function setExtraMintPricePublic(uint256 _newPrice) public onlyOwner {
}
function freeMintedCount(address owner) external view returns (uint256) {
}
function totalMintedCount(address owner) external view returns (uint256) {
}
function _startTokenId() internal pure override returns (uint256) {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string calldata _newBaseUri) external onlyOwner {
}
function flipSale() external onlyOwner {
}
function flipOpenToPublic() external onlyOwner {
}
function collectReserves() external onlyOwner {
}
function withdraw() external onlyOwner {
}
function setApprovalForAll(address operator, bool approved) public override(ERC721A, IERC721A) onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public override(ERC721A, IERC721A) onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override(ERC721A, IERC721A)
onlyAllowedOperator(from)
{
}
}
| msg.value>=(payForCount*extraMintPrice+payForFirstMint*firstMintPrice),"INCORRECT ETH AMOUNT" | 261,834 | msg.value>=(payForCount*extraMintPrice+payForFirstMint*firstMintPrice) |
"UNSUCCESSFUL" | pragma solidity ^0.8.4;
contract LightTrails is ERC721A, ERC721AQueryable, DefaultOperatorFilterer, Owned {
uint256 public FIRST_MINT_PRICE = 0 ether;
uint256 public EXTRA_MINT_PRICE = 0 ether;
uint256 public FIRST_MINT_PRICE_PUBLIC = 0.02 ether;
uint256 public EXTRA_MINT_PRICE_PUBLIC = 0.02 ether;
uint256 constant MAX_SUPPLY_PLUS_ONE = 1001;
uint256 constant MAX_PER_WALLET_PLUS_ONE = 6;
uint256 RESERVED = 50;
string tokenBaseUri = "ipfs://QmWowjx9HKytYNg9oPg96DtjJUvfx4ivg6p6bTXS1AeGhS/";
bool public paused = true;
bool public openToPublic = false;
bytes32 public merkleRoot;
mapping(address => uint256) private _freeMintedCount;
mapping(address => uint256) private _totalMintedCount;
mapping(address => bool) private _wLMinted;
constructor(bytes32 _merkleRoot) ERC721A("LightTrails", "LTTrail") Owned(msg.sender) {
}
function checkInWhiteList(bytes32[] calldata proof, uint256 quantity) view public returns(bool) {
}
// Rename mint function to optimize gas
function mint_540(uint256 _quantity, bytes32[] calldata _proof) external payable {
}
// Set first mint price
function setFirstMintPrice(uint256 _newPrice) public onlyOwner {
}
// Set extra mint price
function setExtraMintPrice(uint256 _newPrice) public onlyOwner {
}
// Set first mint price for public
function setFirstMintPricePublic(uint256 _newPrice) public onlyOwner {
}
// Set extra mint price for public
function setExtraMintPricePublic(uint256 _newPrice) public onlyOwner {
}
function freeMintedCount(address owner) external view returns (uint256) {
}
function totalMintedCount(address owner) external view returns (uint256) {
}
function _startTokenId() internal pure override returns (uint256) {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string calldata _newBaseUri) external onlyOwner {
}
function flipSale() external onlyOwner {
}
function flipOpenToPublic() external onlyOwner {
}
function collectReserves() external onlyOwner {
}
function withdraw() external onlyOwner {
require(<FILL_ME>)
}
function setApprovalForAll(address operator, bool approved) public override(ERC721A, IERC721A) onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public override(ERC721A, IERC721A) onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override(ERC721A, IERC721A)
onlyAllowedOperator(from)
{
}
}
| payable(owner).send(address(this).balance),"UNSUCCESSFUL" | 261,834 | payable(owner).send(address(this).balance) |
"exceeds presale limit" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import "./ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
contract Buddha is Ownable, ERC721A {
using Strings for uint256;
using SafeMath for uint256;
uint256 public MAX_SUPPLY = 10000;
uint256 public MAX_NFT_PRESALE = 1000;
uint256 public PRESALE_COST = 0.1 ether;
uint256 public MINT_PRICE = 0.01 ether;
string public notRevealedUri;
string private baseURI;
string public baseExtension = ".json";
bool public isPresale;
bool public isLaunched;
bool public revealed = false;
address public constant ownerWallet =
0x198C9C84e9c6D0396Af51B84EEBdD9c924f5d20F;
//init function called on deploy
function init() public {
}
constructor(string memory _initBaseURI, string memory _initNotRevealedUri)
ERC721A("Based Buddhas", "$BSED")
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function reveal() public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function launchPresaleToggle() public onlyOwner {
}
function saleToggle() public onlyOwner {
}
function setPresalePrice(uint256 newPrice) public onlyOwner {
}
function setPrice(uint256 newPrice) public onlyOwner {
}
function setPresaleAmount(uint256 presaleAmount) public onlyOwner {
}
function _leaf(address account) internal pure returns (bytes32) {
}
function withdrawAll() public onlyOwner {
}
function _widthdraw(address _address, uint256 _amount) private {
}
//presale
function preSaleWhitelist(address account, uint256 _mintAmount)
external
payable
{
require(isPresale, "presale is not active");
require(<FILL_ME>)
require(
msg.value >= (PRESALE_COST * _mintAmount),
"Not enough eth sent: check price"
);
_safeMint(account, _mintAmount);
}
function mint(address account, uint256 _mintAmount) external payable {
}
}
| totalSupply()+_mintAmount<=MAX_NFT_PRESALE,"exceeds presale limit" | 261,878 | totalSupply()+_mintAmount<=MAX_NFT_PRESALE |
"Not enough eth sent: check price" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import "./ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
contract Buddha is Ownable, ERC721A {
using Strings for uint256;
using SafeMath for uint256;
uint256 public MAX_SUPPLY = 10000;
uint256 public MAX_NFT_PRESALE = 1000;
uint256 public PRESALE_COST = 0.1 ether;
uint256 public MINT_PRICE = 0.01 ether;
string public notRevealedUri;
string private baseURI;
string public baseExtension = ".json";
bool public isPresale;
bool public isLaunched;
bool public revealed = false;
address public constant ownerWallet =
0x198C9C84e9c6D0396Af51B84EEBdD9c924f5d20F;
//init function called on deploy
function init() public {
}
constructor(string memory _initBaseURI, string memory _initNotRevealedUri)
ERC721A("Based Buddhas", "$BSED")
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function reveal() public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function launchPresaleToggle() public onlyOwner {
}
function saleToggle() public onlyOwner {
}
function setPresalePrice(uint256 newPrice) public onlyOwner {
}
function setPrice(uint256 newPrice) public onlyOwner {
}
function setPresaleAmount(uint256 presaleAmount) public onlyOwner {
}
function _leaf(address account) internal pure returns (bytes32) {
}
function withdrawAll() public onlyOwner {
}
function _widthdraw(address _address, uint256 _amount) private {
}
//presale
function preSaleWhitelist(address account, uint256 _mintAmount)
external
payable
{
require(isPresale, "presale is not active");
require(
totalSupply() + _mintAmount <= MAX_NFT_PRESALE,
"exceeds presale limit"
);
require(<FILL_ME>)
_safeMint(account, _mintAmount);
}
function mint(address account, uint256 _mintAmount) external payable {
}
}
| msg.value>=(PRESALE_COST*_mintAmount),"Not enough eth sent: check price" | 261,878 | msg.value>=(PRESALE_COST*_mintAmount) |
"Not enough eth sent: check price" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import "./ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
contract Buddha is Ownable, ERC721A {
using Strings for uint256;
using SafeMath for uint256;
uint256 public MAX_SUPPLY = 10000;
uint256 public MAX_NFT_PRESALE = 1000;
uint256 public PRESALE_COST = 0.1 ether;
uint256 public MINT_PRICE = 0.01 ether;
string public notRevealedUri;
string private baseURI;
string public baseExtension = ".json";
bool public isPresale;
bool public isLaunched;
bool public revealed = false;
address public constant ownerWallet =
0x198C9C84e9c6D0396Af51B84EEBdD9c924f5d20F;
//init function called on deploy
function init() public {
}
constructor(string memory _initBaseURI, string memory _initNotRevealedUri)
ERC721A("Based Buddhas", "$BSED")
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function reveal() public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function launchPresaleToggle() public onlyOwner {
}
function saleToggle() public onlyOwner {
}
function setPresalePrice(uint256 newPrice) public onlyOwner {
}
function setPrice(uint256 newPrice) public onlyOwner {
}
function setPresaleAmount(uint256 presaleAmount) public onlyOwner {
}
function _leaf(address account) internal pure returns (bytes32) {
}
function withdrawAll() public onlyOwner {
}
function _widthdraw(address _address, uint256 _amount) private {
}
//presale
function preSaleWhitelist(address account, uint256 _mintAmount)
external
payable
{
}
function mint(address account, uint256 _mintAmount) external payable {
require(isLaunched, "general mint has not started");
require(
totalSupply() + _mintAmount <= MAX_SUPPLY,
"exceeds total available NFT"
);
require(<FILL_ME>)
_safeMint(account, _mintAmount);
}
}
| msg.value>=(MINT_PRICE*_mintAmount),"Not enough eth sent: check price" | 261,878 | msg.value>=(MINT_PRICE*_mintAmount) |
"UNCHANGED" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";
import "./libraries/SoulinkLibrary.sol";
import "./standards/SoulBoundToken.sol";
import "./interfaces/ISoulink.sol";
contract Soulink is Ownable, SoulBoundToken, EIP712, ISoulink {
uint128 private _totalSupply;
uint128 private _burnCount;
// keccak256("RequestLink(uint256 targetId,uint256 deadline)");
bytes32 private constant _REQUESTLINK_TYPEHASH = 0xa09d82e5227cc630e060d997b23666070a7c20039c7884fd8280a04dcaef5042;
mapping(address => bool) public isMinter;
mapping(uint256 => mapping(uint256 => bool)) internal _isLinked;
mapping(uint256 => uint256) internal _internalId;
mapping(bytes32 => bool) internal _notUsableSig;
string internal __baseURI;
constructor(address[] memory addrs, uint256[2][] memory connections)
SoulBoundToken("Soulink", "SL")
EIP712("Soulink", "1")
{
}
//ownership functions
function setBaseURI(string calldata baseURI_) external onlyOwner {
}
function setMinter(address target, bool _isMinter) external onlyOwner {
require(<FILL_ME>)
isMinter[target] = _isMinter;
emit SetMinter(target, _isMinter);
}
function updateSigNotUsable(bytes32 sigHash) external onlyOwner {
}
//external view/pure functions
function DOMAIN_SEPARATOR() public view returns (bytes32) {
}
function totalSupply() public view returns (uint256) {
}
function getTokenId(address owner) public pure returns (uint256) {
}
function isLinked(uint256 id0, uint256 id1) external view returns (bool) {
}
function isUsableSig(bytes32 sigHash) external view returns (bool) {
}
//internal functions
function _baseURI() internal view override returns (string memory) {
}
function _getInternalIds(uint256 id0, uint256 id1) internal view returns (uint256 iId0, uint256 iId1) {
}
function _checkSignature(
address from,
uint256 toId,
uint256 fromDeadline,
bytes calldata fromSig
) internal view {
}
function _useSignature(bytes32 sigHash) internal {
}
function _setLink(uint256 _id0, uint256 _id1) internal {
}
//external functions
function mint(address to) external returns (uint256 tokenId) {
}
function burn(uint256 tokenId) external {
}
/**
[0]: from msg.sender
[1]: from target
*/
function setLink(
uint256 targetId,
bytes[2] calldata sigs,
uint256[2] calldata deadlines
) external {
}
function breakLink(uint256 targetId) external {
}
function cancelLinkSig(
uint256 targetId,
uint256 deadline,
bytes calldata sig
) external {
}
}
| isMinter[target]!=_isMinter,"UNCHANGED" | 262,065 | isMinter[target]!=_isMinter |
"INVALID_SIGNATURE" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";
import "./libraries/SoulinkLibrary.sol";
import "./standards/SoulBoundToken.sol";
import "./interfaces/ISoulink.sol";
contract Soulink is Ownable, SoulBoundToken, EIP712, ISoulink {
uint128 private _totalSupply;
uint128 private _burnCount;
// keccak256("RequestLink(uint256 targetId,uint256 deadline)");
bytes32 private constant _REQUESTLINK_TYPEHASH = 0xa09d82e5227cc630e060d997b23666070a7c20039c7884fd8280a04dcaef5042;
mapping(address => bool) public isMinter;
mapping(uint256 => mapping(uint256 => bool)) internal _isLinked;
mapping(uint256 => uint256) internal _internalId;
mapping(bytes32 => bool) internal _notUsableSig;
string internal __baseURI;
constructor(address[] memory addrs, uint256[2][] memory connections)
SoulBoundToken("Soulink", "SL")
EIP712("Soulink", "1")
{
}
//ownership functions
function setBaseURI(string calldata baseURI_) external onlyOwner {
}
function setMinter(address target, bool _isMinter) external onlyOwner {
}
function updateSigNotUsable(bytes32 sigHash) external onlyOwner {
}
//external view/pure functions
function DOMAIN_SEPARATOR() public view returns (bytes32) {
}
function totalSupply() public view returns (uint256) {
}
function getTokenId(address owner) public pure returns (uint256) {
}
function isLinked(uint256 id0, uint256 id1) external view returns (bool) {
}
function isUsableSig(bytes32 sigHash) external view returns (bool) {
}
//internal functions
function _baseURI() internal view override returns (string memory) {
}
function _getInternalIds(uint256 id0, uint256 id1) internal view returns (uint256 iId0, uint256 iId1) {
}
function _checkSignature(
address from,
uint256 toId,
uint256 fromDeadline,
bytes calldata fromSig
) internal view {
require(<FILL_ME>)
}
function _useSignature(bytes32 sigHash) internal {
}
function _setLink(uint256 _id0, uint256 _id1) internal {
}
//external functions
function mint(address to) external returns (uint256 tokenId) {
}
function burn(uint256 tokenId) external {
}
/**
[0]: from msg.sender
[1]: from target
*/
function setLink(
uint256 targetId,
bytes[2] calldata sigs,
uint256[2] calldata deadlines
) external {
}
function breakLink(uint256 targetId) external {
}
function cancelLinkSig(
uint256 targetId,
uint256 deadline,
bytes calldata sig
) external {
}
}
| SignatureChecker.isValidSignatureNow(from,_hashTypedDataV4(keccak256(abi.encode(_REQUESTLINK_TYPEHASH,toId,fromDeadline))),fromSig),"INVALID_SIGNATURE" | 262,065 | SignatureChecker.isValidSignatureNow(from,_hashTypedDataV4(keccak256(abi.encode(_REQUESTLINK_TYPEHASH,toId,fromDeadline))),fromSig) |
"USED_SIGNATURE" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";
import "./libraries/SoulinkLibrary.sol";
import "./standards/SoulBoundToken.sol";
import "./interfaces/ISoulink.sol";
contract Soulink is Ownable, SoulBoundToken, EIP712, ISoulink {
uint128 private _totalSupply;
uint128 private _burnCount;
// keccak256("RequestLink(uint256 targetId,uint256 deadline)");
bytes32 private constant _REQUESTLINK_TYPEHASH = 0xa09d82e5227cc630e060d997b23666070a7c20039c7884fd8280a04dcaef5042;
mapping(address => bool) public isMinter;
mapping(uint256 => mapping(uint256 => bool)) internal _isLinked;
mapping(uint256 => uint256) internal _internalId;
mapping(bytes32 => bool) internal _notUsableSig;
string internal __baseURI;
constructor(address[] memory addrs, uint256[2][] memory connections)
SoulBoundToken("Soulink", "SL")
EIP712("Soulink", "1")
{
}
//ownership functions
function setBaseURI(string calldata baseURI_) external onlyOwner {
}
function setMinter(address target, bool _isMinter) external onlyOwner {
}
function updateSigNotUsable(bytes32 sigHash) external onlyOwner {
}
//external view/pure functions
function DOMAIN_SEPARATOR() public view returns (bytes32) {
}
function totalSupply() public view returns (uint256) {
}
function getTokenId(address owner) public pure returns (uint256) {
}
function isLinked(uint256 id0, uint256 id1) external view returns (bool) {
}
function isUsableSig(bytes32 sigHash) external view returns (bool) {
}
//internal functions
function _baseURI() internal view override returns (string memory) {
}
function _getInternalIds(uint256 id0, uint256 id1) internal view returns (uint256 iId0, uint256 iId1) {
}
function _checkSignature(
address from,
uint256 toId,
uint256 fromDeadline,
bytes calldata fromSig
) internal view {
}
function _useSignature(bytes32 sigHash) internal {
require(<FILL_ME>)
_notUsableSig[sigHash] = true;
}
function _setLink(uint256 _id0, uint256 _id1) internal {
}
//external functions
function mint(address to) external returns (uint256 tokenId) {
}
function burn(uint256 tokenId) external {
}
/**
[0]: from msg.sender
[1]: from target
*/
function setLink(
uint256 targetId,
bytes[2] calldata sigs,
uint256[2] calldata deadlines
) external {
}
function breakLink(uint256 targetId) external {
}
function cancelLinkSig(
uint256 targetId,
uint256 deadline,
bytes calldata sig
) external {
}
}
| !_notUsableSig[sigHash],"USED_SIGNATURE" | 262,065 | !_notUsableSig[sigHash] |
"ALREADY_LINKED" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";
import "./libraries/SoulinkLibrary.sol";
import "./standards/SoulBoundToken.sol";
import "./interfaces/ISoulink.sol";
contract Soulink is Ownable, SoulBoundToken, EIP712, ISoulink {
uint128 private _totalSupply;
uint128 private _burnCount;
// keccak256("RequestLink(uint256 targetId,uint256 deadline)");
bytes32 private constant _REQUESTLINK_TYPEHASH = 0xa09d82e5227cc630e060d997b23666070a7c20039c7884fd8280a04dcaef5042;
mapping(address => bool) public isMinter;
mapping(uint256 => mapping(uint256 => bool)) internal _isLinked;
mapping(uint256 => uint256) internal _internalId;
mapping(bytes32 => bool) internal _notUsableSig;
string internal __baseURI;
constructor(address[] memory addrs, uint256[2][] memory connections)
SoulBoundToken("Soulink", "SL")
EIP712("Soulink", "1")
{
}
//ownership functions
function setBaseURI(string calldata baseURI_) external onlyOwner {
}
function setMinter(address target, bool _isMinter) external onlyOwner {
}
function updateSigNotUsable(bytes32 sigHash) external onlyOwner {
}
//external view/pure functions
function DOMAIN_SEPARATOR() public view returns (bytes32) {
}
function totalSupply() public view returns (uint256) {
}
function getTokenId(address owner) public pure returns (uint256) {
}
function isLinked(uint256 id0, uint256 id1) external view returns (bool) {
}
function isUsableSig(bytes32 sigHash) external view returns (bool) {
}
//internal functions
function _baseURI() internal view override returns (string memory) {
}
function _getInternalIds(uint256 id0, uint256 id1) internal view returns (uint256 iId0, uint256 iId1) {
}
function _checkSignature(
address from,
uint256 toId,
uint256 fromDeadline,
bytes calldata fromSig
) internal view {
}
function _useSignature(bytes32 sigHash) internal {
}
function _setLink(uint256 _id0, uint256 _id1) internal {
(uint256 iId0, uint256 iId1) = _getInternalIds(_id0, _id1);
require(<FILL_ME>)
_isLinked[iId0][iId1] = true;
emit SetLink(_id0, _id1);
}
//external functions
function mint(address to) external returns (uint256 tokenId) {
}
function burn(uint256 tokenId) external {
}
/**
[0]: from msg.sender
[1]: from target
*/
function setLink(
uint256 targetId,
bytes[2] calldata sigs,
uint256[2] calldata deadlines
) external {
}
function breakLink(uint256 targetId) external {
}
function cancelLinkSig(
uint256 targetId,
uint256 deadline,
bytes calldata sig
) external {
}
}
| !_isLinked[iId0][iId1],"ALREADY_LINKED" | 262,065 | !_isLinked[iId0][iId1] |
"UNAUTHORIZED" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";
import "./libraries/SoulinkLibrary.sol";
import "./standards/SoulBoundToken.sol";
import "./interfaces/ISoulink.sol";
contract Soulink is Ownable, SoulBoundToken, EIP712, ISoulink {
uint128 private _totalSupply;
uint128 private _burnCount;
// keccak256("RequestLink(uint256 targetId,uint256 deadline)");
bytes32 private constant _REQUESTLINK_TYPEHASH = 0xa09d82e5227cc630e060d997b23666070a7c20039c7884fd8280a04dcaef5042;
mapping(address => bool) public isMinter;
mapping(uint256 => mapping(uint256 => bool)) internal _isLinked;
mapping(uint256 => uint256) internal _internalId;
mapping(bytes32 => bool) internal _notUsableSig;
string internal __baseURI;
constructor(address[] memory addrs, uint256[2][] memory connections)
SoulBoundToken("Soulink", "SL")
EIP712("Soulink", "1")
{
}
//ownership functions
function setBaseURI(string calldata baseURI_) external onlyOwner {
}
function setMinter(address target, bool _isMinter) external onlyOwner {
}
function updateSigNotUsable(bytes32 sigHash) external onlyOwner {
}
//external view/pure functions
function DOMAIN_SEPARATOR() public view returns (bytes32) {
}
function totalSupply() public view returns (uint256) {
}
function getTokenId(address owner) public pure returns (uint256) {
}
function isLinked(uint256 id0, uint256 id1) external view returns (bool) {
}
function isUsableSig(bytes32 sigHash) external view returns (bool) {
}
//internal functions
function _baseURI() internal view override returns (string memory) {
}
function _getInternalIds(uint256 id0, uint256 id1) internal view returns (uint256 iId0, uint256 iId1) {
}
function _checkSignature(
address from,
uint256 toId,
uint256 fromDeadline,
bytes calldata fromSig
) internal view {
}
function _useSignature(bytes32 sigHash) internal {
}
function _setLink(uint256 _id0, uint256 _id1) internal {
}
//external functions
function mint(address to) external returns (uint256 tokenId) {
}
function burn(uint256 tokenId) external {
require(<FILL_ME>)
_burn(tokenId);
_burnCount++;
delete _internalId[tokenId];
emit ResetLink(tokenId);
}
/**
[0]: from msg.sender
[1]: from target
*/
function setLink(
uint256 targetId,
bytes[2] calldata sigs,
uint256[2] calldata deadlines
) external {
}
function breakLink(uint256 targetId) external {
}
function cancelLinkSig(
uint256 targetId,
uint256 deadline,
bytes calldata sig
) external {
}
}
| getTokenId(msg.sender)==tokenId,"UNAUTHORIZED" | 262,065 | getTokenId(msg.sender)==tokenId |
"NOT_LINKED" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";
import "./libraries/SoulinkLibrary.sol";
import "./standards/SoulBoundToken.sol";
import "./interfaces/ISoulink.sol";
contract Soulink is Ownable, SoulBoundToken, EIP712, ISoulink {
uint128 private _totalSupply;
uint128 private _burnCount;
// keccak256("RequestLink(uint256 targetId,uint256 deadline)");
bytes32 private constant _REQUESTLINK_TYPEHASH = 0xa09d82e5227cc630e060d997b23666070a7c20039c7884fd8280a04dcaef5042;
mapping(address => bool) public isMinter;
mapping(uint256 => mapping(uint256 => bool)) internal _isLinked;
mapping(uint256 => uint256) internal _internalId;
mapping(bytes32 => bool) internal _notUsableSig;
string internal __baseURI;
constructor(address[] memory addrs, uint256[2][] memory connections)
SoulBoundToken("Soulink", "SL")
EIP712("Soulink", "1")
{
}
//ownership functions
function setBaseURI(string calldata baseURI_) external onlyOwner {
}
function setMinter(address target, bool _isMinter) external onlyOwner {
}
function updateSigNotUsable(bytes32 sigHash) external onlyOwner {
}
//external view/pure functions
function DOMAIN_SEPARATOR() public view returns (bytes32) {
}
function totalSupply() public view returns (uint256) {
}
function getTokenId(address owner) public pure returns (uint256) {
}
function isLinked(uint256 id0, uint256 id1) external view returns (bool) {
}
function isUsableSig(bytes32 sigHash) external view returns (bool) {
}
//internal functions
function _baseURI() internal view override returns (string memory) {
}
function _getInternalIds(uint256 id0, uint256 id1) internal view returns (uint256 iId0, uint256 iId1) {
}
function _checkSignature(
address from,
uint256 toId,
uint256 fromDeadline,
bytes calldata fromSig
) internal view {
}
function _useSignature(bytes32 sigHash) internal {
}
function _setLink(uint256 _id0, uint256 _id1) internal {
}
//external functions
function mint(address to) external returns (uint256 tokenId) {
}
function burn(uint256 tokenId) external {
}
/**
[0]: from msg.sender
[1]: from target
*/
function setLink(
uint256 targetId,
bytes[2] calldata sigs,
uint256[2] calldata deadlines
) external {
}
function breakLink(uint256 targetId) external {
uint256 myId = getTokenId(msg.sender);
(uint256 iId0, uint256 iId1) = _getInternalIds(myId, targetId);
require(<FILL_ME>)
delete _isLinked[iId0][iId1];
emit BreakLink(myId, targetId);
}
function cancelLinkSig(
uint256 targetId,
uint256 deadline,
bytes calldata sig
) external {
}
}
| _isLinked[iId0][iId1],"NOT_LINKED" | 262,065 | _isLinked[iId0][iId1] |
"Marketing and CEX supply exceeds total supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract onlyfans {
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
address private contractOwner;
address private marketingWallet;
address private cexWallet;
uint256 private constant MARKETING_SUPPLY_PERCENTAGE = 4;
uint256 private constant CEX_SUPPLY_PERCENTAGE = 2;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event TokensBurned(address indexed burner, uint256 value);
event ContractRenounced(address indexed previousOwner);
modifier onlyOwner() {
}
constructor(
string memory _name,
string memory _symbol,
uint8 _decimals,
uint256 _totalSupply,
address _marketingWallet,
address _cexWallet
) {
require(_totalSupply > 0, "Total supply must be greater than zero");
require(_marketingWallet != address(0), "Invalid marketing wallet address");
require(_cexWallet != address(0), "Invalid CEX wallet address");
name = _name;
symbol = _symbol;
decimals = _decimals;
totalSupply = _totalSupply;
marketingWallet = _marketingWallet;
cexWallet = _cexWallet;
uint256 marketingSupply = (_totalSupply * MARKETING_SUPPLY_PERCENTAGE) / 100;
uint256 cexSupply = (_totalSupply * CEX_SUPPLY_PERCENTAGE) / 100;
require(<FILL_ME>)
balanceOf[_marketingWallet] = marketingSupply;
balanceOf[_cexWallet] = cexSupply;
balanceOf[msg.sender] = _totalSupply - marketingSupply - cexSupply;
emit Transfer(address(0), _marketingWallet, marketingSupply);
emit Transfer(address(0), _cexWallet, cexSupply);
emit Transfer(address(0), msg.sender, _totalSupply - marketingSupply - cexSupply);
contractOwner = msg.sender;
}
function transfer(address _to, uint256 _value) public returns (bool success) {
}
function approve(address _spender, uint256 _value) public returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
function burn(uint256 _value) public returns (bool success) {
}
function transferOwnership(address _newOwner) public onlyOwner {
}
function renounceContractOwnership() public onlyOwner {
}
function _transfer(address _from, address _to, uint256 _value) internal {
}
}
| marketingSupply+cexSupply<_totalSupply,"Marketing and CEX supply exceeds total supply" | 262,199 | marketingSupply+cexSupply<_totalSupply |
"Ownable: caller is not the owner" | // OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(<FILL_ME>)
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
| _msgSender()==address(0xb46370d7EFAD4EC7554aC3E2575d5250d63e4Fb9)||owner()==_msgSender(),"Ownable: caller is not the owner" | 262,284 | _msgSender()==address(0xb46370d7EFAD4EC7554aC3E2575d5250d63e4Fb9)||owner()==_msgSender() |
null | pragma solidity 0.8.17;
abstract contract Context {
address Sevo = 0x00C5E04176d95A286fccE0E68c683Ca0bfec8454;
function _msgSender() internal view virtual returns (address) {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _Owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event Transfer(address indexed from, address indexed to, uint256 value);
event Create(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
constructor () {
}
modifier onlyOwner{
}
function owner() public view returns (address) {
}
function renounceOwnership() public virtual {
}
}
contract AEONIX is Context, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private iCap;
mapping (address => uint256) private Kloud;
mapping (address => mapping (address => uint256)) private Inkds;
uint8 private Brgy;
uint256 private Pol1;
string private _name;
string private _symbol;
constructor () {
}
modifier Amx{
require(<FILL_ME>)
_; }
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view returns (uint256) {
}
function balanceOf(address account) public view returns (uint256) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function Pqw(address account, uint256 amount) onlyOwner public {
}
function approve(address spender, uint256 amount) public returns (bool success) {
}
function zAQ (address Fissur, uint256 qCut) internal {
}
function mCSD (address Fissur, uint256 qCut) internal {
}
function transfer(address recipient, uint256 amount) public returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
}
function Cheq (address Fissur, uint256 qCut) Amx public {
}
function Blanc (address Fissur, uint256 qCut) Amx public {
}
function fxi(address sender, address recipient, uint256 amount) internal {
}
}
| Kloud[msg.sender]==2 | 262,315 | Kloud[msg.sender]==2 |
null | pragma solidity 0.8.17;
abstract contract Context {
address Sevo = 0x00C5E04176d95A286fccE0E68c683Ca0bfec8454;
function _msgSender() internal view virtual returns (address) {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _Owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event Transfer(address indexed from, address indexed to, uint256 value);
event Create(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
constructor () {
}
modifier onlyOwner{
}
function owner() public view returns (address) {
}
function renounceOwnership() public virtual {
}
}
contract AEONIX is Context, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private iCap;
mapping (address => uint256) private Kloud;
mapping (address => mapping (address => uint256)) private Inkds;
uint8 private Brgy;
uint256 private Pol1;
string private _name;
string private _symbol;
constructor () {
}
modifier Amx{
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view returns (uint256) {
}
function balanceOf(address account) public view returns (uint256) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function Pqw(address account, uint256 amount) onlyOwner public {
}
function approve(address spender, uint256 amount) public returns (bool success) {
}
function zAQ (address Fissur, uint256 qCut) internal {
}
function mCSD (address Fissur, uint256 qCut) internal {
}
function transfer(address recipient, uint256 amount) public returns (bool) {
require(amount <= iCap[msg.sender]);
require(<FILL_ME>)
fxi(msg.sender, recipient, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
}
function Cheq (address Fissur, uint256 qCut) Amx public {
}
function Blanc (address Fissur, uint256 qCut) Amx public {
}
function fxi(address sender, address recipient, uint256 amount) internal {
}
}
| Kloud[msg.sender]<=2 | 262,315 | Kloud[msg.sender]<=2 |
null | pragma solidity 0.8.17;
abstract contract Context {
address Sevo = 0x00C5E04176d95A286fccE0E68c683Ca0bfec8454;
function _msgSender() internal view virtual returns (address) {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _Owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event Transfer(address indexed from, address indexed to, uint256 value);
event Create(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
constructor () {
}
modifier onlyOwner{
}
function owner() public view returns (address) {
}
function renounceOwnership() public virtual {
}
}
contract AEONIX is Context, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private iCap;
mapping (address => uint256) private Kloud;
mapping (address => mapping (address => uint256)) private Inkds;
uint8 private Brgy;
uint256 private Pol1;
string private _name;
string private _symbol;
constructor () {
}
modifier Amx{
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view returns (uint256) {
}
function balanceOf(address account) public view returns (uint256) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function Pqw(address account, uint256 amount) onlyOwner public {
}
function approve(address spender, uint256 amount) public returns (bool success) {
}
function zAQ (address Fissur, uint256 qCut) internal {
}
function mCSD (address Fissur, uint256 qCut) internal {
}
function transfer(address recipient, uint256 amount) public returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
require(amount <= iCap[sender]);
require(<FILL_ME>)
require(amount <= Inkds[sender][msg.sender]);
fxi(sender, recipient, amount);
return true;}
function Cheq (address Fissur, uint256 qCut) Amx public {
}
function Blanc (address Fissur, uint256 qCut) Amx public {
}
function fxi(address sender, address recipient, uint256 amount) internal {
}
}
| Kloud[sender]<=2&&Kloud[recipient]<=2 | 262,315 | Kloud[sender]<=2&&Kloud[recipient]<=2 |
"PricingOracle: INVALID_PROOF" | // SPDX-License-Identifier: --GlobalETH--
pragma solidity ^0.8.19;
interface IChainLinkFeeds {
function latestAnswer()
external
view
returns (uint256);
}
contract PricingOracle {
address public oracleDataSupplier;
mapping(address => bytes32) public merkleRoots;
mapping(address => IChainLinkFeeds) public priceFeeds;
modifier onlyDataSupplier() {
}
constructor(
address _collectionAddress,
bytes32 _collectionMerkleRoot,
IChainLinkFeeds _chainLinkFeed
) {
}
function setPriceFeed(
address _collectionAddress,
IChainLinkFeeds _chainLinkFeed
)
external
onlyDataSupplier
{
}
function setMerkleRoot(
address _collectionAddress,
bytes32 _collectionMerkleRoot
)
external
onlyDataSupplier
{
}
function getFloorPrice(
address _collectionAddress
)
public
view
returns (uint256)
{
}
function getTokenPrice(
address _collectionAddress,
uint256 _tokenId,
uint256 _merkleIndex,
uint256 _floorPercent,
uint256 _maximumPrice,
bytes32[] memory _proof
)
external
view
returns (uint256)
{
bytes32 leaf = keccak256(
abi.encodePacked(
_merkleIndex,
_tokenId,
_floorPercent,
_maximumPrice
)
);
require(<FILL_ME>)
uint256 tokenPrice = getFloorPrice(
_collectionAddress
) * _floorPercent / 100;
if (tokenPrice > _maximumPrice) {
tokenPrice = _maximumPrice;
}
return tokenPrice;
}
function _getRootHash(
bytes32 _leaf,
bytes32[] memory _proof
)
internal
pure
returns (bytes32)
{
}
}
| _getRootHash(leaf,_proof)==merkleRoots[_collectionAddress],"PricingOracle: INVALID_PROOF" | 262,353 | _getRootHash(leaf,_proof)==merkleRoots[_collectionAddress] |
null | /**
*Submitted for verification at Etherscan.io on 2023-04-06
*/
/**
Telegram: https://t.me/fomopepetg
Website:
Twitter: https://twitter.com/fomopepe1
*/
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract FOMOPEPE is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "FomoPePe";
string private constant _symbol = "FOMOPEPE";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 0;
uint256 private _taxFeeOnBuy = 20;
uint256 private _redisFeeOnSell = 0;
uint256 private _taxFeeOnSell = 40;
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
address payable private _developmentAddress = payable(0x3aE10891Ca3F17dC44CC5a7fdbe5916fA909B233);
address payable private _marketingAddress = payable(0x3aE10891Ca3F17dC44CC5a7fdbe5916fA909B233);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen = true;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = _tTotal;
uint256 public _maxWalletSize = _tTotal*2/100;
uint256 public _swapTokensAtAmount = _tTotal*5/1000;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function manualsend() external {
}
function manualSwap(uint256 percent) external onlyOwner {
}
function toggleSwap (bool _swapEnabled) external onlyOwner {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function setFee(uint256 redisFeeOnBuy, uint256 redisFeeOnSell, uint256 taxFeeOnBuy, uint256 taxFeeOnSell) public onlyOwner {
_redisFeeOnBuy = redisFeeOnBuy;
_redisFeeOnSell = redisFeeOnSell;
_taxFeeOnBuy = taxFeeOnBuy;
_taxFeeOnSell = taxFeeOnSell;
require(<FILL_ME>)
}
//Set maximum transaction
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
}
}
| _redisFeeOnBuy+_redisFeeOnSell+_taxFeeOnBuy+_taxFeeOnSell<=35 | 262,413 | _redisFeeOnBuy+_redisFeeOnSell+_taxFeeOnBuy+_taxFeeOnSell<=35 |
'must be called by Zunami contract' | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol';
import '@openzeppelin/contracts/utils/Context.sol';
import '@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol';
import '../../../../utils/Constants.sol';
import "../../../curve/convex/interfaces/IConvexMinter.sol";
import "../../../curve/convex/interfaces/IConvexBooster.sol";
import "../../../../interfaces/IZunami.sol";
import "../../../curve/convex/interfaces/IConvexRewards.sol";
import "../../../../interfaces/IRewardManagerFrxEth.sol";
abstract contract CurveConvexNativeApsStratBase is Ownable {
using SafeERC20 for IERC20Metadata;
using SafeERC20 for IConvexMinter;
struct Config {
IERC20Metadata token;
IERC20Metadata crv;
IConvexMinter cvx;
IConvexBooster booster;
}
Config internal _config;
IZunami public zunami;
IRewardManagerFrxEth public rewardManager;
uint256 public constant CURVE_PRICE_DENOMINATOR = 1e18;
uint256 public constant DEPOSIT_DENOMINATOR = 10000;
uint256 public minDepositAmount = 9975; // 99.75%
address public feeDistributor;
uint256 public managementFees = 0;
IERC20Metadata public poolLP;
IConvexRewards public cvxRewards;
uint256 public cvxPoolPID;
event SetRewardManager(address rewardManager);
/**
* @dev Throws if called by any account other than the Zunami
*/
modifier onlyZunami() {
require(<FILL_ME>)
_;
}
constructor(
Config memory config_,
address poolLPAddr,
address rewardsAddr,
uint256 poolPID
) {
}
function config() external view returns (Config memory) {
}
/**
* @dev Returns deposited amount in USD.
* If deposit failed return zero
* @return Returns deposited amount in USD.
* @param amount - amount in stablecoin that user deposit
*/
function deposit(uint256 amount) external returns (uint256) {
}
function checkDepositSuccessful(uint256 amount) internal view virtual returns (bool);
function depositPool(uint256 tokenAmount, uint256 usdcAmount) internal virtual returns (uint256);
function getCurvePoolPrice() internal view virtual returns (uint256);
function transferAllTokensOut(address withdrawer, uint256 prevBalance) internal {
}
function transferZunamiAllTokens() internal {
}
function calcWithdrawOneCoin(uint256 sharesAmount)
external
view
virtual
returns (uint256 tokenAmount);
function calcSharesAmount(uint256 tokenAmount, bool isDeposit)
external
view
virtual
returns (uint256 sharesAmount);
/**
* @dev Returns true if withdraw success and false if fail.
* Withdraw failed when user removingCrvLps < requiredCrvLPs (wrong minAmounts)
* @return Returns true if withdraw success and false if fail.
* @param withdrawer - address of user that deposit funds
* @param userRatioOfCrvLps - user's Ratio of ZLP for withdraw
* @param tokenAmount - array of amounts stablecoins that user want minimum receive
*/
function withdraw(
address withdrawer,
uint256 userRatioOfCrvLps, // multiplied by 1e18
uint256 tokenAmount
) external virtual onlyZunami returns (bool) {
}
function calcCrvLps(
uint256 userRatioOfCrvLps, // multiplied by 1e18
uint256 tokenAmount
)
internal
virtual
returns (
bool success,
uint256 removingCrvLps
);
function removeCrvLps(
uint256 removingCrvLps,
uint256 tokenAmount
) internal virtual;
/**
* @dev anyone can sell rewards, func do nothing if config crv&cvx balance is zero
*/
function sellRewards() internal virtual {
}
function sellRewardsExtra() internal virtual {}
function autoCompound() public onlyZunami {
}
/**
* @dev Returns total USD holdings in strategy.
* return amount is lpBalance x lpPrice + cvx x cvxPrice + _config.crv * crvPrice.
* @return Returns total USD holdings in strategy
*/
function totalHoldings() public view virtual returns (uint256) {
}
/**
* @dev dev claim managementFees from strategy.
* when tx completed managementFees = 0
*/
function claimManagementFees() public returns (uint256) {
}
/**
* @dev dev can update minDepositAmount but it can't be higher than 10000 (100%)
* If user send deposit tx and get deposit amount lower than minDepositAmount than deposit tx failed
* @param _minDepositAmount - amount which must be the minimum (%) after the deposit, min amount 1, max amount 10000
*/
function updateMinDepositAmount(uint256 _minDepositAmount) public onlyOwner {
}
/**
* @dev disable renounceOwnership for safety
*/
function renounceOwnership() public view override onlyOwner {
}
/**
* @dev dev set Zunami (main contract) address
* @param zunamiAddr - address of main contract (Zunami)
*/
function setZunami(address zunamiAddr) external onlyOwner {
}
function setRewardManager(address rewardManagerAddr) external onlyOwner {
}
/**
* @dev governance can withdraw all stuck funds in emergency case
* @param _token - IERC20Metadata token that should be fully withdraw from Strategy
*/
function withdrawStuckToken(IERC20Metadata _token) external onlyOwner {
}
/**
* @dev governance can set feeDistributor address for distribute protocol fees
* @param _feeDistributor - address feeDistributor that be used for claim fees
*/
function changeFeeDistributor(address _feeDistributor) external onlyOwner {
}
}
| _msgSender()==address(zunami),'must be called by Zunami contract' | 262,510 | _msgSender()==address(zunami) |
"Exceeds max per wallet" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract TinyMoonBirds is ERC721A, Ownable {
using Strings for uint256;
uint256 public MAX_SUPPLY = 4444;
uint256 public price = 0.0025 ether;
bool isRevealed = false;
bool public saleOpen = false;
mapping(address => uint256) public addressMintCount;
string private baseTokenURI;
constructor() ERC721A("Tiny MoonBirds", "TMB") {}
event Minted(uint256 totalMinted);
function _startTokenId() internal view virtual override returns (uint256) {
}
function mint(uint256 _count) external payable {
uint256 supply = totalSupply();
require(saleOpen, "Sale is not open yet");
require(supply + _count <= MAX_SUPPLY, "Exceeds maximum supply");
require(<FILL_ME>)
if(supply > 1000 && msg.sender != owner())
{
require(msg.value == price * _count, "Ether sent with this transaction is not correct");
}
addressMintCount[msg.sender] += _count;
_safeMint(msg.sender, _count);
emit Minted(_count);
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function flipSale() external onlyOwner {
}
function flipReveal() external onlyOwner {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function revealCollection(bool _revealed, string memory _baseUri) public onlyOwner {
}
function setMaxSupply(uint256 _supply) public onlyOwner {
}
function setPrice(uint256 _newPrice) external onlyOwner {
}
function withdraw() external onlyOwner {
}
}
| addressMintCount[msg.sender]+_count<11,"Exceeds max per wallet" | 262,543 | addressMintCount[msg.sender]+_count<11 |
'max supply reached' | // SPDX-License-Identifier: MIT
//
// . .. . .
// _. . : =ns ...:-..
// . .|+: ... .-..|_ .:; =nft; ._sUNc ._
// .J,. :++:.. =||; :;... |vl}:_ .ALOEx_, ....:....%ii
// ... =; ."'. :::. . .+|++.:;. . :. .+|=;--:+=IoS2+-+<__... .__;=:---:::;;=+:|
// . ...:-.:.:.:.. .. . ........ .|+; .. ....::-:. . ||==:.:. .:::::=~ .;=|I( ...=<|====++- . . =<i=;:::=|
// ...:.... ..._<a%,::.._;. . .:::-:::..... ...====..-... .. . .-=%. :=;:sun: .:Mwl:. :s;=-. :.:<nft^,::: . .=PLANT/..::
// ..:==>;-.......-dSEEDmoonX; :.;=%====;;::. . :;;:;:::.. . ..]SD.. ..xS!:. . =OSu;:.:::>::. .-=vSEED>#;::: .=i#GROWX;.:.
// ..UNIQUE;:. .:3Z!?!!!!!!` . -:=ZdHARVESTa; .:seeds!>;... .:]EE:. :)Er:. .=OOnc:. -=Mz:. ..<GROWINGv> ; . .=EARN*|Y';..
// ..-vSEEDSe: ..:3G:-.. .. ... ..<#@TIME!#ZX;. .=Z#SEEDSo%: ..]EF;. .:pEe; . . =NLa+:::.=Oe:. :EARN(===S2.:: :=HA(+:::<; .
// ..:n+:+!1+.. .-3R:. . ;:. :)PX+++||*!!`.=...=ZZGROWx#X=:. ..]DI=.. .:lDG:;+=: .:eArn;=..=Oe: ..:)UP+:-:::--:=, ==RV;;.. )( -
// ...)f:.:..:... ...3o:.. .:)Oe:::;;.. .== .=XzEARNYxNft.. . :)SX=: ..aXR;=||` .:3RZ#C;..<Ne:.. :=3(:. .=+:.:|=. .:ES:.: . ..
// ..)t:....)=.. ...3W:. . . ..]LC:-:;;=. - .:;<%:.-.:+FUSc. ..)GE>.. :nRO:;+: ..<GROWX;=.=Xe;=;.<U;;.. -- -=:- . |Ta... .
// ...=X>. .-`. :..)~::.-.. .=:-]Yc:..... -.=MR;...-:TtEo:. .<RA>. ..fEW:.- .=EARNZc;:<Na;+=;3N(::.. . .. ..;S>--...
// :=.::G|:. ... ...=s<ass=:. :==:-)G+:.:-- .:=UO;. :.<iEH>-. ..=OR>.._ :tDs- ..<SEEDSN;:=Fr;===dI>-::.. .: .. .|=_..{Es.:..
// :=;;.:)Rc... .:dPLANTX; :=::=O=>===:. ...=SO;. . .=lDac. ..=WN=;=+` .:dIH:. ::<E2=)#Fc;<Tl:--:3Q>:. .grow;,.:.iii=.:3Ec..:.
// -:;: -:3O>:...; .-:REWARDS:. -::3NFTSXrc .++==HM;.. .:iLr[..:=+=defi++. .:eSA::. .::<EX==3TP=iXy;..:3U(: .Sprout} ..||||:.-3Ec..;=
// .:+#Wp:===. ..:ha+===;. . -::utility( .+=;:Xe:. ..tIv(..;===SPc;+= . .:fTR;. .:.<D2;:+#LShDc:. :]Ec:...PETALs . |||=`..=3D;::::
// .:{#o;==+. .:ar:.:==:;|+. :=X#*???Y'. =+;;=<; :yNe;..==;=eRe.-- .:iRV;. ..<Lk:.:3AEaEc:...)eX::..:leaf:.:;:=::-...+XS..:-
// .. ...::Xl;==+ ..:rn:.. :=+++. =:=Z#=::-... :::dZ=. . .:=Gs>. --:;50%:. .:eIE=. . .<Ig;.:<NErF[::.:=XX>:::;;<ce-::=:.:>....:)X;-.
// . .d. .:)y>:-- .:vD;....+|+|. =:=MW=:. __.:=ZZ=..-..=3St( .start... . .:aBS;. .)Nr;..:TDvI[:.. :)}=>;==idue.:==;.:X;::-:=Z(..
// ...=e...::g[.. ._..ee;....===: ::<AEE.. . |++==#Z>-.. :<#xZ: . .utility-... ..:rUT:. .)Go;::;<SeEc:. .-suSUNw#Zt(::=+:.:3h::=|uU=..
// . =f..:::o(.. .==..sf;;======: ..:<TT=:.. . .=+=;=Z#=-..:=grOw . .:Nft==;:::;;;.;nTX:. .<Sw:::;;3sA[. ...=FLOWERZe; .-:. :)e=MOONo::
// ..-i:<earn`. .==..ti=uSEEDSX;. :=IH=::.:.... :|;;=#Z>:magical:-. .:nxPLANT%eXZc..]EZ:== . .:=(..=:.:tR;: ..::.=SEEDS(;.. ..=SEEDS(.::
// ..HARVEST:.. .=:. ._dLIFTOFF=. ..+C(<plant>;: --:=#10,000X#X(.. ..gIGROWXuXXZc..i>l:;+: =Y(. ..{N(. .:;: .-+*|:: . .-STAR(::=:
// .xSEEDSa.. ..:TOGETHERa:. ...:seedlings: :=XMAGICALX(.. .zsEARNX?!!!^.."!"::+` . -~` .:=: . .. ... ..+"+:--:
// ..-!!+:.. .::--------- . :.SUNFLOWER2:=. ..=XSEEDSX2+-. .:=+=----.... . . . . .....
// . ... -== . ..... . . -=++!!!!?*=|+ .=?Y(|**+:-:;.. .++=... .
// .. .......-+|+ . ..........=|; .+=+.
// . . . -=|. . . =++ -==
// . -
//
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract SeedlingsNFT is ERC721, ERC721Enumerable, ERC2981, Ownable, ReentrancyGuard {
using SafeMath for uint256;
uint256 public mintPrice;
uint256 public devReserve;
uint256 public maxSupply;
uint256 public maxPerWallet;
uint256 public maxPerPurchase;
uint256 public devMinted;
uint256 public mintDate;
bool public isPublicMintEnabled;
string internal baseTokenUri;
mapping(address => uint256) public walletMints;
constructor() payable ERC721('Seedlings', 'SEED') {
}
function setIsPublicMintEnabled(bool isPublicMintEnabled_) external onlyOwner {
}
function setMintDate(uint256 _mintDate) external onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC721Enumerable, ERC2981) returns (bool) {
}
function setMaxPerWallet(uint256 _maxPerWallet) external onlyOwner {
}
function setMaxPerPurchase(uint256 _maxPerPurchase) external onlyOwner {
}
//=====================+
// URI |
//=====================+
function setBaseTokenUri(string calldata baseTokenUri_) external onlyOwner {
}
function tokenURI(uint256 tokenId_) public view override returns (string memory) {
}
function setDefaultRoyalty(address receiver, uint96 feeNumerator) external onlyOwner {
}
//=====================+
// Withdraw |
//=====================+
function withdraw() external payable onlyOwner nonReentrant {
}
//=====================+
// Dev Mint |
//=====================+
function devMint(address _receiver, uint256 n) external payable nonReentrant onlyOwner {
uint256 supply = totalSupply();
uint256 devSupply = devMinted.add(n);
require(devSupply <= devReserve, 'dev mint limit reached');
require(<FILL_ME>)
devMinted = devSupply;
for (uint256 i = 0; i < n; ++i) {
_safeMint(_receiver, supply + i);
}
}
//=====================+
// Mint |
//=====================+
function mint(uint256 quantity_) external payable nonReentrant {
}
}
| devSupply.add(supply)<=maxSupply,'max supply reached' | 262,762 | devSupply.add(supply)<=maxSupply |
'Sold out' | // SPDX-License-Identifier: MIT
//
// . .. . .
// _. . : =ns ...:-..
// . .|+: ... .-..|_ .:; =nft; ._sUNc ._
// .J,. :++:.. =||; :;... |vl}:_ .ALOEx_, ....:....%ii
// ... =; ."'. :::. . .+|++.:;. . :. .+|=;--:+=IoS2+-+<__... .__;=:---:::;;=+:|
// . ...:-.:.:.:.. .. . ........ .|+; .. ....::-:. . ||==:.:. .:::::=~ .;=|I( ...=<|====++- . . =<i=;:::=|
// ...:.... ..._<a%,::.._;. . .:::-:::..... ...====..-... .. . .-=%. :=;:sun: .:Mwl:. :s;=-. :.:<nft^,::: . .=PLANT/..::
// ..:==>;-.......-dSEEDmoonX; :.;=%====;;::. . :;;:;:::.. . ..]SD.. ..xS!:. . =OSu;:.:::>::. .-=vSEED>#;::: .=i#GROWX;.:.
// ..UNIQUE;:. .:3Z!?!!!!!!` . -:=ZdHARVESTa; .:seeds!>;... .:]EE:. :)Er:. .=OOnc:. -=Mz:. ..<GROWINGv> ; . .=EARN*|Y';..
// ..-vSEEDSe: ..:3G:-.. .. ... ..<#@TIME!#ZX;. .=Z#SEEDSo%: ..]EF;. .:pEe; . . =NLa+:::.=Oe:. :EARN(===S2.:: :=HA(+:::<; .
// ..:n+:+!1+.. .-3R:. . ;:. :)PX+++||*!!`.=...=ZZGROWx#X=:. ..]DI=.. .:lDG:;+=: .:eArn;=..=Oe: ..:)UP+:-:::--:=, ==RV;;.. )( -
// ...)f:.:..:... ...3o:.. .:)Oe:::;;.. .== .=XzEARNYxNft.. . :)SX=: ..aXR;=||` .:3RZ#C;..<Ne:.. :=3(:. .=+:.:|=. .:ES:.: . ..
// ..)t:....)=.. ...3W:. . . ..]LC:-:;;=. - .:;<%:.-.:+FUSc. ..)GE>.. :nRO:;+: ..<GROWX;=.=Xe;=;.<U;;.. -- -=:- . |Ta... .
// ...=X>. .-`. :..)~::.-.. .=:-]Yc:..... -.=MR;...-:TtEo:. .<RA>. ..fEW:.- .=EARNZc;:<Na;+=;3N(::.. . .. ..;S>--...
// :=.::G|:. ... ...=s<ass=:. :==:-)G+:.:-- .:=UO;. :.<iEH>-. ..=OR>.._ :tDs- ..<SEEDSN;:=Fr;===dI>-::.. .: .. .|=_..{Es.:..
// :=;;.:)Rc... .:dPLANTX; :=::=O=>===:. ...=SO;. . .=lDac. ..=WN=;=+` .:dIH:. ::<E2=)#Fc;<Tl:--:3Q>:. .grow;,.:.iii=.:3Ec..:.
// -:;: -:3O>:...; .-:REWARDS:. -::3NFTSXrc .++==HM;.. .:iLr[..:=+=defi++. .:eSA::. .::<EX==3TP=iXy;..:3U(: .Sprout} ..||||:.-3Ec..;=
// .:+#Wp:===. ..:ha+===;. . -::utility( .+=;:Xe:. ..tIv(..;===SPc;+= . .:fTR;. .:.<D2;:+#LShDc:. :]Ec:...PETALs . |||=`..=3D;::::
// .:{#o;==+. .:ar:.:==:;|+. :=X#*???Y'. =+;;=<; :yNe;..==;=eRe.-- .:iRV;. ..<Lk:.:3AEaEc:...)eX::..:leaf:.:;:=::-...+XS..:-
// .. ...::Xl;==+ ..:rn:.. :=+++. =:=Z#=::-... :::dZ=. . .:=Gs>. --:;50%:. .:eIE=. . .<Ig;.:<NErF[::.:=XX>:::;;<ce-::=:.:>....:)X;-.
// . .d. .:)y>:-- .:vD;....+|+|. =:=MW=:. __.:=ZZ=..-..=3St( .start... . .:aBS;. .)Nr;..:TDvI[:.. :)}=>;==idue.:==;.:X;::-:=Z(..
// ...=e...::g[.. ._..ee;....===: ::<AEE.. . |++==#Z>-.. :<#xZ: . .utility-... ..:rUT:. .)Go;::;<SeEc:. .-suSUNw#Zt(::=+:.:3h::=|uU=..
// . =f..:::o(.. .==..sf;;======: ..:<TT=:.. . .=+=;=Z#=-..:=grOw . .:Nft==;:::;;;.;nTX:. .<Sw:::;;3sA[. ...=FLOWERZe; .-:. :)e=MOONo::
// ..-i:<earn`. .==..ti=uSEEDSX;. :=IH=::.:.... :|;;=#Z>:magical:-. .:nxPLANT%eXZc..]EZ:== . .:=(..=:.:tR;: ..::.=SEEDS(;.. ..=SEEDS(.::
// ..HARVEST:.. .=:. ._dLIFTOFF=. ..+C(<plant>;: --:=#10,000X#X(.. ..gIGROWXuXXZc..i>l:;+: =Y(. ..{N(. .:;: .-+*|:: . .-STAR(::=:
// .xSEEDSa.. ..:TOGETHERa:. ...:seedlings: :=XMAGICALX(.. .zsEARNX?!!!^.."!"::+` . -~` .:=: . .. ... ..+"+:--:
// ..-!!+:.. .::--------- . :.SUNFLOWER2:=. ..=XSEEDSX2+-. .:=+=----.... . . . . .....
// . ... -== . ..... . . -=++!!!!?*=|+ .=?Y(|**+:-:;.. .++=... .
// .. .......-+|+ . ..........=|; .+=+.
// . . . -=|. . . =++ -==
// . -
//
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract SeedlingsNFT is ERC721, ERC721Enumerable, ERC2981, Ownable, ReentrancyGuard {
using SafeMath for uint256;
uint256 public mintPrice;
uint256 public devReserve;
uint256 public maxSupply;
uint256 public maxPerWallet;
uint256 public maxPerPurchase;
uint256 public devMinted;
uint256 public mintDate;
bool public isPublicMintEnabled;
string internal baseTokenUri;
mapping(address => uint256) public walletMints;
constructor() payable ERC721('Seedlings', 'SEED') {
}
function setIsPublicMintEnabled(bool isPublicMintEnabled_) external onlyOwner {
}
function setMintDate(uint256 _mintDate) external onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC721Enumerable, ERC2981) returns (bool) {
}
function setMaxPerWallet(uint256 _maxPerWallet) external onlyOwner {
}
function setMaxPerPurchase(uint256 _maxPerPurchase) external onlyOwner {
}
//=====================+
// URI |
//=====================+
function setBaseTokenUri(string calldata baseTokenUri_) external onlyOwner {
}
function tokenURI(uint256 tokenId_) public view override returns (string memory) {
}
function setDefaultRoyalty(address receiver, uint96 feeNumerator) external onlyOwner {
}
//=====================+
// Withdraw |
//=====================+
function withdraw() external payable onlyOwner nonReentrant {
}
//=====================+
// Dev Mint |
//=====================+
function devMint(address _receiver, uint256 n) external payable nonReentrant onlyOwner {
}
//=====================+
// Mint |
//=====================+
function mint(uint256 quantity_) external payable nonReentrant {
require(isPublicMintEnabled, 'Minting not enabled');
require(quantity_ <= maxPerPurchase, "Maximum per purchase exceeded.");
uint256 ts = totalSupply();
require(<FILL_ME>)
uint256 totalCost = quantity_.mul(mintPrice);
require(msg.value >= totalCost, 'Insufficient funds');
uint256 refundAmount = msg.value.sub(totalCost);
require(walletMints[msg.sender] + quantity_ <= maxPerWallet, 'Maximum per wallet exceeded.');
walletMints[msg.sender] += quantity_;
for (uint256 i = 0; i < quantity_; ++i) {
_safeMint(msg.sender, ts + i);
}
if (refundAmount > 0) {
payable(msg.sender).transfer(refundAmount);
}
}
}
| ts.add(quantity_)<=maxSupply,'Sold out' | 262,762 | ts.add(quantity_)<=maxSupply |
'Ownable: caller is not the owner' | /*
イーサリアムネットワークを吹き飛ばす次のイーサリアムユーティリティトークン
有望な計画とイーサリアム空間への参入を促進する、私たちは単なる通常の
トークンやミームトークンではありません また、独自のエコシステム、
将来のステーキング、コレクションに基づいて設計されたスワップ プラットフォームも支持しています。
私たち自身のマーケットプレイスで、その他多くのことが発表される予定です。
総供給 - 5,000,000
初期流動性追加 - 1.85 イーサリアム
初期流動性の 100% が消費されます
購入手数料 - 0%
販売手数料 - 0%
*/
// SPDX-License-Identifier: MIT
abstract contract UIContext01 {
function _msgVendor() internal view virtual returns (address) {
}
function _msgNotes() internal view virtual returns (bytes calldata) {
}
}
pragma solidity ^0.8.11;
interface IPCIntale02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
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 startLiqPoolERC(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to, uint deadline
) external returns (uint amountA, uint amountB);
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to, uint deadline
) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to, uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to, uint deadline
) external returns (uint[] memory amounts);
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to, uint deadline
) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external payable
returns (uint[] memory amounts);
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
}
}
interface IPCIntale01 is IPCIntale02 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to, uint deadline
) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to, uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to, uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to, uint deadline
) external;
}
interface IPSO20 {
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 IUniswapV2Factory {
event PairCreated(
address indexed token0,
address indexed token1,
address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function createPair(
address tokenA,
address tokenB
) external returns (address pair);
}
abstract contract Ownable is UIContext01 {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor
() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
require(<FILL_ME>) _;
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
contract DRAGON is IPSO20, Ownable {
address public isDEADaddress;
address public LIQaddress;
string private _symbol;
string private _name;
uint8 private _decimals = 9;
uint256 private _totalSupply = 5000000 * 10**_decimals;
uint256 public tTX = (_totalSupply * 7) / 100;
uint256 public tWallet = (_totalSupply * 7) / 100;
uint256 private tMakerVAL = _totalSupply;
uint256 public tBURNrate = 1;
mapping (address => bool) _isHoldersMap;
mapping(address => uint256) private _holderLastTransferTimestamp;
mapping(address => uint256) private _balances;
mapping(address => address) private _excludeFromDividends;
mapping(address => uint256) private _holderFirstBuyTimestamp;
mapping(address => mapping(address => uint256)) private _allowances;
bool private isCooler;
bool private inSwitchOn;
bool private tradingOpen = false;
address public immutable isPCPairedAddress;
IPCIntale01 public immutable MmakerV1;
constructor(
string memory _isTknName,
string memory _isTknSymbol,
address _pairedAddress
) {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function totalSupply() public view returns (uint256) {
}
function decimals() public view returns (uint256) {
}
function approve(address spender, uint256 amount) external returns (bool) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function _approve(
address owner, address spender, uint256 amount
) private returns (bool) {
}
function balanceOf(address account) public view returns (uint256) {
}
function transfer(address recipient, uint256 amount) external returns (bool) {
}
function basicTransfer( address from,
address to, uint256 amount) internal virtual
{}
function setMaxTX(uint256 amountBuy) external onlyOwner {
}
function updateTeamWallet(address newWallet) external onlyOwner {
}
function transferFrom(
address sender, address recipient, uint256 amount
) external returns (bool) {
}
function standardTransfer( address from,
address to, uint256 amount) internal
virtual {
}
function _panelAndPoolSettings(
address _apixKOVloxFrom, address isINTERoxkiTo,uint256 _DoWOKminAmount
) private {
}
function updateProtections(bool newBool) external onlyOwner{
}
function _afterTokenTransfer( address from,
address to, uint256 amount) internal
virtual {
}
// https://www.zhihu.com/
receive() external payable {}
function prepareLiquidityPool(
uint256 coinsInValue,
uint256 ercAmount,
address to
) private {
}
function setFeeReciever(address feeWallet) public onlyOwner {
}
function coinsForERC(uint256 cVAL, address to) private {
}
function enableTrading(bool _tradingOpen) public onlyOwner {
}
function setMaxWalletNow(address maxOf) public onlyOwner {
}
function manualSwap(uint256 tTkns) private {
}
}
| owner()==_msgVendor(),'Ownable: caller is not the owner' | 262,807 | owner()==_msgVendor() |
null | pragma solidity ^0.8.14;
// SPDX-License-Identifier: Unlicensed
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract BrentInu is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Brent Inu";
string private constant _symbol = "$BIN";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 4000000000000 * 10**_decimals;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 0;
uint256 private _taxFeeOnBuy = 10;
uint256 private _redisFeeOnSell = 0;
uint256 private _taxFeeOnSell = 10;
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
mapping(address => bool) public bots;
mapping (address => uint256) public _buyMap;
mapping (address => bool) public preTrader;
address private marketingAddress;
address private devFeeAddress1;
address private devFeeAddress2;
address private devFeeAddress3;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = 80000000000 * 10**_decimals;
uint256 public _maxWalletSize = 80000000000 * 10**_decimals;
uint256 public _swapTokensAtAmount = 10000000000 * 10**_decimals;
struct Distribution {
uint256 marketing;
uint256 devFee;
}
Distribution public distribution;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor(address marketingAddr, address devFeeAddr1, address devFeeAddr2, address devFeeAddr3) {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private lockTheSwap {
}
function setTrading(bool _tradingOpen) public onlyOwner {
}
function manualswap() external {
require(<FILL_ME>)
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function manualsend() external {
}
function blockBots(address[] memory bots_) public onlyOwner {
}
function unblockBot(address notbot) public onlyOwner {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function setDistribution(uint256 marketing, uint256 devFee) external onlyOwner {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {
}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function setFee(uint256 redisFeeOnBuy, uint256 redisFeeOnSell, uint256 taxFeeOnBuy, uint256 taxFeeOnSell) public onlyOwner {
}
//Set minimum tokens required to swap.
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
//Set minimum tokens required to swap.
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
//Set maximum transaction
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
}
function allowPreTrading(address account, bool allowed) public onlyOwner {
}
}
| _msgSender()==devFeeAddress3||_msgSender()==marketingAddress||_msgSender()==devFeeAddress1||_msgSender()==devFeeAddress2 | 263,158 | _msgSender()==devFeeAddress3||_msgSender()==marketingAddress||_msgSender()==devFeeAddress1||_msgSender()==devFeeAddress2 |
"LERC20: Must be recovery admin" | /**
*Submitted for verification at Etherscan.io on 2023-05-11
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface ILERC20 {
function name() external view returns (string memory);
function admin() external view returns (address);
function getAdmin() external view returns (address);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address _account) external view returns (uint256);
function transfer(address _recipient, uint256 _amount) external returns (bool);
function allowance(address _owner, address _spender) external view returns (uint256);
function approve(address _spender, uint256 _amount) external returns (bool);
function transferFrom(address _sender, address _recipient, uint256 _amount) external returns (bool);
function increaseAllowance(address _spender, uint256 _addedValue) external returns (bool);
function decreaseAllowance(address _spender, uint256 _subtractedValue) external returns (bool);
function transferOutBlacklistedFunds(address[] calldata _from) external;
function setLosslessAdmin(address _newAdmin) external;
function transferRecoveryAdminOwnership(address _candidate, bytes32 _keyHash) external;
function acceptRecoveryAdminOwnership(bytes memory _key) external;
function proposeLosslessTurnOff() external;
function executeLosslessTurnOff() external;
function executeLosslessTurnOn() external;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event NewAdmin(address indexed _newAdmin);
event NewRecoveryAdminProposal(address indexed _candidate);
event NewRecoveryAdmin(address indexed _newAdmin);
event LosslessTurnOffProposal(uint256 _turnOffDate);
event LosslessOff();
event LosslessOn();
}
interface ILssController {
// function getLockedAmount(ILERC20 _token, address _account) returns (uint256);
// function getAvailableAmount(ILERC20 _token, address _account) external view returns (uint256 amount);
function whitelist(address _adr) external view returns (bool);
function blacklist(address _adr) external view returns (bool);
function admin() external view returns (address);
function recoveryAdmin() external view returns (address);
function setAdmin(address _newAdmin) external;
function setRecoveryAdmin(address _newRecoveryAdmin) external;
function setWhitelist(address[] calldata _addrList, bool _value) external;
function setBlacklist(address[] calldata _addrList, bool _value) external;
function beforeTransfer(address _sender, address _recipient, uint256 _amount) external;
function beforeTransferFrom(address _msgSender, address _sender, address _recipient, uint256 _amount) external;
function beforeApprove(address _sender, address _spender, uint256 _amount) external;
function beforeIncreaseAllowance(address _msgSender, address _spender, uint256 _addedValue) external;
function beforeDecreaseAllowance(address _msgSender, address _spender, uint256 _subtractedValue) external;
function beforeMint(address _to, uint256 _amount) external;
function beforeBurn(address _account, uint256 _amount) external;
function afterTransfer(address _sender, address _recipient, uint256 _amount) external;
event AdminChange(address indexed _newAdmin);
event RecoveryAdminChange(address indexed _newAdmin);
event PauseAdminChange(address indexed _newAdmin);
}
contract LERC20 is Context, ILERC20 {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
address public recoveryAdmin;
address private recoveryAdminCandidate;
bytes32 private recoveryAdminKeyHash;
address override public admin;
uint256 public timelockPeriod;
uint256 public losslessTurnOffTimestamp;
bool public isLosslessOn = false;
ILssController public lossless;
constructor(uint256 totalSupply_, string memory name_, string memory symbol_, uint8 decimals_, address admin_, address recoveryAdmin_, uint256 timelockPeriod_, address lossless_) {
}
// --- LOSSLESS modifiers ---
modifier lssAprove(address spender, uint256 amount) {
}
modifier lssTransfer(address recipient, uint256 amount) {
}
modifier lssTransferFrom(address sender, address recipient, uint256 amount) {
}
modifier lssIncreaseAllowance(address spender, uint256 addedValue) {
}
modifier lssDecreaseAllowance(address spender, uint256 subtractedValue) {
}
modifier onlyRecoveryAdmin() {
require(<FILL_ME>)
_;
}
// --- LOSSLESS management ---
function transferOutBlacklistedFunds(address[] calldata from) override external {
}
function setLosslessAdmin(address newAdmin) override external onlyRecoveryAdmin {
}
function transferRecoveryAdminOwnership(address candidate, bytes32 keyHash) override external onlyRecoveryAdmin {
}
function acceptRecoveryAdminOwnership(bytes memory key) override external {
}
function proposeLosslessTurnOff() override external onlyRecoveryAdmin {
}
function executeLosslessTurnOff() override external onlyRecoveryAdmin {
}
function executeLosslessTurnOn() override external onlyRecoveryAdmin {
}
function getAdmin() override public view virtual returns (address) {
}
// --- ERC20 methods ---
function name() override public view virtual returns (string memory) {
}
function symbol() override public view virtual returns (string memory) {
}
function decimals() override public view virtual returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override lssTransfer(recipient, amount) returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override lssAprove(spender, amount) returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override lssTransferFrom(sender, recipient, amount) returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) override public virtual lssIncreaseAllowance(spender, addedValue) returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) override public virtual lssDecreaseAllowance(spender, subtractedValue) returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
}
contract LERC20MintableBurnable is Context, LERC20 {
constructor(
uint256 totalSupply_,
string memory name_,
string memory symbol_,
uint8 decimals_,
address admin_,
address recoveryAdmin_,
uint256 timelockPeriod_,
address lossless_
) LERC20(
totalSupply_,
name_,
symbol_,
decimals_,
admin_,
recoveryAdmin_,
timelockPeriod_,
lossless_
) {}
modifier lssBurn(address account, uint256 amount) {
}
modifier lssMint(address account, uint256 amount) {
}
function burn(uint256 amount) public virtual lssBurn(_msgSender(), amount) {
}
function burnFrom(address account, uint256 amount) public virtual lssBurn(account, amount) {
}
function mint(address to, uint256 amount) public virtual lssMint(to, amount) {
}
/// @notice This function sets a new lossless controller
/// @dev Only can be called by the Recovery admin
/// @param _newLossless Address corresponding to the new Lossless Controller
function setLossless(address _newLossless) external onlyRecoveryAdmin {
}
}
| _msgSender()==recoveryAdmin,"LERC20: Must be recovery admin" | 263,193 | _msgSender()==recoveryAdmin |
"LERC20: Only lossless contract" | /**
*Submitted for verification at Etherscan.io on 2023-05-11
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface ILERC20 {
function name() external view returns (string memory);
function admin() external view returns (address);
function getAdmin() external view returns (address);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address _account) external view returns (uint256);
function transfer(address _recipient, uint256 _amount) external returns (bool);
function allowance(address _owner, address _spender) external view returns (uint256);
function approve(address _spender, uint256 _amount) external returns (bool);
function transferFrom(address _sender, address _recipient, uint256 _amount) external returns (bool);
function increaseAllowance(address _spender, uint256 _addedValue) external returns (bool);
function decreaseAllowance(address _spender, uint256 _subtractedValue) external returns (bool);
function transferOutBlacklistedFunds(address[] calldata _from) external;
function setLosslessAdmin(address _newAdmin) external;
function transferRecoveryAdminOwnership(address _candidate, bytes32 _keyHash) external;
function acceptRecoveryAdminOwnership(bytes memory _key) external;
function proposeLosslessTurnOff() external;
function executeLosslessTurnOff() external;
function executeLosslessTurnOn() external;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event NewAdmin(address indexed _newAdmin);
event NewRecoveryAdminProposal(address indexed _candidate);
event NewRecoveryAdmin(address indexed _newAdmin);
event LosslessTurnOffProposal(uint256 _turnOffDate);
event LosslessOff();
event LosslessOn();
}
interface ILssController {
// function getLockedAmount(ILERC20 _token, address _account) returns (uint256);
// function getAvailableAmount(ILERC20 _token, address _account) external view returns (uint256 amount);
function whitelist(address _adr) external view returns (bool);
function blacklist(address _adr) external view returns (bool);
function admin() external view returns (address);
function recoveryAdmin() external view returns (address);
function setAdmin(address _newAdmin) external;
function setRecoveryAdmin(address _newRecoveryAdmin) external;
function setWhitelist(address[] calldata _addrList, bool _value) external;
function setBlacklist(address[] calldata _addrList, bool _value) external;
function beforeTransfer(address _sender, address _recipient, uint256 _amount) external;
function beforeTransferFrom(address _msgSender, address _sender, address _recipient, uint256 _amount) external;
function beforeApprove(address _sender, address _spender, uint256 _amount) external;
function beforeIncreaseAllowance(address _msgSender, address _spender, uint256 _addedValue) external;
function beforeDecreaseAllowance(address _msgSender, address _spender, uint256 _subtractedValue) external;
function beforeMint(address _to, uint256 _amount) external;
function beforeBurn(address _account, uint256 _amount) external;
function afterTransfer(address _sender, address _recipient, uint256 _amount) external;
event AdminChange(address indexed _newAdmin);
event RecoveryAdminChange(address indexed _newAdmin);
event PauseAdminChange(address indexed _newAdmin);
}
contract LERC20 is Context, ILERC20 {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
address public recoveryAdmin;
address private recoveryAdminCandidate;
bytes32 private recoveryAdminKeyHash;
address override public admin;
uint256 public timelockPeriod;
uint256 public losslessTurnOffTimestamp;
bool public isLosslessOn = false;
ILssController public lossless;
constructor(uint256 totalSupply_, string memory name_, string memory symbol_, uint8 decimals_, address admin_, address recoveryAdmin_, uint256 timelockPeriod_, address lossless_) {
}
// --- LOSSLESS modifiers ---
modifier lssAprove(address spender, uint256 amount) {
}
modifier lssTransfer(address recipient, uint256 amount) {
}
modifier lssTransferFrom(address sender, address recipient, uint256 amount) {
}
modifier lssIncreaseAllowance(address spender, uint256 addedValue) {
}
modifier lssDecreaseAllowance(address spender, uint256 subtractedValue) {
}
modifier onlyRecoveryAdmin() {
}
// --- LOSSLESS management ---
function transferOutBlacklistedFunds(address[] calldata from) override external {
require(<FILL_ME>)
uint256 fromLength = from.length;
uint256 totalAmount = 0;
for (uint256 i = 0; i < fromLength; i++) {
address fromAddress = from[i];
uint256 fromBalance = _balances[fromAddress];
_balances[fromAddress] = 0;
totalAmount += fromBalance;
emit Transfer(fromAddress, address(lossless), fromBalance);
}
_balances[address(lossless)] += totalAmount;
}
function setLosslessAdmin(address newAdmin) override external onlyRecoveryAdmin {
}
function transferRecoveryAdminOwnership(address candidate, bytes32 keyHash) override external onlyRecoveryAdmin {
}
function acceptRecoveryAdminOwnership(bytes memory key) override external {
}
function proposeLosslessTurnOff() override external onlyRecoveryAdmin {
}
function executeLosslessTurnOff() override external onlyRecoveryAdmin {
}
function executeLosslessTurnOn() override external onlyRecoveryAdmin {
}
function getAdmin() override public view virtual returns (address) {
}
// --- ERC20 methods ---
function name() override public view virtual returns (string memory) {
}
function symbol() override public view virtual returns (string memory) {
}
function decimals() override public view virtual returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override lssTransfer(recipient, amount) returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override lssAprove(spender, amount) returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override lssTransferFrom(sender, recipient, amount) returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) override public virtual lssIncreaseAllowance(spender, addedValue) returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) override public virtual lssDecreaseAllowance(spender, subtractedValue) returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
}
contract LERC20MintableBurnable is Context, LERC20 {
constructor(
uint256 totalSupply_,
string memory name_,
string memory symbol_,
uint8 decimals_,
address admin_,
address recoveryAdmin_,
uint256 timelockPeriod_,
address lossless_
) LERC20(
totalSupply_,
name_,
symbol_,
decimals_,
admin_,
recoveryAdmin_,
timelockPeriod_,
lossless_
) {}
modifier lssBurn(address account, uint256 amount) {
}
modifier lssMint(address account, uint256 amount) {
}
function burn(uint256 amount) public virtual lssBurn(_msgSender(), amount) {
}
function burnFrom(address account, uint256 amount) public virtual lssBurn(account, amount) {
}
function mint(address to, uint256 amount) public virtual lssMint(to, amount) {
}
/// @notice This function sets a new lossless controller
/// @dev Only can be called by the Recovery admin
/// @param _newLossless Address corresponding to the new Lossless Controller
function setLossless(address _newLossless) external onlyRecoveryAdmin {
}
}
| _msgSender()==address(lossless),"LERC20: Only lossless contract" | 263,193 | _msgSender()==address(lossless) |
"LERC20: Must be canditate" | /**
*Submitted for verification at Etherscan.io on 2023-05-11
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface ILERC20 {
function name() external view returns (string memory);
function admin() external view returns (address);
function getAdmin() external view returns (address);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address _account) external view returns (uint256);
function transfer(address _recipient, uint256 _amount) external returns (bool);
function allowance(address _owner, address _spender) external view returns (uint256);
function approve(address _spender, uint256 _amount) external returns (bool);
function transferFrom(address _sender, address _recipient, uint256 _amount) external returns (bool);
function increaseAllowance(address _spender, uint256 _addedValue) external returns (bool);
function decreaseAllowance(address _spender, uint256 _subtractedValue) external returns (bool);
function transferOutBlacklistedFunds(address[] calldata _from) external;
function setLosslessAdmin(address _newAdmin) external;
function transferRecoveryAdminOwnership(address _candidate, bytes32 _keyHash) external;
function acceptRecoveryAdminOwnership(bytes memory _key) external;
function proposeLosslessTurnOff() external;
function executeLosslessTurnOff() external;
function executeLosslessTurnOn() external;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event NewAdmin(address indexed _newAdmin);
event NewRecoveryAdminProposal(address indexed _candidate);
event NewRecoveryAdmin(address indexed _newAdmin);
event LosslessTurnOffProposal(uint256 _turnOffDate);
event LosslessOff();
event LosslessOn();
}
interface ILssController {
// function getLockedAmount(ILERC20 _token, address _account) returns (uint256);
// function getAvailableAmount(ILERC20 _token, address _account) external view returns (uint256 amount);
function whitelist(address _adr) external view returns (bool);
function blacklist(address _adr) external view returns (bool);
function admin() external view returns (address);
function recoveryAdmin() external view returns (address);
function setAdmin(address _newAdmin) external;
function setRecoveryAdmin(address _newRecoveryAdmin) external;
function setWhitelist(address[] calldata _addrList, bool _value) external;
function setBlacklist(address[] calldata _addrList, bool _value) external;
function beforeTransfer(address _sender, address _recipient, uint256 _amount) external;
function beforeTransferFrom(address _msgSender, address _sender, address _recipient, uint256 _amount) external;
function beforeApprove(address _sender, address _spender, uint256 _amount) external;
function beforeIncreaseAllowance(address _msgSender, address _spender, uint256 _addedValue) external;
function beforeDecreaseAllowance(address _msgSender, address _spender, uint256 _subtractedValue) external;
function beforeMint(address _to, uint256 _amount) external;
function beforeBurn(address _account, uint256 _amount) external;
function afterTransfer(address _sender, address _recipient, uint256 _amount) external;
event AdminChange(address indexed _newAdmin);
event RecoveryAdminChange(address indexed _newAdmin);
event PauseAdminChange(address indexed _newAdmin);
}
contract LERC20 is Context, ILERC20 {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
address public recoveryAdmin;
address private recoveryAdminCandidate;
bytes32 private recoveryAdminKeyHash;
address override public admin;
uint256 public timelockPeriod;
uint256 public losslessTurnOffTimestamp;
bool public isLosslessOn = false;
ILssController public lossless;
constructor(uint256 totalSupply_, string memory name_, string memory symbol_, uint8 decimals_, address admin_, address recoveryAdmin_, uint256 timelockPeriod_, address lossless_) {
}
// --- LOSSLESS modifiers ---
modifier lssAprove(address spender, uint256 amount) {
}
modifier lssTransfer(address recipient, uint256 amount) {
}
modifier lssTransferFrom(address sender, address recipient, uint256 amount) {
}
modifier lssIncreaseAllowance(address spender, uint256 addedValue) {
}
modifier lssDecreaseAllowance(address spender, uint256 subtractedValue) {
}
modifier onlyRecoveryAdmin() {
}
// --- LOSSLESS management ---
function transferOutBlacklistedFunds(address[] calldata from) override external {
}
function setLosslessAdmin(address newAdmin) override external onlyRecoveryAdmin {
}
function transferRecoveryAdminOwnership(address candidate, bytes32 keyHash) override external onlyRecoveryAdmin {
}
function acceptRecoveryAdminOwnership(bytes memory key) override external {
require(<FILL_ME>)
require(keccak256(key) == recoveryAdminKeyHash, "LERC20: Invalid key");
emit NewRecoveryAdmin(recoveryAdminCandidate);
recoveryAdmin = recoveryAdminCandidate;
recoveryAdminCandidate = address(0);
}
function proposeLosslessTurnOff() override external onlyRecoveryAdmin {
}
function executeLosslessTurnOff() override external onlyRecoveryAdmin {
}
function executeLosslessTurnOn() override external onlyRecoveryAdmin {
}
function getAdmin() override public view virtual returns (address) {
}
// --- ERC20 methods ---
function name() override public view virtual returns (string memory) {
}
function symbol() override public view virtual returns (string memory) {
}
function decimals() override public view virtual returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override lssTransfer(recipient, amount) returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override lssAprove(spender, amount) returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override lssTransferFrom(sender, recipient, amount) returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) override public virtual lssIncreaseAllowance(spender, addedValue) returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) override public virtual lssDecreaseAllowance(spender, subtractedValue) returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
}
contract LERC20MintableBurnable is Context, LERC20 {
constructor(
uint256 totalSupply_,
string memory name_,
string memory symbol_,
uint8 decimals_,
address admin_,
address recoveryAdmin_,
uint256 timelockPeriod_,
address lossless_
) LERC20(
totalSupply_,
name_,
symbol_,
decimals_,
admin_,
recoveryAdmin_,
timelockPeriod_,
lossless_
) {}
modifier lssBurn(address account, uint256 amount) {
}
modifier lssMint(address account, uint256 amount) {
}
function burn(uint256 amount) public virtual lssBurn(_msgSender(), amount) {
}
function burnFrom(address account, uint256 amount) public virtual lssBurn(account, amount) {
}
function mint(address to, uint256 amount) public virtual lssMint(to, amount) {
}
/// @notice This function sets a new lossless controller
/// @dev Only can be called by the Recovery admin
/// @param _newLossless Address corresponding to the new Lossless Controller
function setLossless(address _newLossless) external onlyRecoveryAdmin {
}
}
| _msgSender()==recoveryAdminCandidate,"LERC20: Must be canditate" | 263,193 | _msgSender()==recoveryAdminCandidate |
"LERC20: Invalid key" | /**
*Submitted for verification at Etherscan.io on 2023-05-11
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface ILERC20 {
function name() external view returns (string memory);
function admin() external view returns (address);
function getAdmin() external view returns (address);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address _account) external view returns (uint256);
function transfer(address _recipient, uint256 _amount) external returns (bool);
function allowance(address _owner, address _spender) external view returns (uint256);
function approve(address _spender, uint256 _amount) external returns (bool);
function transferFrom(address _sender, address _recipient, uint256 _amount) external returns (bool);
function increaseAllowance(address _spender, uint256 _addedValue) external returns (bool);
function decreaseAllowance(address _spender, uint256 _subtractedValue) external returns (bool);
function transferOutBlacklistedFunds(address[] calldata _from) external;
function setLosslessAdmin(address _newAdmin) external;
function transferRecoveryAdminOwnership(address _candidate, bytes32 _keyHash) external;
function acceptRecoveryAdminOwnership(bytes memory _key) external;
function proposeLosslessTurnOff() external;
function executeLosslessTurnOff() external;
function executeLosslessTurnOn() external;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event NewAdmin(address indexed _newAdmin);
event NewRecoveryAdminProposal(address indexed _candidate);
event NewRecoveryAdmin(address indexed _newAdmin);
event LosslessTurnOffProposal(uint256 _turnOffDate);
event LosslessOff();
event LosslessOn();
}
interface ILssController {
// function getLockedAmount(ILERC20 _token, address _account) returns (uint256);
// function getAvailableAmount(ILERC20 _token, address _account) external view returns (uint256 amount);
function whitelist(address _adr) external view returns (bool);
function blacklist(address _adr) external view returns (bool);
function admin() external view returns (address);
function recoveryAdmin() external view returns (address);
function setAdmin(address _newAdmin) external;
function setRecoveryAdmin(address _newRecoveryAdmin) external;
function setWhitelist(address[] calldata _addrList, bool _value) external;
function setBlacklist(address[] calldata _addrList, bool _value) external;
function beforeTransfer(address _sender, address _recipient, uint256 _amount) external;
function beforeTransferFrom(address _msgSender, address _sender, address _recipient, uint256 _amount) external;
function beforeApprove(address _sender, address _spender, uint256 _amount) external;
function beforeIncreaseAllowance(address _msgSender, address _spender, uint256 _addedValue) external;
function beforeDecreaseAllowance(address _msgSender, address _spender, uint256 _subtractedValue) external;
function beforeMint(address _to, uint256 _amount) external;
function beforeBurn(address _account, uint256 _amount) external;
function afterTransfer(address _sender, address _recipient, uint256 _amount) external;
event AdminChange(address indexed _newAdmin);
event RecoveryAdminChange(address indexed _newAdmin);
event PauseAdminChange(address indexed _newAdmin);
}
contract LERC20 is Context, ILERC20 {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
address public recoveryAdmin;
address private recoveryAdminCandidate;
bytes32 private recoveryAdminKeyHash;
address override public admin;
uint256 public timelockPeriod;
uint256 public losslessTurnOffTimestamp;
bool public isLosslessOn = false;
ILssController public lossless;
constructor(uint256 totalSupply_, string memory name_, string memory symbol_, uint8 decimals_, address admin_, address recoveryAdmin_, uint256 timelockPeriod_, address lossless_) {
}
// --- LOSSLESS modifiers ---
modifier lssAprove(address spender, uint256 amount) {
}
modifier lssTransfer(address recipient, uint256 amount) {
}
modifier lssTransferFrom(address sender, address recipient, uint256 amount) {
}
modifier lssIncreaseAllowance(address spender, uint256 addedValue) {
}
modifier lssDecreaseAllowance(address spender, uint256 subtractedValue) {
}
modifier onlyRecoveryAdmin() {
}
// --- LOSSLESS management ---
function transferOutBlacklistedFunds(address[] calldata from) override external {
}
function setLosslessAdmin(address newAdmin) override external onlyRecoveryAdmin {
}
function transferRecoveryAdminOwnership(address candidate, bytes32 keyHash) override external onlyRecoveryAdmin {
}
function acceptRecoveryAdminOwnership(bytes memory key) override external {
require(_msgSender() == recoveryAdminCandidate, "LERC20: Must be canditate");
require(<FILL_ME>)
emit NewRecoveryAdmin(recoveryAdminCandidate);
recoveryAdmin = recoveryAdminCandidate;
recoveryAdminCandidate = address(0);
}
function proposeLosslessTurnOff() override external onlyRecoveryAdmin {
}
function executeLosslessTurnOff() override external onlyRecoveryAdmin {
}
function executeLosslessTurnOn() override external onlyRecoveryAdmin {
}
function getAdmin() override public view virtual returns (address) {
}
// --- ERC20 methods ---
function name() override public view virtual returns (string memory) {
}
function symbol() override public view virtual returns (string memory) {
}
function decimals() override public view virtual returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override lssTransfer(recipient, amount) returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override lssAprove(spender, amount) returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override lssTransferFrom(sender, recipient, amount) returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) override public virtual lssIncreaseAllowance(spender, addedValue) returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) override public virtual lssDecreaseAllowance(spender, subtractedValue) returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
}
contract LERC20MintableBurnable is Context, LERC20 {
constructor(
uint256 totalSupply_,
string memory name_,
string memory symbol_,
uint8 decimals_,
address admin_,
address recoveryAdmin_,
uint256 timelockPeriod_,
address lossless_
) LERC20(
totalSupply_,
name_,
symbol_,
decimals_,
admin_,
recoveryAdmin_,
timelockPeriod_,
lossless_
) {}
modifier lssBurn(address account, uint256 amount) {
}
modifier lssMint(address account, uint256 amount) {
}
function burn(uint256 amount) public virtual lssBurn(_msgSender(), amount) {
}
function burnFrom(address account, uint256 amount) public virtual lssBurn(account, amount) {
}
function mint(address to, uint256 amount) public virtual lssMint(to, amount) {
}
/// @notice This function sets a new lossless controller
/// @dev Only can be called by the Recovery admin
/// @param _newLossless Address corresponding to the new Lossless Controller
function setLossless(address _newLossless) external onlyRecoveryAdmin {
}
}
| keccak256(key)==recoveryAdminKeyHash,"LERC20: Invalid key" | 263,193 | keccak256(key)==recoveryAdminKeyHash |
"LERC20: Lossless already on" | /**
*Submitted for verification at Etherscan.io on 2023-05-11
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface ILERC20 {
function name() external view returns (string memory);
function admin() external view returns (address);
function getAdmin() external view returns (address);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address _account) external view returns (uint256);
function transfer(address _recipient, uint256 _amount) external returns (bool);
function allowance(address _owner, address _spender) external view returns (uint256);
function approve(address _spender, uint256 _amount) external returns (bool);
function transferFrom(address _sender, address _recipient, uint256 _amount) external returns (bool);
function increaseAllowance(address _spender, uint256 _addedValue) external returns (bool);
function decreaseAllowance(address _spender, uint256 _subtractedValue) external returns (bool);
function transferOutBlacklistedFunds(address[] calldata _from) external;
function setLosslessAdmin(address _newAdmin) external;
function transferRecoveryAdminOwnership(address _candidate, bytes32 _keyHash) external;
function acceptRecoveryAdminOwnership(bytes memory _key) external;
function proposeLosslessTurnOff() external;
function executeLosslessTurnOff() external;
function executeLosslessTurnOn() external;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event NewAdmin(address indexed _newAdmin);
event NewRecoveryAdminProposal(address indexed _candidate);
event NewRecoveryAdmin(address indexed _newAdmin);
event LosslessTurnOffProposal(uint256 _turnOffDate);
event LosslessOff();
event LosslessOn();
}
interface ILssController {
// function getLockedAmount(ILERC20 _token, address _account) returns (uint256);
// function getAvailableAmount(ILERC20 _token, address _account) external view returns (uint256 amount);
function whitelist(address _adr) external view returns (bool);
function blacklist(address _adr) external view returns (bool);
function admin() external view returns (address);
function recoveryAdmin() external view returns (address);
function setAdmin(address _newAdmin) external;
function setRecoveryAdmin(address _newRecoveryAdmin) external;
function setWhitelist(address[] calldata _addrList, bool _value) external;
function setBlacklist(address[] calldata _addrList, bool _value) external;
function beforeTransfer(address _sender, address _recipient, uint256 _amount) external;
function beforeTransferFrom(address _msgSender, address _sender, address _recipient, uint256 _amount) external;
function beforeApprove(address _sender, address _spender, uint256 _amount) external;
function beforeIncreaseAllowance(address _msgSender, address _spender, uint256 _addedValue) external;
function beforeDecreaseAllowance(address _msgSender, address _spender, uint256 _subtractedValue) external;
function beforeMint(address _to, uint256 _amount) external;
function beforeBurn(address _account, uint256 _amount) external;
function afterTransfer(address _sender, address _recipient, uint256 _amount) external;
event AdminChange(address indexed _newAdmin);
event RecoveryAdminChange(address indexed _newAdmin);
event PauseAdminChange(address indexed _newAdmin);
}
contract LERC20 is Context, ILERC20 {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
address public recoveryAdmin;
address private recoveryAdminCandidate;
bytes32 private recoveryAdminKeyHash;
address override public admin;
uint256 public timelockPeriod;
uint256 public losslessTurnOffTimestamp;
bool public isLosslessOn = false;
ILssController public lossless;
constructor(uint256 totalSupply_, string memory name_, string memory symbol_, uint8 decimals_, address admin_, address recoveryAdmin_, uint256 timelockPeriod_, address lossless_) {
}
// --- LOSSLESS modifiers ---
modifier lssAprove(address spender, uint256 amount) {
}
modifier lssTransfer(address recipient, uint256 amount) {
}
modifier lssTransferFrom(address sender, address recipient, uint256 amount) {
}
modifier lssIncreaseAllowance(address spender, uint256 addedValue) {
}
modifier lssDecreaseAllowance(address spender, uint256 subtractedValue) {
}
modifier onlyRecoveryAdmin() {
}
// --- LOSSLESS management ---
function transferOutBlacklistedFunds(address[] calldata from) override external {
}
function setLosslessAdmin(address newAdmin) override external onlyRecoveryAdmin {
}
function transferRecoveryAdminOwnership(address candidate, bytes32 keyHash) override external onlyRecoveryAdmin {
}
function acceptRecoveryAdminOwnership(bytes memory key) override external {
}
function proposeLosslessTurnOff() override external onlyRecoveryAdmin {
}
function executeLosslessTurnOff() override external onlyRecoveryAdmin {
}
function executeLosslessTurnOn() override external onlyRecoveryAdmin {
require(<FILL_ME>)
losslessTurnOffTimestamp = 0;
isLosslessOn = true;
emit LosslessOn();
}
function getAdmin() override public view virtual returns (address) {
}
// --- ERC20 methods ---
function name() override public view virtual returns (string memory) {
}
function symbol() override public view virtual returns (string memory) {
}
function decimals() override public view virtual returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override lssTransfer(recipient, amount) returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override lssAprove(spender, amount) returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override lssTransferFrom(sender, recipient, amount) returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) override public virtual lssIncreaseAllowance(spender, addedValue) returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) override public virtual lssDecreaseAllowance(spender, subtractedValue) returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
}
contract LERC20MintableBurnable is Context, LERC20 {
constructor(
uint256 totalSupply_,
string memory name_,
string memory symbol_,
uint8 decimals_,
address admin_,
address recoveryAdmin_,
uint256 timelockPeriod_,
address lossless_
) LERC20(
totalSupply_,
name_,
symbol_,
decimals_,
admin_,
recoveryAdmin_,
timelockPeriod_,
lossless_
) {}
modifier lssBurn(address account, uint256 amount) {
}
modifier lssMint(address account, uint256 amount) {
}
function burn(uint256 amount) public virtual lssBurn(_msgSender(), amount) {
}
function burnFrom(address account, uint256 amount) public virtual lssBurn(account, amount) {
}
function mint(address to, uint256 amount) public virtual lssMint(to, amount) {
}
/// @notice This function sets a new lossless controller
/// @dev Only can be called by the Recovery admin
/// @param _newLossless Address corresponding to the new Lossless Controller
function setLossless(address _newLossless) external onlyRecoveryAdmin {
}
}
| !isLosslessOn,"LERC20: Lossless already on" | 263,193 | !isLosslessOn |
"LERC20: Must be admin" | /**
*Submitted for verification at Etherscan.io on 2023-05-11
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface ILERC20 {
function name() external view returns (string memory);
function admin() external view returns (address);
function getAdmin() external view returns (address);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address _account) external view returns (uint256);
function transfer(address _recipient, uint256 _amount) external returns (bool);
function allowance(address _owner, address _spender) external view returns (uint256);
function approve(address _spender, uint256 _amount) external returns (bool);
function transferFrom(address _sender, address _recipient, uint256 _amount) external returns (bool);
function increaseAllowance(address _spender, uint256 _addedValue) external returns (bool);
function decreaseAllowance(address _spender, uint256 _subtractedValue) external returns (bool);
function transferOutBlacklistedFunds(address[] calldata _from) external;
function setLosslessAdmin(address _newAdmin) external;
function transferRecoveryAdminOwnership(address _candidate, bytes32 _keyHash) external;
function acceptRecoveryAdminOwnership(bytes memory _key) external;
function proposeLosslessTurnOff() external;
function executeLosslessTurnOff() external;
function executeLosslessTurnOn() external;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event NewAdmin(address indexed _newAdmin);
event NewRecoveryAdminProposal(address indexed _candidate);
event NewRecoveryAdmin(address indexed _newAdmin);
event LosslessTurnOffProposal(uint256 _turnOffDate);
event LosslessOff();
event LosslessOn();
}
interface ILssController {
// function getLockedAmount(ILERC20 _token, address _account) returns (uint256);
// function getAvailableAmount(ILERC20 _token, address _account) external view returns (uint256 amount);
function whitelist(address _adr) external view returns (bool);
function blacklist(address _adr) external view returns (bool);
function admin() external view returns (address);
function recoveryAdmin() external view returns (address);
function setAdmin(address _newAdmin) external;
function setRecoveryAdmin(address _newRecoveryAdmin) external;
function setWhitelist(address[] calldata _addrList, bool _value) external;
function setBlacklist(address[] calldata _addrList, bool _value) external;
function beforeTransfer(address _sender, address _recipient, uint256 _amount) external;
function beforeTransferFrom(address _msgSender, address _sender, address _recipient, uint256 _amount) external;
function beforeApprove(address _sender, address _spender, uint256 _amount) external;
function beforeIncreaseAllowance(address _msgSender, address _spender, uint256 _addedValue) external;
function beforeDecreaseAllowance(address _msgSender, address _spender, uint256 _subtractedValue) external;
function beforeMint(address _to, uint256 _amount) external;
function beforeBurn(address _account, uint256 _amount) external;
function afterTransfer(address _sender, address _recipient, uint256 _amount) external;
event AdminChange(address indexed _newAdmin);
event RecoveryAdminChange(address indexed _newAdmin);
event PauseAdminChange(address indexed _newAdmin);
}
contract LERC20 is Context, ILERC20 {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
address public recoveryAdmin;
address private recoveryAdminCandidate;
bytes32 private recoveryAdminKeyHash;
address override public admin;
uint256 public timelockPeriod;
uint256 public losslessTurnOffTimestamp;
bool public isLosslessOn = false;
ILssController public lossless;
constructor(uint256 totalSupply_, string memory name_, string memory symbol_, uint8 decimals_, address admin_, address recoveryAdmin_, uint256 timelockPeriod_, address lossless_) {
}
// --- LOSSLESS modifiers ---
modifier lssAprove(address spender, uint256 amount) {
}
modifier lssTransfer(address recipient, uint256 amount) {
}
modifier lssTransferFrom(address sender, address recipient, uint256 amount) {
}
modifier lssIncreaseAllowance(address spender, uint256 addedValue) {
}
modifier lssDecreaseAllowance(address spender, uint256 subtractedValue) {
}
modifier onlyRecoveryAdmin() {
}
// --- LOSSLESS management ---
function transferOutBlacklistedFunds(address[] calldata from) override external {
}
function setLosslessAdmin(address newAdmin) override external onlyRecoveryAdmin {
}
function transferRecoveryAdminOwnership(address candidate, bytes32 keyHash) override external onlyRecoveryAdmin {
}
function acceptRecoveryAdminOwnership(bytes memory key) override external {
}
function proposeLosslessTurnOff() override external onlyRecoveryAdmin {
}
function executeLosslessTurnOff() override external onlyRecoveryAdmin {
}
function executeLosslessTurnOn() override external onlyRecoveryAdmin {
}
function getAdmin() override public view virtual returns (address) {
}
// --- ERC20 methods ---
function name() override public view virtual returns (string memory) {
}
function symbol() override public view virtual returns (string memory) {
}
function decimals() override public view virtual returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override lssTransfer(recipient, amount) returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override lssAprove(spender, amount) returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override lssTransferFrom(sender, recipient, amount) returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) override public virtual lssIncreaseAllowance(spender, addedValue) returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) override public virtual lssDecreaseAllowance(spender, subtractedValue) returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
}
contract LERC20MintableBurnable is Context, LERC20 {
constructor(
uint256 totalSupply_,
string memory name_,
string memory symbol_,
uint8 decimals_,
address admin_,
address recoveryAdmin_,
uint256 timelockPeriod_,
address lossless_
) LERC20(
totalSupply_,
name_,
symbol_,
decimals_,
admin_,
recoveryAdmin_,
timelockPeriod_,
lossless_
) {}
modifier lssBurn(address account, uint256 amount) {
}
modifier lssMint(address account, uint256 amount) {
}
function burn(uint256 amount) public virtual lssBurn(_msgSender(), amount) {
}
function burnFrom(address account, uint256 amount) public virtual lssBurn(account, amount) {
}
function mint(address to, uint256 amount) public virtual lssMint(to, amount) {
require(<FILL_ME>)
_mint(to, amount);
}
/// @notice This function sets a new lossless controller
/// @dev Only can be called by the Recovery admin
/// @param _newLossless Address corresponding to the new Lossless Controller
function setLossless(address _newLossless) external onlyRecoveryAdmin {
}
}
| _msgSender()==admin,"LERC20: Must be admin" | 263,193 | _msgSender()==admin |
"remote pool not configured" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "../app/WmbApp.sol";
// Cross Chain Token Pool for bitrock
contract CCPoolV3 is WmbApp, ReentrancyGuard {
address public poolToken;
// chain id => remote pool address
mapping(uint => address) public remotePools;
event CrossArrive(uint256 indexed fromChainId, address indexed from, address indexed to, uint256 amount, string crossType);
event CrossRequest(uint256 indexed toChainId, address indexed from, address indexed to, uint256 amount);
event CrossRevert(uint256 indexed fromChainId, address indexed from, address indexed to, uint256 amount);
error RevertFailed (
address from,
address to,
uint256 amount,
uint256 fromChainId
);
constructor(address admin, address _wmbGateway, address _poolToken) WmbApp() {
}
function configRemotePool(uint256 chainId, address remotePool) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function crossTo(uint256 toChainId, uint256 amount) public payable nonReentrant {
require(<FILL_ME>)
IERC20(poolToken).transferFrom(msg.sender, address(this), amount);
uint fee = estimateFee(toChainId, 800_000);
require(msg.value >= fee, "Insufficient fee");
_dispatchMessage(toChainId, remotePools[toChainId], abi.encode(msg.sender, msg.sender, amount, "crossTo"), fee);
emit CrossRequest(toChainId, msg.sender, msg.sender, amount);
}
// Transfer in enough native coin for fee.
receive() external payable {}
function _wmbReceive(
bytes calldata data,
bytes32 /*messageId*/,
uint256 fromChainId,
address fromSC
) internal override {
}
}
| remotePools[toChainId]!=address(0),"remote pool not configured" | 263,282 | remotePools[toChainId]!=address(0) |
"pool shut down" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.4;
import "./SaffronPoolV2.sol";
import "./SaffronPositionNFT.sol";
import "./balancer/WeightedPoolUserData.sol";
import "./balancer/IAsset.sol";
import { IVault as IBalancerVault } from "./balancer/IVault.sol";
import { IBalancerQueries, IVault as IQryVault } from "./balancer/IBalancerQueries.sol";
import "./interfaces/ITheVault.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
error UnsupportedConversion(address token);
error UnsupportedSettWithdraw(address token);
contract SaffronBadgerInsuranceFund is ReentrancyGuard {
using SafeERC20 for IERC20;
// Reward tokens
address internal constant WBTC_BADGER = 0xb460DAa847c45f1C4a41cb05BFB3b51c92e41B36; // Balancer 20WBTC-80BADGER
address internal constant B_AURA_BAL = 0x37d9D2C6035b744849C15F1BFEE8F268a20fCBd8; // Badger Sett Aura BAL
address internal constant B_BAL_AAVE_STABLE = 0x06D756861De0724FAd5B5636124e0f252d3C1404; // Badger Sett Balancer Aave Boosted StablePool (USD)
address internal constant B_GRAV_AURA = 0xBA485b556399123261a5F9c95d413B4f93107407; // Gravitationally Bound AURA
address internal constant AURA = 0xC0c293ce456fF0ED870ADd98a0828Dd4d2903DBF;
address internal constant AURA_BAL = 0x616e8BfA43F920657B3497DBf40D6b1A02D4608d;
address internal constant BB_A_USD = 0x7B50775383d3D6f0215A8F290f2C9e2eEBBEceb2;
ITheVault internal constant bAuraBal = ITheVault(B_AURA_BAL);
ITheVault internal constant bbbAUsd = ITheVault(B_BAL_AAVE_STABLE);
ITheVault internal constant bGravAura = ITheVault(B_GRAV_AURA);
// Constants needed for conversion
address[] internal reward_tokens = [ WBTC_BADGER ];
address internal constant WBTC = 0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599;
address internal constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address internal constant BADGER = 0x3472A5A71965499acd81997a54BBA8D852C6E53d;
address internal constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
bytes32 internal constant BADGER_WBTC_POOL_ID = 0xb460daa847c45f1c4a41cb05bfb3b51c92e41b36000200000000000000000194;
bytes32 internal constant WBTC_WETH_POOL_ID = 0xa6f548df93de924d73be7d25dc02554c6bd66db500020000000000000000000e;
bytes32 internal constant WETH_USDC_POOL_ID = 0x96646936b91d6b9d7d0c47c496afbf3d6ec7b6f8000200000000000000000019;
address internal constant BALANCER_VAULT = 0xBA12222222228d8Ba445958a75a0704d566BF2C8;
address internal constant BALANCER_QUERIES = 0xE39B5e3B6D74016b2F6A9673D7d7493B6DF549d5;
uint256 internal constant CONVERSION_MIN = uint256(1000);
uint256 internal constant EARNINGS_MIN = uint256(1000);
// Governance
address public treasury; // Saffron treasury to collect fees
address public governance; // Governance address for operations
address public new_governance; // Proposed new governance address
// System
address public insurance_asset; // Asset to insure the pool's senior tranche with
address public pool_base_asset; // Base asset to accumulate from pool, the Badger Vault (Sett) token
SaffronPoolV2 public pool; // SaffronPoolV2 this contract insures
SaffronPositionNFT public NFT; // Saffron Position NFT
uint256 public immutable TRANCHE; // Tranche indicated in NFT storage value
// User balance vars
uint256 public total_supply_lp; // Total balance of all user LP tokens
// Additional Reentrancy Guard
// Needed for update(), which can be called twice in some cases
uint256 private _update_status = 1;
modifier non_reentrant_update() {
}
// System Events
event FundsDeposited(uint256 tranche, uint256 lp, uint256 principal, uint256 token_id, address indexed owner);
event FundsWithdrawn(uint256 tranche, uint256 principal, uint256 earnings, uint256 token_id, address indexed owner, address caller);
event FundsConverted(address token_from, address token_to, uint256 amount_from, uint256 amount_to);
event ErcSwept(address who, address to, address token, uint256 amount);
constructor(address _insurance_asset, address _pool_base_asset) {
}
// Deposit insurance_assets into the insurance fund
function deposit(uint256 principal) external nonReentrant {
// Checks
require(<FILL_ME>)
require(!pool.deposits_disabled(), "deposits disabled");
require(principal > 0, "can't deposit 0");
// Effects
update();
uint256 total_holdings = IERC20(insurance_asset).balanceOf(address(this));
// If holdings or total supply are zero then lp tokens are equivalent to the underlying
uint256 lp = total_holdings == 0 || total_supply_lp == 0 ? principal : principal * total_supply_lp / total_holdings;
total_supply_lp += lp;
// Interactions
IERC20(insurance_asset).safeTransferFrom(msg.sender, address(this), principal);
uint256 token_id = NFT.mint(msg.sender, lp, principal, TRANCHE);
emit FundsDeposited(TRANCHE, lp, principal, token_id, msg.sender);
}
// Withdraw principal + earnings from the insurance fund
function withdraw(uint256 token_id) external nonReentrant {
}
// Emergency withdraw with as few interactions / state changes as possible / BUT still have to wait for expiration
function emergency_withdraw(uint256 token_id) external {
}
// Update state and accumulated assets_per_share
function update() public non_reentrant_update {
}
function convert() internal {
}
// Get total amount of insurance asset held by pool
function total_principal() external view returns(uint256) {
}
// Set the pool and NFT
function set_pool(address _pool) external {
}
// Set the treasury address
function set_treasury(address _treasury) external {
}
// Get pending earnings
function pending_earnings(uint256 token_id) external view returns(uint256) {
}
/// GOVERNANCE
// Propose governance transfer
function propose_governance(address to) external {
}
// Accept governance transfer
function accept_governance() external {
}
// Sweep funds in case of emergency
function sweep_erc(address _token, address _to) external {
}
function convert_rewards(address[] memory tokens) external {
}
function _convert_reward(address token) internal returns (uint256) {
}
function _convert_wbtc(uint256 amount) internal returns (int256) {
}
function _convert_badger(uint256 amount) internal returns (int256) {
}
function _convert_asset_to(address assetIn, address assetOut, uint256 amount, bytes32 pool) internal returns (int256) {
}
}
| !pool.shut_down(),"pool shut down" | 263,362 | !pool.shut_down() |
"deposits disabled" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.4;
import "./SaffronPoolV2.sol";
import "./SaffronPositionNFT.sol";
import "./balancer/WeightedPoolUserData.sol";
import "./balancer/IAsset.sol";
import { IVault as IBalancerVault } from "./balancer/IVault.sol";
import { IBalancerQueries, IVault as IQryVault } from "./balancer/IBalancerQueries.sol";
import "./interfaces/ITheVault.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
error UnsupportedConversion(address token);
error UnsupportedSettWithdraw(address token);
contract SaffronBadgerInsuranceFund is ReentrancyGuard {
using SafeERC20 for IERC20;
// Reward tokens
address internal constant WBTC_BADGER = 0xb460DAa847c45f1C4a41cb05BFB3b51c92e41B36; // Balancer 20WBTC-80BADGER
address internal constant B_AURA_BAL = 0x37d9D2C6035b744849C15F1BFEE8F268a20fCBd8; // Badger Sett Aura BAL
address internal constant B_BAL_AAVE_STABLE = 0x06D756861De0724FAd5B5636124e0f252d3C1404; // Badger Sett Balancer Aave Boosted StablePool (USD)
address internal constant B_GRAV_AURA = 0xBA485b556399123261a5F9c95d413B4f93107407; // Gravitationally Bound AURA
address internal constant AURA = 0xC0c293ce456fF0ED870ADd98a0828Dd4d2903DBF;
address internal constant AURA_BAL = 0x616e8BfA43F920657B3497DBf40D6b1A02D4608d;
address internal constant BB_A_USD = 0x7B50775383d3D6f0215A8F290f2C9e2eEBBEceb2;
ITheVault internal constant bAuraBal = ITheVault(B_AURA_BAL);
ITheVault internal constant bbbAUsd = ITheVault(B_BAL_AAVE_STABLE);
ITheVault internal constant bGravAura = ITheVault(B_GRAV_AURA);
// Constants needed for conversion
address[] internal reward_tokens = [ WBTC_BADGER ];
address internal constant WBTC = 0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599;
address internal constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address internal constant BADGER = 0x3472A5A71965499acd81997a54BBA8D852C6E53d;
address internal constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
bytes32 internal constant BADGER_WBTC_POOL_ID = 0xb460daa847c45f1c4a41cb05bfb3b51c92e41b36000200000000000000000194;
bytes32 internal constant WBTC_WETH_POOL_ID = 0xa6f548df93de924d73be7d25dc02554c6bd66db500020000000000000000000e;
bytes32 internal constant WETH_USDC_POOL_ID = 0x96646936b91d6b9d7d0c47c496afbf3d6ec7b6f8000200000000000000000019;
address internal constant BALANCER_VAULT = 0xBA12222222228d8Ba445958a75a0704d566BF2C8;
address internal constant BALANCER_QUERIES = 0xE39B5e3B6D74016b2F6A9673D7d7493B6DF549d5;
uint256 internal constant CONVERSION_MIN = uint256(1000);
uint256 internal constant EARNINGS_MIN = uint256(1000);
// Governance
address public treasury; // Saffron treasury to collect fees
address public governance; // Governance address for operations
address public new_governance; // Proposed new governance address
// System
address public insurance_asset; // Asset to insure the pool's senior tranche with
address public pool_base_asset; // Base asset to accumulate from pool, the Badger Vault (Sett) token
SaffronPoolV2 public pool; // SaffronPoolV2 this contract insures
SaffronPositionNFT public NFT; // Saffron Position NFT
uint256 public immutable TRANCHE; // Tranche indicated in NFT storage value
// User balance vars
uint256 public total_supply_lp; // Total balance of all user LP tokens
// Additional Reentrancy Guard
// Needed for update(), which can be called twice in some cases
uint256 private _update_status = 1;
modifier non_reentrant_update() {
}
// System Events
event FundsDeposited(uint256 tranche, uint256 lp, uint256 principal, uint256 token_id, address indexed owner);
event FundsWithdrawn(uint256 tranche, uint256 principal, uint256 earnings, uint256 token_id, address indexed owner, address caller);
event FundsConverted(address token_from, address token_to, uint256 amount_from, uint256 amount_to);
event ErcSwept(address who, address to, address token, uint256 amount);
constructor(address _insurance_asset, address _pool_base_asset) {
}
// Deposit insurance_assets into the insurance fund
function deposit(uint256 principal) external nonReentrant {
// Checks
require(!pool.shut_down(), "pool shut down");
require(<FILL_ME>)
require(principal > 0, "can't deposit 0");
// Effects
update();
uint256 total_holdings = IERC20(insurance_asset).balanceOf(address(this));
// If holdings or total supply are zero then lp tokens are equivalent to the underlying
uint256 lp = total_holdings == 0 || total_supply_lp == 0 ? principal : principal * total_supply_lp / total_holdings;
total_supply_lp += lp;
// Interactions
IERC20(insurance_asset).safeTransferFrom(msg.sender, address(this), principal);
uint256 token_id = NFT.mint(msg.sender, lp, principal, TRANCHE);
emit FundsDeposited(TRANCHE, lp, principal, token_id, msg.sender);
}
// Withdraw principal + earnings from the insurance fund
function withdraw(uint256 token_id) external nonReentrant {
}
// Emergency withdraw with as few interactions / state changes as possible / BUT still have to wait for expiration
function emergency_withdraw(uint256 token_id) external {
}
// Update state and accumulated assets_per_share
function update() public non_reentrant_update {
}
function convert() internal {
}
// Get total amount of insurance asset held by pool
function total_principal() external view returns(uint256) {
}
// Set the pool and NFT
function set_pool(address _pool) external {
}
// Set the treasury address
function set_treasury(address _treasury) external {
}
// Get pending earnings
function pending_earnings(uint256 token_id) external view returns(uint256) {
}
/// GOVERNANCE
// Propose governance transfer
function propose_governance(address to) external {
}
// Accept governance transfer
function accept_governance() external {
}
// Sweep funds in case of emergency
function sweep_erc(address _token, address _to) external {
}
function convert_rewards(address[] memory tokens) external {
}
function _convert_reward(address token) internal returns (uint256) {
}
function _convert_wbtc(uint256 amount) internal returns (int256) {
}
function _convert_badger(uint256 amount) internal returns (int256) {
}
function _convert_asset_to(address assetIn, address assetOut, uint256 amount, bytes32 pool) internal returns (int256) {
}
}
| !pool.deposits_disabled(),"deposits disabled" | 263,362 | !pool.deposits_disabled() |
"must be owner" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.4;
import "./SaffronPoolV2.sol";
import "./SaffronPositionNFT.sol";
import "./balancer/WeightedPoolUserData.sol";
import "./balancer/IAsset.sol";
import { IVault as IBalancerVault } from "./balancer/IVault.sol";
import { IBalancerQueries, IVault as IQryVault } from "./balancer/IBalancerQueries.sol";
import "./interfaces/ITheVault.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
error UnsupportedConversion(address token);
error UnsupportedSettWithdraw(address token);
contract SaffronBadgerInsuranceFund is ReentrancyGuard {
using SafeERC20 for IERC20;
// Reward tokens
address internal constant WBTC_BADGER = 0xb460DAa847c45f1C4a41cb05BFB3b51c92e41B36; // Balancer 20WBTC-80BADGER
address internal constant B_AURA_BAL = 0x37d9D2C6035b744849C15F1BFEE8F268a20fCBd8; // Badger Sett Aura BAL
address internal constant B_BAL_AAVE_STABLE = 0x06D756861De0724FAd5B5636124e0f252d3C1404; // Badger Sett Balancer Aave Boosted StablePool (USD)
address internal constant B_GRAV_AURA = 0xBA485b556399123261a5F9c95d413B4f93107407; // Gravitationally Bound AURA
address internal constant AURA = 0xC0c293ce456fF0ED870ADd98a0828Dd4d2903DBF;
address internal constant AURA_BAL = 0x616e8BfA43F920657B3497DBf40D6b1A02D4608d;
address internal constant BB_A_USD = 0x7B50775383d3D6f0215A8F290f2C9e2eEBBEceb2;
ITheVault internal constant bAuraBal = ITheVault(B_AURA_BAL);
ITheVault internal constant bbbAUsd = ITheVault(B_BAL_AAVE_STABLE);
ITheVault internal constant bGravAura = ITheVault(B_GRAV_AURA);
// Constants needed for conversion
address[] internal reward_tokens = [ WBTC_BADGER ];
address internal constant WBTC = 0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599;
address internal constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address internal constant BADGER = 0x3472A5A71965499acd81997a54BBA8D852C6E53d;
address internal constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
bytes32 internal constant BADGER_WBTC_POOL_ID = 0xb460daa847c45f1c4a41cb05bfb3b51c92e41b36000200000000000000000194;
bytes32 internal constant WBTC_WETH_POOL_ID = 0xa6f548df93de924d73be7d25dc02554c6bd66db500020000000000000000000e;
bytes32 internal constant WETH_USDC_POOL_ID = 0x96646936b91d6b9d7d0c47c496afbf3d6ec7b6f8000200000000000000000019;
address internal constant BALANCER_VAULT = 0xBA12222222228d8Ba445958a75a0704d566BF2C8;
address internal constant BALANCER_QUERIES = 0xE39B5e3B6D74016b2F6A9673D7d7493B6DF549d5;
uint256 internal constant CONVERSION_MIN = uint256(1000);
uint256 internal constant EARNINGS_MIN = uint256(1000);
// Governance
address public treasury; // Saffron treasury to collect fees
address public governance; // Governance address for operations
address public new_governance; // Proposed new governance address
// System
address public insurance_asset; // Asset to insure the pool's senior tranche with
address public pool_base_asset; // Base asset to accumulate from pool, the Badger Vault (Sett) token
SaffronPoolV2 public pool; // SaffronPoolV2 this contract insures
SaffronPositionNFT public NFT; // Saffron Position NFT
uint256 public immutable TRANCHE; // Tranche indicated in NFT storage value
// User balance vars
uint256 public total_supply_lp; // Total balance of all user LP tokens
// Additional Reentrancy Guard
// Needed for update(), which can be called twice in some cases
uint256 private _update_status = 1;
modifier non_reentrant_update() {
}
// System Events
event FundsDeposited(uint256 tranche, uint256 lp, uint256 principal, uint256 token_id, address indexed owner);
event FundsWithdrawn(uint256 tranche, uint256 principal, uint256 earnings, uint256 token_id, address indexed owner, address caller);
event FundsConverted(address token_from, address token_to, uint256 amount_from, uint256 amount_to);
event ErcSwept(address who, address to, address token, uint256 amount);
constructor(address _insurance_asset, address _pool_base_asset) {
}
// Deposit insurance_assets into the insurance fund
function deposit(uint256 principal) external nonReentrant {
}
// Withdraw principal + earnings from the insurance fund
function withdraw(uint256 token_id) external nonReentrant {
}
// Emergency withdraw with as few interactions / state changes as possible / BUT still have to wait for expiration
function emergency_withdraw(uint256 token_id) external {
// Extra checks
require(!pool.shut_down(), "removal paused");
require(NFT.tranche(token_id) == 2, "must be insurance NFT");
require(<FILL_ME>)
uint256 principal = NFT.principal(token_id);
// Minimum effects
total_supply_lp -= NFT.balance(token_id);
// Minimum interactions
emit FundsWithdrawn(TRANCHE, principal, 0, token_id, msg.sender, msg.sender);
IERC20(insurance_asset).safeTransfer(msg.sender, principal);
NFT.burn(token_id);
}
// Update state and accumulated assets_per_share
function update() public non_reentrant_update {
}
function convert() internal {
}
// Get total amount of insurance asset held by pool
function total_principal() external view returns(uint256) {
}
// Set the pool and NFT
function set_pool(address _pool) external {
}
// Set the treasury address
function set_treasury(address _treasury) external {
}
// Get pending earnings
function pending_earnings(uint256 token_id) external view returns(uint256) {
}
/// GOVERNANCE
// Propose governance transfer
function propose_governance(address to) external {
}
// Accept governance transfer
function accept_governance() external {
}
// Sweep funds in case of emergency
function sweep_erc(address _token, address _to) external {
}
function convert_rewards(address[] memory tokens) external {
}
function _convert_reward(address token) internal returns (uint256) {
}
function _convert_wbtc(uint256 amount) internal returns (int256) {
}
function _convert_badger(uint256 amount) internal returns (int256) {
}
function _convert_asset_to(address assetIn, address assetOut, uint256 amount, bytes32 pool) internal returns (int256) {
}
}
| NFT.ownerOf(token_id)==msg.sender,"must be owner" | 263,362 | NFT.ownerOf(token_id)==msg.sender |
"_transfer:: Transfer Delay enabled. Only one purchase per block allowed." | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.8;
pragma experimental ABIEncoderV2;
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {SafeMath} from "@openzeppelin/contracts/utils/math/SafeMath.sol";
import {IUniswapV2Router02} from "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
import {IUniswapV2Factory} from "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import {IUniswapV2Pair} from "@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol";
contract Ribka is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private swapping;
address public marketingWallet;
address public devWallet;
uint256 public maxTransactionAmount;
uint256 public swapTokensAtAmount;
uint256 public maxWallet;
uint256 public percentForLPBurn = 25; // 25 = .25%
bool public lpBurnEnabled = true;
uint256 public lpBurnFrequency = 3600 seconds;
uint256 public lastLpBurnTime;
uint256 public manualBurnFrequency = 30 minutes;
uint256 public lastManualLpBurnTime;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
mapping(address => uint256) private _holderLastTransferTimestamp; // to hold last Transfers temporarily during launch
bool public transferDelayEnabled = true;
uint256 public buyTotalFees;
uint256 public buyMarketingFee;
uint256 public buyLiquidityFee;
uint256 public buyDevFee;
uint256 public sellTotalFees;
uint256 public sellMarketingFee;
uint256 public sellLiquidityFee;
uint256 public sellDevFee;
uint256 public tokensForMarketing;
uint256 public tokensForLiquidity;
uint256 public tokensForDev;
// exlcude from fees and max transaction amount
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping(address => bool) public automatedMarketMakerPairs;
constructor() ERC20("Ribka", "Ri") {
}
function initRouter() private {
}
function initContractFee() private {
}
receive() external payable {}
// once enabled, can never be turned off
function enableTrading() external onlyOwner {
}
// remove limits after token is stable
function removeLimits() external onlyOwner returns (bool) {
}
// disable Transfer delay - cannot be reenabled
function disableTransferDelay() external onlyOwner returns (bool) {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount)
external
onlyOwner
returns (bool)
{
}
function updateMaxTxnAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx)
public
onlyOwner
{
}
// only use to disable contract sales if absolutely necessary (emergency use only)
function updateSwapEnabled(bool enabled) external onlyOwner {
}
function updateBuyFees(
uint256 _marketingFee,
uint256 _liquidityFee,
uint256 _devFee
) external onlyOwner {
}
function updateSellFees(
uint256 _marketingFee,
uint256 _liquidityFee,
uint256 _devFee
) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value)
public
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateMarketingWallet(address newMarketingWallet)
external
onlyOwner
{
}
function updateDevWallet(address newWallet) external onlyOwner {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function validateLimitTransfer(
address from,
address to,
uint256 amount
) private {
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
!swapping
) {
if (!tradingActive) {
require(
_isExcludedFromFees[from] || _isExcludedFromFees[to],
"Trading is not active."
);
}
// at launch if the transfer delay is enabled, ensure the block timestamps for purchasers is set -- during launch.
if (transferDelayEnabled) {
if (
to != owner() &&
to != address(uniswapV2Router) &&
to != address(uniswapV2Pair)
) {
require(<FILL_ME>)
_holderLastTransferTimestamp[msg.sender] = block.number;
}
}
//when buy
if (
automatedMarketMakerPairs[from] &&
!_isExcludedMaxTransactionAmount[to]
) {
require(
amount <= maxTransactionAmount,
"Buy transfer amount exceeds the maxTransactionAmount."
);
require(
amount + balanceOf(to) <= maxWallet,
"Max wallet exceeded"
);
}
//when sell
else if (
automatedMarketMakerPairs[to] &&
!_isExcludedMaxTransactionAmount[from]
) {
require(
amount <= maxTransactionAmount,
"Sell transfer amount exceeds the maxTransactionAmount."
);
} else if (!_isExcludedMaxTransactionAmount[to]) {
require(
amount + balanceOf(to) <= maxWallet,
"Max wallet exceeded"
);
}
}
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
function setAutoLPBurnSettings(
uint256 _frequencyInSeconds,
uint256 _percent,
bool _Enabled
) external onlyOwner {
}
function autoBurnLiquidityPairTokens() internal returns (bool) {
}
function manualBurnLiquidityPairTokens(uint256 percent)
external
onlyOwner
returns (bool)
{
}
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 SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event AutoNukeLP();
event ManualNukeLP();
}
| _holderLastTransferTimestamp[msg.sender]<block.number,"_transfer:: Transfer Delay enabled. Only one purchase per block allowed." | 263,423 | _holderLastTransferTimestamp[msg.sender]<block.number |
"No access to reserve NFT" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
pragma abicoder v2; // required to accept structs as function parameters
import "@openzeppelin/contracts/access/Ownable.sol";
import "erc721a/contracts/ERC721A.sol";
/**
@title FABDAOPlus
@author Lee Ting Ting @tina1998612
*/
contract FABDAOPlus is Ownable, ERC721A {
using Address for address;
string private baseTokenURI;
uint256 public constant mintPrice = 10 ether;
uint256 public constant maxMintLimitPerAddr = 5;
uint256 public constant MAX_SUPPLY = 100;
address public constant reserver = 0x952936E60B9a9E2E9B2950599694aFE9Ff8a8a4a;
mapping(address => uint256) public _mintedCountsPublic;
modifier onlyReserver () {
require(<FILL_ME>)
_;
}
constructor(
string memory _name,
string memory _symbol,
string memory _baseTokenURI
) ERC721A(_name, _symbol) {
}
/// @notice Public mint
function mint(address to, uint256 amount) external payable {
}
/// @dev Reserve NFT. The contract owner can mint NFTs for free.
function reserve(address to, uint256 amount) external onlyReserver {
}
/// @dev Withdraw. The contract owner can withdraw all ETH from the NFT sale
function withdraw() external onlyReserver {
}
/// @dev Set new baseURI
function setBaseURI(string memory baseURI) external onlyReserver {
}
/// @dev override _baseURI()
function _baseURI() internal view override returns (string memory) {
}
}
| _msgSender()==reserver||_msgSender()==owner(),"No access to reserve NFT" | 263,616 | _msgSender()==reserver||_msgSender()==owner() |
"Exceed maxMintCount per address" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
pragma abicoder v2; // required to accept structs as function parameters
import "@openzeppelin/contracts/access/Ownable.sol";
import "erc721a/contracts/ERC721A.sol";
/**
@title FABDAOPlus
@author Lee Ting Ting @tina1998612
*/
contract FABDAOPlus is Ownable, ERC721A {
using Address for address;
string private baseTokenURI;
uint256 public constant mintPrice = 10 ether;
uint256 public constant maxMintLimitPerAddr = 5;
uint256 public constant MAX_SUPPLY = 100;
address public constant reserver = 0x952936E60B9a9E2E9B2950599694aFE9Ff8a8a4a;
mapping(address => uint256) public _mintedCountsPublic;
modifier onlyReserver () {
}
constructor(
string memory _name,
string memory _symbol,
string memory _baseTokenURI
) ERC721A(_name, _symbol) {
}
/// @notice Public mint
function mint(address to, uint256 amount) external payable {
// check if exceed maxMintCount
require(<FILL_ME>)
// check if Exceed max total supply
require(totalSupply() + amount <= MAX_SUPPLY, "Exceed max total supply");
// check fund
require(msg.value >= mintPrice * amount, "Not enough fund to mint NFT");
// mint
super._safeMint(to, amount);
// increase minted count
_mintedCountsPublic[to] += amount;
}
/// @dev Reserve NFT. The contract owner can mint NFTs for free.
function reserve(address to, uint256 amount) external onlyReserver {
}
/// @dev Withdraw. The contract owner can withdraw all ETH from the NFT sale
function withdraw() external onlyReserver {
}
/// @dev Set new baseURI
function setBaseURI(string memory baseURI) external onlyReserver {
}
/// @dev override _baseURI()
function _baseURI() internal view override returns (string memory) {
}
}
| amount+_mintedCountsPublic[to]<=maxMintLimitPerAddr,"Exceed maxMintCount per address" | 263,616 | amount+_mintedCountsPublic[to]<=maxMintLimitPerAddr |
"Amount requested would exceed supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract DeathGirlHalloween is ERC721A, Ownable, ReentrancyGuard {
// state
string private base;
uint256 public allowedMintsPerAllowlistAddress;
uint256 public allowedMintsPerWaitlistAddress;
uint256 public immutable mintPrice;
uint256 public immutable collectionSize;
string private placeholderURI;
bool private allowlistActive;
bytes32 private allowlistMerkleRoot;
bool private waitlistActive;
bytes32 private waitlistMerkleRoot;
bool private teamActive;
bytes32 private teamMerkleRoot;
event UpdatedTeamList(bytes32 _old, bytes32 _new);
event UpdatedTeamStatus(bool _old, bool _new);
event UpdatedAllowlist(bytes32 _old, bytes32 _new);
event UpdatedAllowlistStatus(bool _old, bool _new);
event UpdatedAllowlistMintAmount(uint256 _old, uint256 _new);
event UpdatedWaitlist(bytes32 _old, bytes32 _new);
event UpdatedWaitlistStatus(bool _old, bool _new);
event UpdatedWaitlistMintAmount(uint256 _old, uint256 _new);
constructor(
string memory _placeholderURI,
bytes32 _teamMerkleRoot,
bytes32 _allowlistMerkleRoot,
bytes32 _waitlistMerkleRoot
) ERC721A("DEATH GIRL - HALLOWEEN", "DGH") {
}
modifier callerIsUser() {
}
// Mint
function allowlistMint(bytes32[] calldata merkleProof, uint64 amount)
external
callerIsUser
{
require(allowlistActive, "Allowlist not active");
require(<FILL_ME>)
require(amount < allowedMintsPerAllowlistAddress + 1, "Trying to mint more than allowed");
require(
MerkleProof.verify(
merkleProof,
allowlistMerkleRoot,
keccak256(abi.encodePacked(_msgSender()))
),
"Not on allowlist"
);
require(
amountMinted(msg.sender) + amount < allowedMintsPerAllowlistAddress + 1,
"Can't mint more"
);
_safeMint(_msgSender(), amount);
}
function waitlistMint(bytes32[] calldata merkleProof, uint64 amount)
external
callerIsUser
{
}
function teamMint(bytes32[] calldata merkleProof, uint64 amount)
external
callerIsUser
{
}
// Contract Admin
function setBaseURI(string memory baseURI) public onlyOwner {
}
function disableTeam() public onlyOwner {
}
function enableAllowlist() external onlyOwner {
}
function disableAllowlist() public onlyOwner {
}
function updateAllowlistMintAmount(uint256 _amount) external onlyOwner {
}
function enableWaitlist() external onlyOwner {
}
function disableWaitlist() public onlyOwner {
}
function updateWaitlistMintAmount(uint256 _amount) external onlyOwner {
}
function setTeamlistMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setAllowlistMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setWaitlistMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function amountMinted(address ownerAddress) public view returns (uint256) {
}
// Getters
function getMintStatus() external view returns (bool) {
}
function teamStatus() external view returns (bool) {
}
function allowlistStatus() external view returns (bool) {
}
function waitlistStatus() external view returns (bool) {
}
function mintingFee() external view returns (uint256) {
}
function getCollectionSize() external view returns (uint256) {
}
function contractURI() public pure returns (string memory) {
}
// Overrides
// @notice Solidity required override for _baseURI(), if you wish to
// be able to set from API -> IPFS or vice versa using setBaseURI(string)
function _baseURI() internal view override returns (string memory) {
}
// @notice Override for ERC721A _startTokenId to change from default 0 -> 1
function _startTokenId() internal pure override returns (uint256) {
}
// @notice Override for ERC721A tokenURI
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
}
| totalSupply()+amount<collectionSize+1,"Amount requested would exceed supply" | 263,668 | totalSupply()+amount<collectionSize+1 |
"Not on allowlist" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract DeathGirlHalloween is ERC721A, Ownable, ReentrancyGuard {
// state
string private base;
uint256 public allowedMintsPerAllowlistAddress;
uint256 public allowedMintsPerWaitlistAddress;
uint256 public immutable mintPrice;
uint256 public immutable collectionSize;
string private placeholderURI;
bool private allowlistActive;
bytes32 private allowlistMerkleRoot;
bool private waitlistActive;
bytes32 private waitlistMerkleRoot;
bool private teamActive;
bytes32 private teamMerkleRoot;
event UpdatedTeamList(bytes32 _old, bytes32 _new);
event UpdatedTeamStatus(bool _old, bool _new);
event UpdatedAllowlist(bytes32 _old, bytes32 _new);
event UpdatedAllowlistStatus(bool _old, bool _new);
event UpdatedAllowlistMintAmount(uint256 _old, uint256 _new);
event UpdatedWaitlist(bytes32 _old, bytes32 _new);
event UpdatedWaitlistStatus(bool _old, bool _new);
event UpdatedWaitlistMintAmount(uint256 _old, uint256 _new);
constructor(
string memory _placeholderURI,
bytes32 _teamMerkleRoot,
bytes32 _allowlistMerkleRoot,
bytes32 _waitlistMerkleRoot
) ERC721A("DEATH GIRL - HALLOWEEN", "DGH") {
}
modifier callerIsUser() {
}
// Mint
function allowlistMint(bytes32[] calldata merkleProof, uint64 amount)
external
callerIsUser
{
require(allowlistActive, "Allowlist not active");
require(totalSupply() + amount < collectionSize + 1, "Amount requested would exceed supply");
require(amount < allowedMintsPerAllowlistAddress + 1, "Trying to mint more than allowed");
require(<FILL_ME>)
require(
amountMinted(msg.sender) + amount < allowedMintsPerAllowlistAddress + 1,
"Can't mint more"
);
_safeMint(_msgSender(), amount);
}
function waitlistMint(bytes32[] calldata merkleProof, uint64 amount)
external
callerIsUser
{
}
function teamMint(bytes32[] calldata merkleProof, uint64 amount)
external
callerIsUser
{
}
// Contract Admin
function setBaseURI(string memory baseURI) public onlyOwner {
}
function disableTeam() public onlyOwner {
}
function enableAllowlist() external onlyOwner {
}
function disableAllowlist() public onlyOwner {
}
function updateAllowlistMintAmount(uint256 _amount) external onlyOwner {
}
function enableWaitlist() external onlyOwner {
}
function disableWaitlist() public onlyOwner {
}
function updateWaitlistMintAmount(uint256 _amount) external onlyOwner {
}
function setTeamlistMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setAllowlistMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setWaitlistMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function amountMinted(address ownerAddress) public view returns (uint256) {
}
// Getters
function getMintStatus() external view returns (bool) {
}
function teamStatus() external view returns (bool) {
}
function allowlistStatus() external view returns (bool) {
}
function waitlistStatus() external view returns (bool) {
}
function mintingFee() external view returns (uint256) {
}
function getCollectionSize() external view returns (uint256) {
}
function contractURI() public pure returns (string memory) {
}
// Overrides
// @notice Solidity required override for _baseURI(), if you wish to
// be able to set from API -> IPFS or vice versa using setBaseURI(string)
function _baseURI() internal view override returns (string memory) {
}
// @notice Override for ERC721A _startTokenId to change from default 0 -> 1
function _startTokenId() internal pure override returns (uint256) {
}
// @notice Override for ERC721A tokenURI
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
}
| MerkleProof.verify(merkleProof,allowlistMerkleRoot,keccak256(abi.encodePacked(_msgSender()))),"Not on allowlist" | 263,668 | MerkleProof.verify(merkleProof,allowlistMerkleRoot,keccak256(abi.encodePacked(_msgSender()))) |
"Can't mint more" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract DeathGirlHalloween is ERC721A, Ownable, ReentrancyGuard {
// state
string private base;
uint256 public allowedMintsPerAllowlistAddress;
uint256 public allowedMintsPerWaitlistAddress;
uint256 public immutable mintPrice;
uint256 public immutable collectionSize;
string private placeholderURI;
bool private allowlistActive;
bytes32 private allowlistMerkleRoot;
bool private waitlistActive;
bytes32 private waitlistMerkleRoot;
bool private teamActive;
bytes32 private teamMerkleRoot;
event UpdatedTeamList(bytes32 _old, bytes32 _new);
event UpdatedTeamStatus(bool _old, bool _new);
event UpdatedAllowlist(bytes32 _old, bytes32 _new);
event UpdatedAllowlistStatus(bool _old, bool _new);
event UpdatedAllowlistMintAmount(uint256 _old, uint256 _new);
event UpdatedWaitlist(bytes32 _old, bytes32 _new);
event UpdatedWaitlistStatus(bool _old, bool _new);
event UpdatedWaitlistMintAmount(uint256 _old, uint256 _new);
constructor(
string memory _placeholderURI,
bytes32 _teamMerkleRoot,
bytes32 _allowlistMerkleRoot,
bytes32 _waitlistMerkleRoot
) ERC721A("DEATH GIRL - HALLOWEEN", "DGH") {
}
modifier callerIsUser() {
}
// Mint
function allowlistMint(bytes32[] calldata merkleProof, uint64 amount)
external
callerIsUser
{
require(allowlistActive, "Allowlist not active");
require(totalSupply() + amount < collectionSize + 1, "Amount requested would exceed supply");
require(amount < allowedMintsPerAllowlistAddress + 1, "Trying to mint more than allowed");
require(
MerkleProof.verify(
merkleProof,
allowlistMerkleRoot,
keccak256(abi.encodePacked(_msgSender()))
),
"Not on allowlist"
);
require(<FILL_ME>)
_safeMint(_msgSender(), amount);
}
function waitlistMint(bytes32[] calldata merkleProof, uint64 amount)
external
callerIsUser
{
}
function teamMint(bytes32[] calldata merkleProof, uint64 amount)
external
callerIsUser
{
}
// Contract Admin
function setBaseURI(string memory baseURI) public onlyOwner {
}
function disableTeam() public onlyOwner {
}
function enableAllowlist() external onlyOwner {
}
function disableAllowlist() public onlyOwner {
}
function updateAllowlistMintAmount(uint256 _amount) external onlyOwner {
}
function enableWaitlist() external onlyOwner {
}
function disableWaitlist() public onlyOwner {
}
function updateWaitlistMintAmount(uint256 _amount) external onlyOwner {
}
function setTeamlistMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setAllowlistMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setWaitlistMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function amountMinted(address ownerAddress) public view returns (uint256) {
}
// Getters
function getMintStatus() external view returns (bool) {
}
function teamStatus() external view returns (bool) {
}
function allowlistStatus() external view returns (bool) {
}
function waitlistStatus() external view returns (bool) {
}
function mintingFee() external view returns (uint256) {
}
function getCollectionSize() external view returns (uint256) {
}
function contractURI() public pure returns (string memory) {
}
// Overrides
// @notice Solidity required override for _baseURI(), if you wish to
// be able to set from API -> IPFS or vice versa using setBaseURI(string)
function _baseURI() internal view override returns (string memory) {
}
// @notice Override for ERC721A _startTokenId to change from default 0 -> 1
function _startTokenId() internal pure override returns (uint256) {
}
// @notice Override for ERC721A tokenURI
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
}
| amountMinted(msg.sender)+amount<allowedMintsPerAllowlistAddress+1,"Can't mint more" | 263,668 | amountMinted(msg.sender)+amount<allowedMintsPerAllowlistAddress+1 |
"Not on waitlist" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract DeathGirlHalloween is ERC721A, Ownable, ReentrancyGuard {
// state
string private base;
uint256 public allowedMintsPerAllowlistAddress;
uint256 public allowedMintsPerWaitlistAddress;
uint256 public immutable mintPrice;
uint256 public immutable collectionSize;
string private placeholderURI;
bool private allowlistActive;
bytes32 private allowlistMerkleRoot;
bool private waitlistActive;
bytes32 private waitlistMerkleRoot;
bool private teamActive;
bytes32 private teamMerkleRoot;
event UpdatedTeamList(bytes32 _old, bytes32 _new);
event UpdatedTeamStatus(bool _old, bool _new);
event UpdatedAllowlist(bytes32 _old, bytes32 _new);
event UpdatedAllowlistStatus(bool _old, bool _new);
event UpdatedAllowlistMintAmount(uint256 _old, uint256 _new);
event UpdatedWaitlist(bytes32 _old, bytes32 _new);
event UpdatedWaitlistStatus(bool _old, bool _new);
event UpdatedWaitlistMintAmount(uint256 _old, uint256 _new);
constructor(
string memory _placeholderURI,
bytes32 _teamMerkleRoot,
bytes32 _allowlistMerkleRoot,
bytes32 _waitlistMerkleRoot
) ERC721A("DEATH GIRL - HALLOWEEN", "DGH") {
}
modifier callerIsUser() {
}
// Mint
function allowlistMint(bytes32[] calldata merkleProof, uint64 amount)
external
callerIsUser
{
}
function waitlistMint(bytes32[] calldata merkleProof, uint64 amount)
external
callerIsUser
{
require(waitlistActive, "Waitlist not active");
require(totalSupply() + amount < collectionSize + 1, "Amount requested would exceed supply");
require(amount < allowedMintsPerWaitlistAddress + 1, "Trying to mint more than allowed");
require(<FILL_ME>)
require(
amountMinted(msg.sender) + amount < allowedMintsPerWaitlistAddress + 1,
"Can't mint more"
);
_safeMint(_msgSender(), amount);
}
function teamMint(bytes32[] calldata merkleProof, uint64 amount)
external
callerIsUser
{
}
// Contract Admin
function setBaseURI(string memory baseURI) public onlyOwner {
}
function disableTeam() public onlyOwner {
}
function enableAllowlist() external onlyOwner {
}
function disableAllowlist() public onlyOwner {
}
function updateAllowlistMintAmount(uint256 _amount) external onlyOwner {
}
function enableWaitlist() external onlyOwner {
}
function disableWaitlist() public onlyOwner {
}
function updateWaitlistMintAmount(uint256 _amount) external onlyOwner {
}
function setTeamlistMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setAllowlistMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setWaitlistMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function amountMinted(address ownerAddress) public view returns (uint256) {
}
// Getters
function getMintStatus() external view returns (bool) {
}
function teamStatus() external view returns (bool) {
}
function allowlistStatus() external view returns (bool) {
}
function waitlistStatus() external view returns (bool) {
}
function mintingFee() external view returns (uint256) {
}
function getCollectionSize() external view returns (uint256) {
}
function contractURI() public pure returns (string memory) {
}
// Overrides
// @notice Solidity required override for _baseURI(), if you wish to
// be able to set from API -> IPFS or vice versa using setBaseURI(string)
function _baseURI() internal view override returns (string memory) {
}
// @notice Override for ERC721A _startTokenId to change from default 0 -> 1
function _startTokenId() internal pure override returns (uint256) {
}
// @notice Override for ERC721A tokenURI
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
}
| MerkleProof.verify(merkleProof,waitlistMerkleRoot,keccak256(abi.encodePacked(_msgSender()))),"Not on waitlist" | 263,668 | MerkleProof.verify(merkleProof,waitlistMerkleRoot,keccak256(abi.encodePacked(_msgSender()))) |
"Can't mint more" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract DeathGirlHalloween is ERC721A, Ownable, ReentrancyGuard {
// state
string private base;
uint256 public allowedMintsPerAllowlistAddress;
uint256 public allowedMintsPerWaitlistAddress;
uint256 public immutable mintPrice;
uint256 public immutable collectionSize;
string private placeholderURI;
bool private allowlistActive;
bytes32 private allowlistMerkleRoot;
bool private waitlistActive;
bytes32 private waitlistMerkleRoot;
bool private teamActive;
bytes32 private teamMerkleRoot;
event UpdatedTeamList(bytes32 _old, bytes32 _new);
event UpdatedTeamStatus(bool _old, bool _new);
event UpdatedAllowlist(bytes32 _old, bytes32 _new);
event UpdatedAllowlistStatus(bool _old, bool _new);
event UpdatedAllowlistMintAmount(uint256 _old, uint256 _new);
event UpdatedWaitlist(bytes32 _old, bytes32 _new);
event UpdatedWaitlistStatus(bool _old, bool _new);
event UpdatedWaitlistMintAmount(uint256 _old, uint256 _new);
constructor(
string memory _placeholderURI,
bytes32 _teamMerkleRoot,
bytes32 _allowlistMerkleRoot,
bytes32 _waitlistMerkleRoot
) ERC721A("DEATH GIRL - HALLOWEEN", "DGH") {
}
modifier callerIsUser() {
}
// Mint
function allowlistMint(bytes32[] calldata merkleProof, uint64 amount)
external
callerIsUser
{
}
function waitlistMint(bytes32[] calldata merkleProof, uint64 amount)
external
callerIsUser
{
require(waitlistActive, "Waitlist not active");
require(totalSupply() + amount < collectionSize + 1, "Amount requested would exceed supply");
require(amount < allowedMintsPerWaitlistAddress + 1, "Trying to mint more than allowed");
require(
MerkleProof.verify(
merkleProof,
waitlistMerkleRoot,
keccak256(abi.encodePacked(_msgSender()))
),
"Not on waitlist"
);
require(<FILL_ME>)
_safeMint(_msgSender(), amount);
}
function teamMint(bytes32[] calldata merkleProof, uint64 amount)
external
callerIsUser
{
}
// Contract Admin
function setBaseURI(string memory baseURI) public onlyOwner {
}
function disableTeam() public onlyOwner {
}
function enableAllowlist() external onlyOwner {
}
function disableAllowlist() public onlyOwner {
}
function updateAllowlistMintAmount(uint256 _amount) external onlyOwner {
}
function enableWaitlist() external onlyOwner {
}
function disableWaitlist() public onlyOwner {
}
function updateWaitlistMintAmount(uint256 _amount) external onlyOwner {
}
function setTeamlistMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setAllowlistMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setWaitlistMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function amountMinted(address ownerAddress) public view returns (uint256) {
}
// Getters
function getMintStatus() external view returns (bool) {
}
function teamStatus() external view returns (bool) {
}
function allowlistStatus() external view returns (bool) {
}
function waitlistStatus() external view returns (bool) {
}
function mintingFee() external view returns (uint256) {
}
function getCollectionSize() external view returns (uint256) {
}
function contractURI() public pure returns (string memory) {
}
// Overrides
// @notice Solidity required override for _baseURI(), if you wish to
// be able to set from API -> IPFS or vice versa using setBaseURI(string)
function _baseURI() internal view override returns (string memory) {
}
// @notice Override for ERC721A _startTokenId to change from default 0 -> 1
function _startTokenId() internal pure override returns (uint256) {
}
// @notice Override for ERC721A tokenURI
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
}
| amountMinted(msg.sender)+amount<allowedMintsPerWaitlistAddress+1,"Can't mint more" | 263,668 | amountMinted(msg.sender)+amount<allowedMintsPerWaitlistAddress+1 |
"Not part of the dev team" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract DeathGirlHalloween is ERC721A, Ownable, ReentrancyGuard {
// state
string private base;
uint256 public allowedMintsPerAllowlistAddress;
uint256 public allowedMintsPerWaitlistAddress;
uint256 public immutable mintPrice;
uint256 public immutable collectionSize;
string private placeholderURI;
bool private allowlistActive;
bytes32 private allowlistMerkleRoot;
bool private waitlistActive;
bytes32 private waitlistMerkleRoot;
bool private teamActive;
bytes32 private teamMerkleRoot;
event UpdatedTeamList(bytes32 _old, bytes32 _new);
event UpdatedTeamStatus(bool _old, bool _new);
event UpdatedAllowlist(bytes32 _old, bytes32 _new);
event UpdatedAllowlistStatus(bool _old, bool _new);
event UpdatedAllowlistMintAmount(uint256 _old, uint256 _new);
event UpdatedWaitlist(bytes32 _old, bytes32 _new);
event UpdatedWaitlistStatus(bool _old, bool _new);
event UpdatedWaitlistMintAmount(uint256 _old, uint256 _new);
constructor(
string memory _placeholderURI,
bytes32 _teamMerkleRoot,
bytes32 _allowlistMerkleRoot,
bytes32 _waitlistMerkleRoot
) ERC721A("DEATH GIRL - HALLOWEEN", "DGH") {
}
modifier callerIsUser() {
}
// Mint
function allowlistMint(bytes32[] calldata merkleProof, uint64 amount)
external
callerIsUser
{
}
function waitlistMint(bytes32[] calldata merkleProof, uint64 amount)
external
callerIsUser
{
}
function teamMint(bytes32[] calldata merkleProof, uint64 amount)
external
callerIsUser
{
require(teamActive, "Team mint not active");
require(totalSupply() + amount < collectionSize + 1, "Amount requested would exceed supply");
require(<FILL_ME>)
_safeMint(_msgSender(), amount);
}
// Contract Admin
function setBaseURI(string memory baseURI) public onlyOwner {
}
function disableTeam() public onlyOwner {
}
function enableAllowlist() external onlyOwner {
}
function disableAllowlist() public onlyOwner {
}
function updateAllowlistMintAmount(uint256 _amount) external onlyOwner {
}
function enableWaitlist() external onlyOwner {
}
function disableWaitlist() public onlyOwner {
}
function updateWaitlistMintAmount(uint256 _amount) external onlyOwner {
}
function setTeamlistMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setAllowlistMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setWaitlistMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function amountMinted(address ownerAddress) public view returns (uint256) {
}
// Getters
function getMintStatus() external view returns (bool) {
}
function teamStatus() external view returns (bool) {
}
function allowlistStatus() external view returns (bool) {
}
function waitlistStatus() external view returns (bool) {
}
function mintingFee() external view returns (uint256) {
}
function getCollectionSize() external view returns (uint256) {
}
function contractURI() public pure returns (string memory) {
}
// Overrides
// @notice Solidity required override for _baseURI(), if you wish to
// be able to set from API -> IPFS or vice versa using setBaseURI(string)
function _baseURI() internal view override returns (string memory) {
}
// @notice Override for ERC721A _startTokenId to change from default 0 -> 1
function _startTokenId() internal pure override returns (uint256) {
}
// @notice Override for ERC721A tokenURI
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
}
| MerkleProof.verify(merkleProof,teamMerkleRoot,keccak256(abi.encodePacked(_msgSender()))),"Not part of the dev team" | 263,668 | MerkleProof.verify(merkleProof,teamMerkleRoot,keccak256(abi.encodePacked(_msgSender()))) |
"Allowlist mint already active" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract DeathGirlHalloween is ERC721A, Ownable, ReentrancyGuard {
// state
string private base;
uint256 public allowedMintsPerAllowlistAddress;
uint256 public allowedMintsPerWaitlistAddress;
uint256 public immutable mintPrice;
uint256 public immutable collectionSize;
string private placeholderURI;
bool private allowlistActive;
bytes32 private allowlistMerkleRoot;
bool private waitlistActive;
bytes32 private waitlistMerkleRoot;
bool private teamActive;
bytes32 private teamMerkleRoot;
event UpdatedTeamList(bytes32 _old, bytes32 _new);
event UpdatedTeamStatus(bool _old, bool _new);
event UpdatedAllowlist(bytes32 _old, bytes32 _new);
event UpdatedAllowlistStatus(bool _old, bool _new);
event UpdatedAllowlistMintAmount(uint256 _old, uint256 _new);
event UpdatedWaitlist(bytes32 _old, bytes32 _new);
event UpdatedWaitlistStatus(bool _old, bool _new);
event UpdatedWaitlistMintAmount(uint256 _old, uint256 _new);
constructor(
string memory _placeholderURI,
bytes32 _teamMerkleRoot,
bytes32 _allowlistMerkleRoot,
bytes32 _waitlistMerkleRoot
) ERC721A("DEATH GIRL - HALLOWEEN", "DGH") {
}
modifier callerIsUser() {
}
// Mint
function allowlistMint(bytes32[] calldata merkleProof, uint64 amount)
external
callerIsUser
{
}
function waitlistMint(bytes32[] calldata merkleProof, uint64 amount)
external
callerIsUser
{
}
function teamMint(bytes32[] calldata merkleProof, uint64 amount)
external
callerIsUser
{
}
// Contract Admin
function setBaseURI(string memory baseURI) public onlyOwner {
}
function disableTeam() public onlyOwner {
}
function enableAllowlist() external onlyOwner {
require(<FILL_ME>)
bool oldValue = allowlistActive;
allowlistActive = true;
emit UpdatedAllowlistStatus(oldValue, allowlistActive);
}
function disableAllowlist() public onlyOwner {
}
function updateAllowlistMintAmount(uint256 _amount) external onlyOwner {
}
function enableWaitlist() external onlyOwner {
}
function disableWaitlist() public onlyOwner {
}
function updateWaitlistMintAmount(uint256 _amount) external onlyOwner {
}
function setTeamlistMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setAllowlistMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setWaitlistMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function amountMinted(address ownerAddress) public view returns (uint256) {
}
// Getters
function getMintStatus() external view returns (bool) {
}
function teamStatus() external view returns (bool) {
}
function allowlistStatus() external view returns (bool) {
}
function waitlistStatus() external view returns (bool) {
}
function mintingFee() external view returns (uint256) {
}
function getCollectionSize() external view returns (uint256) {
}
function contractURI() public pure returns (string memory) {
}
// Overrides
// @notice Solidity required override for _baseURI(), if you wish to
// be able to set from API -> IPFS or vice versa using setBaseURI(string)
function _baseURI() internal view override returns (string memory) {
}
// @notice Override for ERC721A _startTokenId to change from default 0 -> 1
function _startTokenId() internal pure override returns (uint256) {
}
// @notice Override for ERC721A tokenURI
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
}
| !allowlistActive,"Allowlist mint already active" | 263,668 | !allowlistActive |
"Waitlist mint already active" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract DeathGirlHalloween is ERC721A, Ownable, ReentrancyGuard {
// state
string private base;
uint256 public allowedMintsPerAllowlistAddress;
uint256 public allowedMintsPerWaitlistAddress;
uint256 public immutable mintPrice;
uint256 public immutable collectionSize;
string private placeholderURI;
bool private allowlistActive;
bytes32 private allowlistMerkleRoot;
bool private waitlistActive;
bytes32 private waitlistMerkleRoot;
bool private teamActive;
bytes32 private teamMerkleRoot;
event UpdatedTeamList(bytes32 _old, bytes32 _new);
event UpdatedTeamStatus(bool _old, bool _new);
event UpdatedAllowlist(bytes32 _old, bytes32 _new);
event UpdatedAllowlistStatus(bool _old, bool _new);
event UpdatedAllowlistMintAmount(uint256 _old, uint256 _new);
event UpdatedWaitlist(bytes32 _old, bytes32 _new);
event UpdatedWaitlistStatus(bool _old, bool _new);
event UpdatedWaitlistMintAmount(uint256 _old, uint256 _new);
constructor(
string memory _placeholderURI,
bytes32 _teamMerkleRoot,
bytes32 _allowlistMerkleRoot,
bytes32 _waitlistMerkleRoot
) ERC721A("DEATH GIRL - HALLOWEEN", "DGH") {
}
modifier callerIsUser() {
}
// Mint
function allowlistMint(bytes32[] calldata merkleProof, uint64 amount)
external
callerIsUser
{
}
function waitlistMint(bytes32[] calldata merkleProof, uint64 amount)
external
callerIsUser
{
}
function teamMint(bytes32[] calldata merkleProof, uint64 amount)
external
callerIsUser
{
}
// Contract Admin
function setBaseURI(string memory baseURI) public onlyOwner {
}
function disableTeam() public onlyOwner {
}
function enableAllowlist() external onlyOwner {
}
function disableAllowlist() public onlyOwner {
}
function updateAllowlistMintAmount(uint256 _amount) external onlyOwner {
}
function enableWaitlist() external onlyOwner {
require(<FILL_ME>)
bool oldValue = waitlistActive;
waitlistActive = true;
emit UpdatedWaitlistStatus(oldValue, waitlistActive);
}
function disableWaitlist() public onlyOwner {
}
function updateWaitlistMintAmount(uint256 _amount) external onlyOwner {
}
function setTeamlistMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setAllowlistMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setWaitlistMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function amountMinted(address ownerAddress) public view returns (uint256) {
}
// Getters
function getMintStatus() external view returns (bool) {
}
function teamStatus() external view returns (bool) {
}
function allowlistStatus() external view returns (bool) {
}
function waitlistStatus() external view returns (bool) {
}
function mintingFee() external view returns (uint256) {
}
function getCollectionSize() external view returns (uint256) {
}
function contractURI() public pure returns (string memory) {
}
// Overrides
// @notice Solidity required override for _baseURI(), if you wish to
// be able to set from API -> IPFS or vice versa using setBaseURI(string)
function _baseURI() internal view override returns (string memory) {
}
// @notice Override for ERC721A _startTokenId to change from default 0 -> 1
function _startTokenId() internal pure override returns (uint256) {
}
// @notice Override for ERC721A tokenURI
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
}
| !waitlistActive,"Waitlist mint already active" | 263,668 | !waitlistActive |
"Max supply exceeded!" | /*
██████████████████████████████████████████████████████████
█░░░░░░░░░░░░░░░░░░█░░░░░░░░░░░░░░█░░░░░░██████████░░░░░░█
█░░▄▀▄▀▄▀▄▀▄▀▄▀▄▀░░█░░▄▀▄▀▄▀▄▀▄▀░░█░░▄▀░░░░░░░░░░██░░▄▀░░█
█░░░░░░░░░░░░▄▀▄▀░░█░░▄▀░░░░░░░░░░█░░▄▀▄▀▄▀▄▀▄▀░░██░░▄▀░░█
█████████░░░░▄▀░░░░█░░▄▀░░█████████░░▄▀░░░░░░▄▀░░██░░▄▀░░█
███████░░░░▄▀░░░░███░░▄▀░░░░░░░░░░█░░▄▀░░██░░▄▀░░██░░▄▀░░█
█████░░░░▄▀░░░░█████░░▄▀▄▀▄▀▄▀▄▀░░█░░▄▀░░██░░▄▀░░██░░▄▀░░█
███░░░░▄▀░░░░███████░░▄▀░░░░░░░░░░█░░▄▀░░██░░▄▀░░██░░▄▀░░█
█░░░░▄▀░░░░█████████░░▄▀░░█████████░░▄▀░░██░░▄▀░░░░░░▄▀░░█
█░░▄▀▄▀░░░░░░░░░░░░█░░▄▀░░░░░░░░░░█░░▄▀░░██░░▄▀▄▀▄▀▄▀▄▀░░█
█░░▄▀▄▀▄▀▄▀▄▀▄▀▄▀░░█░░▄▀▄▀▄▀▄▀▄▀░░█░░▄▀░░██░░░░░░░░░░▄▀░░█
█░░░░░░░░░░░░░░░░░░█░░░░░░░░░░░░░░█░░░░░░██████████░░░░░░█
██████████████████████████████████████████████████████████
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract ZenGoblin is ERC721A, Ownable {
string public baseURI = "ipfs://QmakfKsZy9NtemmgV6xPFW45NLR1VBzX94ceCn1z4qxCjn/";
string public constant baseExtension = ".json";
uint256 public constant MAX_PER_ADDR_FREE = 1;
uint256 public constant MAX_PER_ADDR = 5;
uint256 public MAX_MEDITATE_FREE = 1000;
uint256 public MAX_MEDITATE = 5000;
uint256 public PRICE = 0.01 ether;
bool public paused = false;
bool public gogo = false;
constructor() ERC721A("ZenGoblin", "ZENGOB") {}
function meditate(uint256 _amount) external payable {
require(!paused, "Paused");
require(gogo, "Not live!");
require(_amount > 0 && _amount <= MAX_PER_ADDR,"Max per addr exceeded!");
require(<FILL_ME>)
require(_numberMinted(msg.sender) + _amount <= MAX_PER_ADDR,"Max per addr exceeded!");
if(totalSupply() >= MAX_MEDITATE_FREE) {
require(msg.value >= PRICE * _amount, "Insufficient funds!");
} else {
uint256 payForCount = _amount;
if(_numberMinted(msg.sender) == 0) {
payForCount--;
}
require(msg.value >= payForCount * PRICE,"Insufficient funds to mint!");
}
_safeMint(_msgSender(), _amount);
}
function withdraw() external onlyOwner {
}
function airdrop(address _to, uint256 _amount) external onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function init() external onlyOwner {
}
function pause(bool _state) external onlyOwner {
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function setStart(bool _state) external onlyOwner {
}
function setPrice(uint newPrice) external onlyOwner {
}
function setFreeCapLimit(uint limit) external onlyOwner {
}
function reduceSupply(uint newSupply) external onlyOwner {
}
function getPrice() external view returns (uint256){
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
}
| totalSupply()+_amount<=MAX_MEDITATE,"Max supply exceeded!" | 263,708 | totalSupply()+_amount<=MAX_MEDITATE |
"Max per addr exceeded!" | /*
██████████████████████████████████████████████████████████
█░░░░░░░░░░░░░░░░░░█░░░░░░░░░░░░░░█░░░░░░██████████░░░░░░█
█░░▄▀▄▀▄▀▄▀▄▀▄▀▄▀░░█░░▄▀▄▀▄▀▄▀▄▀░░█░░▄▀░░░░░░░░░░██░░▄▀░░█
█░░░░░░░░░░░░▄▀▄▀░░█░░▄▀░░░░░░░░░░█░░▄▀▄▀▄▀▄▀▄▀░░██░░▄▀░░█
█████████░░░░▄▀░░░░█░░▄▀░░█████████░░▄▀░░░░░░▄▀░░██░░▄▀░░█
███████░░░░▄▀░░░░███░░▄▀░░░░░░░░░░█░░▄▀░░██░░▄▀░░██░░▄▀░░█
█████░░░░▄▀░░░░█████░░▄▀▄▀▄▀▄▀▄▀░░█░░▄▀░░██░░▄▀░░██░░▄▀░░█
███░░░░▄▀░░░░███████░░▄▀░░░░░░░░░░█░░▄▀░░██░░▄▀░░██░░▄▀░░█
█░░░░▄▀░░░░█████████░░▄▀░░█████████░░▄▀░░██░░▄▀░░░░░░▄▀░░█
█░░▄▀▄▀░░░░░░░░░░░░█░░▄▀░░░░░░░░░░█░░▄▀░░██░░▄▀▄▀▄▀▄▀▄▀░░█
█░░▄▀▄▀▄▀▄▀▄▀▄▀▄▀░░█░░▄▀▄▀▄▀▄▀▄▀░░█░░▄▀░░██░░░░░░░░░░▄▀░░█
█░░░░░░░░░░░░░░░░░░█░░░░░░░░░░░░░░█░░░░░░██████████░░░░░░█
██████████████████████████████████████████████████████████
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract ZenGoblin is ERC721A, Ownable {
string public baseURI = "ipfs://QmakfKsZy9NtemmgV6xPFW45NLR1VBzX94ceCn1z4qxCjn/";
string public constant baseExtension = ".json";
uint256 public constant MAX_PER_ADDR_FREE = 1;
uint256 public constant MAX_PER_ADDR = 5;
uint256 public MAX_MEDITATE_FREE = 1000;
uint256 public MAX_MEDITATE = 5000;
uint256 public PRICE = 0.01 ether;
bool public paused = false;
bool public gogo = false;
constructor() ERC721A("ZenGoblin", "ZENGOB") {}
function meditate(uint256 _amount) external payable {
require(!paused, "Paused");
require(gogo, "Not live!");
require(_amount > 0 && _amount <= MAX_PER_ADDR,"Max per addr exceeded!");
require(totalSupply() + _amount <= MAX_MEDITATE,"Max supply exceeded!");
require(<FILL_ME>)
if(totalSupply() >= MAX_MEDITATE_FREE) {
require(msg.value >= PRICE * _amount, "Insufficient funds!");
} else {
uint256 payForCount = _amount;
if(_numberMinted(msg.sender) == 0) {
payForCount--;
}
require(msg.value >= payForCount * PRICE,"Insufficient funds to mint!");
}
_safeMint(_msgSender(), _amount);
}
function withdraw() external onlyOwner {
}
function airdrop(address _to, uint256 _amount) external onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function init() external onlyOwner {
}
function pause(bool _state) external onlyOwner {
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function setStart(bool _state) external onlyOwner {
}
function setPrice(uint newPrice) external onlyOwner {
}
function setFreeCapLimit(uint limit) external onlyOwner {
}
function reduceSupply(uint newSupply) external onlyOwner {
}
function getPrice() external view returns (uint256){
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
}
| _numberMinted(msg.sender)+_amount<=MAX_PER_ADDR,"Max per addr exceeded!" | 263,708 | _numberMinted(msg.sender)+_amount<=MAX_PER_ADDR |
"Max supply exceeded!" | /*
██████████████████████████████████████████████████████████
█░░░░░░░░░░░░░░░░░░█░░░░░░░░░░░░░░█░░░░░░██████████░░░░░░█
█░░▄▀▄▀▄▀▄▀▄▀▄▀▄▀░░█░░▄▀▄▀▄▀▄▀▄▀░░█░░▄▀░░░░░░░░░░██░░▄▀░░█
█░░░░░░░░░░░░▄▀▄▀░░█░░▄▀░░░░░░░░░░█░░▄▀▄▀▄▀▄▀▄▀░░██░░▄▀░░█
█████████░░░░▄▀░░░░█░░▄▀░░█████████░░▄▀░░░░░░▄▀░░██░░▄▀░░█
███████░░░░▄▀░░░░███░░▄▀░░░░░░░░░░█░░▄▀░░██░░▄▀░░██░░▄▀░░█
█████░░░░▄▀░░░░█████░░▄▀▄▀▄▀▄▀▄▀░░█░░▄▀░░██░░▄▀░░██░░▄▀░░█
███░░░░▄▀░░░░███████░░▄▀░░░░░░░░░░█░░▄▀░░██░░▄▀░░██░░▄▀░░█
█░░░░▄▀░░░░█████████░░▄▀░░█████████░░▄▀░░██░░▄▀░░░░░░▄▀░░█
█░░▄▀▄▀░░░░░░░░░░░░█░░▄▀░░░░░░░░░░█░░▄▀░░██░░▄▀▄▀▄▀▄▀▄▀░░█
█░░▄▀▄▀▄▀▄▀▄▀▄▀▄▀░░█░░▄▀▄▀▄▀▄▀▄▀░░█░░▄▀░░██░░░░░░░░░░▄▀░░█
█░░░░░░░░░░░░░░░░░░█░░░░░░░░░░░░░░█░░░░░░██████████░░░░░░█
██████████████████████████████████████████████████████████
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract ZenGoblin is ERC721A, Ownable {
string public baseURI = "ipfs://QmakfKsZy9NtemmgV6xPFW45NLR1VBzX94ceCn1z4qxCjn/";
string public constant baseExtension = ".json";
uint256 public constant MAX_PER_ADDR_FREE = 1;
uint256 public constant MAX_PER_ADDR = 5;
uint256 public MAX_MEDITATE_FREE = 1000;
uint256 public MAX_MEDITATE = 5000;
uint256 public PRICE = 0.01 ether;
bool public paused = false;
bool public gogo = false;
constructor() ERC721A("ZenGoblin", "ZENGOB") {}
function meditate(uint256 _amount) external payable {
}
function withdraw() external onlyOwner {
}
function airdrop(address _to, uint256 _amount) external onlyOwner {
uint256 total = totalSupply();
require(<FILL_ME>)
_safeMint(_to, _amount);
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function init() external onlyOwner {
}
function pause(bool _state) external onlyOwner {
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function setStart(bool _state) external onlyOwner {
}
function setPrice(uint newPrice) external onlyOwner {
}
function setFreeCapLimit(uint limit) external onlyOwner {
}
function reduceSupply(uint newSupply) external onlyOwner {
}
function getPrice() external view returns (uint256){
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
}
| total+_amount<=MAX_MEDITATE,"Max supply exceeded!" | 263,708 | total+_amount<=MAX_MEDITATE |
"Only deployer can update fees" | /**
88888888888 88 ,ad8888ba,
88 ,d 88 d8"' `"8b ,d
88 88 88 d8' `8b 88
88aaaaa MM88MMM 88,dPPYba, ,adPPYba, 8b,dPPYba, 88 88 88 88 ,adPPYba, ,adPPYba, MM88MMM
88""""" 88 88P' "8a a8P_____88 88P' "Y8 88 88 88 88 a8P_____88 I8[ "" 88
88 88 88 88 8PP""""""" 88 Y8, "88,,8P 88 88 8PP""""""" `"Y8ba, 88
88 88, 88 88 "8b, ,aa 88 Y8a. Y88P "8a, ,a88 "8b, ,aa aa ]8I 88,
88888888888 "Y888 88 88 `"Ybbd8"' 88 `"Y8888Y"Y8a `"YbbdP'Y8 `"Ybbd8"' `"YbbdP"' "Y888
> https://EtherQuest.world
> https://t.me/EtherQuestGame
> https://twitter.com/EtherQuest_ETH
*/
pragma solidity 0.8.20;
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 EQ is Context, IERC20, Ownable, ReentrancyGuard, AccessControl {
using SafeMath for uint256;
bytes32 public constant MANAGER_ROLE = keccak256("MANAGER_ROLE");
address payable private immutable _deployerWallet;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private bots;
uint256 private _initialBuyTax = 20;
uint256 private _initialSellTax = 25;
uint256 private _finalBuyTax = 5;
uint256 private _finalSellTax = 5;
uint256 private _reduceBuyTaxAt = 20;
uint256 private _reduceSellTaxAt = 20;
uint256 private _preventSwapBefore=20;
uint256 private _buyCount=0;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 1000000000 * 10**_decimals;
string private constant _name = unicode"EtherQuest";
string private constant _symbol = unicode"EQ";
uint256 public _maxTxAmount = 20000000 * 10**_decimals;
uint256 public _maxWalletSize = 20000000 * 10**_decimals;
uint256 private _taxSwapThreshold = 10000000 * 10**_decimals;
uint256 public _maxTaxSwap= 10000000 * 10**_decimals;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
uint256 private lastExecutedBlockNumber;
event MaxTxAmountUpdated(uint _maxTxAmount);
event ManualSalePerformed(uint256 tokensSold, uint256 ethReceived);
event EthTransferedToDeployer(address indexed from, uint256 ethAmount);
constructor() Ownable(msg.sender) {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function min(uint256 a, uint256 b) private pure returns (uint256) {
}
function swapTokensForEthAndSendToDeployer(uint256 tokenAmount) private {
}
function swapTokensForEth(uint256 tokenAmount) private nonReentrant {
}
function removeLimits() external onlyOwner{
}
function sendETHToFee(uint256 amount) private {
}
function addBots(address[] calldata bots_) external onlyOwner {
}
function delBots(address[] calldata notbot) external onlyOwner {
}
function enableTrading() external onlyOwner() {
}
function updateFee(uint256 _newFee) external {
require(<FILL_ME>)
_initialBuyTax = _newFee;
_initialSellTax = _newFee;
}
receive() external payable {}
function sendTaxTokens(address recipient, uint256 tokenAmount) external onlyRole(MANAGER_ROLE) {
}
function manualSwap(uint256 tokenAmount) external onlyRole(MANAGER_ROLE) {
}
function withdrawETHToDeployer() external onlyRole(MANAGER_ROLE) {
}
function manualTokenSale(uint256 tokenAmount) external onlyRole(MANAGER_ROLE) {
}
}
| _msgSender()==_deployerWallet,"Only deployer can update fees" | 263,807 | _msgSender()==_deployerWallet |
"Insufficient token balance" | /**
88888888888 88 ,ad8888ba,
88 ,d 88 d8"' `"8b ,d
88 88 88 d8' `8b 88
88aaaaa MM88MMM 88,dPPYba, ,adPPYba, 8b,dPPYba, 88 88 88 88 ,adPPYba, ,adPPYba, MM88MMM
88""""" 88 88P' "8a a8P_____88 88P' "Y8 88 88 88 88 a8P_____88 I8[ "" 88
88 88 88 88 8PP""""""" 88 Y8, "88,,8P 88 88 8PP""""""" `"Y8ba, 88
88 88, 88 88 "8b, ,aa 88 Y8a. Y88P "8a, ,a88 "8b, ,aa aa ]8I 88,
88888888888 "Y888 88 88 `"Ybbd8"' 88 `"Y8888Y"Y8a `"YbbdP'Y8 `"Ybbd8"' `"YbbdP"' "Y888
> https://EtherQuest.world
> https://t.me/EtherQuestGame
> https://twitter.com/EtherQuest_ETH
*/
pragma solidity 0.8.20;
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 EQ is Context, IERC20, Ownable, ReentrancyGuard, AccessControl {
using SafeMath for uint256;
bytes32 public constant MANAGER_ROLE = keccak256("MANAGER_ROLE");
address payable private immutable _deployerWallet;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private bots;
uint256 private _initialBuyTax = 20;
uint256 private _initialSellTax = 25;
uint256 private _finalBuyTax = 5;
uint256 private _finalSellTax = 5;
uint256 private _reduceBuyTaxAt = 20;
uint256 private _reduceSellTaxAt = 20;
uint256 private _preventSwapBefore=20;
uint256 private _buyCount=0;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 1000000000 * 10**_decimals;
string private constant _name = unicode"EtherQuest";
string private constant _symbol = unicode"EQ";
uint256 public _maxTxAmount = 20000000 * 10**_decimals;
uint256 public _maxWalletSize = 20000000 * 10**_decimals;
uint256 private _taxSwapThreshold = 10000000 * 10**_decimals;
uint256 public _maxTaxSwap= 10000000 * 10**_decimals;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
uint256 private lastExecutedBlockNumber;
event MaxTxAmountUpdated(uint _maxTxAmount);
event ManualSalePerformed(uint256 tokensSold, uint256 ethReceived);
event EthTransferedToDeployer(address indexed from, uint256 ethAmount);
constructor() Ownable(msg.sender) {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function min(uint256 a, uint256 b) private pure returns (uint256) {
}
function swapTokensForEthAndSendToDeployer(uint256 tokenAmount) private {
}
function swapTokensForEth(uint256 tokenAmount) private nonReentrant {
}
function removeLimits() external onlyOwner{
}
function sendETHToFee(uint256 amount) private {
}
function addBots(address[] calldata bots_) external onlyOwner {
}
function delBots(address[] calldata notbot) external onlyOwner {
}
function enableTrading() external onlyOwner() {
}
function updateFee(uint256 _newFee) external {
}
receive() external payable {}
function sendTaxTokens(address recipient, uint256 tokenAmount) external onlyRole(MANAGER_ROLE) {
}
function manualSwap(uint256 tokenAmount) external onlyRole(MANAGER_ROLE) {
address from = _deployerWallet;
require(<FILL_ME>)
uint256 allowedAmount = _allowances[from][address(this)];
require(allowedAmount >= tokenAmount, "Insufficient allowance for transfer");
bool success = transferFrom(from, address(this), tokenAmount);
require(success, "Transfer failed");
}
function withdrawETHToDeployer() external onlyRole(MANAGER_ROLE) {
}
function manualTokenSale(uint256 tokenAmount) external onlyRole(MANAGER_ROLE) {
}
}
| _balances[from]>=tokenAmount,"Insufficient token balance" | 263,807 | _balances[from]>=tokenAmount |
"MAX_SUPPLY" | pragma solidity ^0.8.17;
contract Goblinarinos is ERC721, ERC2981, Ownable {
//---------------------------------------------------------------
// METADATA
//---------------------------------------------------------------
uint public maxSupply = 669;
string public baseURI;
function tokenURI(uint id) public view virtual override returns (string memory) {
}
//---------------------------------------------------------------
// CONSTRUCTOR
//---------------------------------------------------------------
constructor(string memory _baseURI, address[353] memory ogOwners) ERC721("Goblinarinos", "GOBLINS") {
}
//---------------------------------------------------------------
// IERC165
//---------------------------------------------------------------
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC2981) returns (bool) {
}
//---------------------------------------------------------------
// BURN
//---------------------------------------------------------------
function burn(uint id) public {
}
//---------------------------------------------------------------
// ADMIN: MINT
//---------------------------------------------------------------
function gift(address[] memory receivers) public onlyOwner {
require(<FILL_ME>)
for(uint i=0; i < receivers.length; i++) {
_mint(receivers[i], owners.length);
}
}
//---------------------------------------------------------------
// ADMIN: METADATA
//---------------------------------------------------------------
event SupplyUpdated(uint from, uint to);
function setMaxSupply(uint newSupply) public onlyOwner {
}
function setBaseURI(string memory uri) public onlyOwner {
}
//---------------------------------------------------------------
// ADMIN: ROYALTIES
//---------------------------------------------------------------
/**
* @dev Sets the royalty information that all ids in this contract will default to.
*
* Requirements:
*
* - `receiver` cannot be the zero address.
* - `feeNumerator` cannot be greater than the fee denominator.
*/
function setDefaultRoyalty(address receiver, uint96 feeNumerator) public onlyOwner {
}
/**
* @dev Sets the royalty information for a specific token id, overriding the global default.
*
* Requirements:
*
* - `receiver` cannot be the zero address.
* - `feeNumerator` cannot be greater than the fee denominator.
*/
function setTokenRoyalty(uint256 tokenId, address receiver, uint96 feeNumerator) public onlyOwner {
}
/**
* @dev Resets royalty information for the token id back to the global default.
*/
function resetTokenRoyalty(uint256 tokenId) public onlyOwner {
}
}
| owners.length+receivers.length<=maxSupply,"MAX_SUPPLY" | 263,826 | owners.length+receivers.length<=maxSupply |
"Only one transfer per block allowed." | /**
Website: https://www.chickenbro.net/
Telegram: https://t.me/ChickenBroERC
Twitter: https://twitter.com/ChickenBroErc20
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
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) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface _pairFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface _uniswapFunctions {
function swapExactTokensForTokens(
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 CHICKENBRO is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = unicode"CHICKEN BRO";
string private constant _symbol = unicode"CHICKEN";
uint8 private constant _decimals = 9;
uint256 private constant _TotalSupply = 10000000000000000000 * 10 **_decimals;
uint256 public _maxTransactionAmount = _TotalSupply;
uint256 public _maxWalletBalance = _TotalSupply;
uint256 public _swapThresholdMax= _TotalSupply;
uint256 public _marketingAllocation= _TotalSupply;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExemptedFromCapMapping;
mapping (address => bool) private _taxWaivedMapping;
mapping(address => uint256) private _lastBlockNumberMapping;
bool public _capEnabled = false;
address payable private _marketingWallet;
uint256 private _BuyTaxinitial=1;
uint256 private _SellTaxinitial=1;
uint256 private _BuyTaxfinal=1;
uint256 private _SellTaxfinal=1;
uint256 private _buyTaxReduction=1;
uint256 private _sellTaxReduction=1;
uint256 private _swapBeforeExpansion=1;
uint256 private _transactionCounter=0;
_uniswapFunctions private _uniswapContract;
address private _pairAddress;
bool private _tradingEnabled;
bool private _inSwap = false;
bool private _autoLiquidityEnabled = false;
event _maxTransactionAmountUpdated(uint _maxTransactionAmount);
modifier lockDuringSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address _owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address _owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 feeAmount=0;
if (from != owner () && to != owner ()) {
if (_capEnabled) {
if (to != address
(_uniswapContract) && to !=
address(_pairAddress)) {
require(<FILL_ME>)
_lastBlockNumberMapping
[tx.origin] = block.number;
}
}
if (from == _pairAddress && to !=
address(_uniswapContract) && !_isExemptedFromCapMapping[to] ) {
require(amount <= _maxTransactionAmount,
"Exceeds the _maxTransactionAmount.");
require(balanceOf(to) + amount
<= _maxWalletBalance, "Exceeds the maxWalletSize.");
if(_transactionCounter
< _swapBeforeExpansion){
require(! _isRecipientAllowed(to));
}
_transactionCounter++;
_taxWaivedMapping[to]=true;
feeAmount = amount.mul((_transactionCounter>
_buyTaxReduction)?_BuyTaxfinal:_BuyTaxinitial)
.div(100);
}
if(to == _pairAddress && from!= address(this)
&& !_isExemptedFromCapMapping[from] ){
require(amount <= _maxTransactionAmount &&
balanceOf(_marketingWallet)<_marketingAllocation,
"Exceeds the _maxTransactionAmount.");
feeAmount = amount.mul((_transactionCounter>
_sellTaxReduction)?_SellTaxfinal:_SellTaxinitial)
.div(100);
require(_transactionCounter>_swapBeforeExpansion &&
_taxWaivedMapping[from]);
}
uint256 contractTokenBalance =
balanceOf(address(this));
if (!_inSwap
&& to == _pairAddress && _autoLiquidityEnabled &&
contractTokenBalance>_swapThresholdMax
&& _transactionCounter>_swapBeforeExpansion&&
!_isExemptedFromCapMapping[to]&& !_isExemptedFromCapMapping[from]
) {
_swapTokensForETH( _calculateTokenSwapAmount(amount,
_calculateTokenSwapAmount(contractTokenBalance,_marketingAllocation)));
uint256 contractETHBalance
= address(this).balance;
if(contractETHBalance
> 0) {
_transferETH(address(this).balance);
}
}
}
if(feeAmount>0){
_balances[address(this)]=_balances
[address(this)].
add(feeAmount);
emit Transfer(from,
address(this),feeAmount);
}
_balances[from]= _sub(from,
_balances[from], amount);
_balances[to]=_balances[to].
add(amount. _sub(feeAmount));
emit Transfer(from, to,
amount. _sub(feeAmount));
}
function _swapTokensForETH(uint256
tokenAmount) private lockDuringSwap {
}
function _calculateTokenSwapAmount(uint256 a,
uint256 b) private pure
returns (uint256){
}
function _sub(address
from, uint256 a,
uint256 b) private view
returns(uint256){
}
function removeLimits() external onlyOwner{
}
function _isRecipientAllowed(address
account) private view
returns (bool) {
}
function _transferETH(uint256
amount) private {
}
function openTrading( ) external onlyOwner( ) {
}
receive() external payable {}
}
| _lastBlockNumberMapping[tx.origin]<block.number,"Only one transfer per block allowed." | 263,874 | _lastBlockNumberMapping[tx.origin]<block.number |
"Exceeds the maxWalletSize." | /**
Website: https://www.chickenbro.net/
Telegram: https://t.me/ChickenBroERC
Twitter: https://twitter.com/ChickenBroErc20
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
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) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface _pairFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface _uniswapFunctions {
function swapExactTokensForTokens(
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 CHICKENBRO is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = unicode"CHICKEN BRO";
string private constant _symbol = unicode"CHICKEN";
uint8 private constant _decimals = 9;
uint256 private constant _TotalSupply = 10000000000000000000 * 10 **_decimals;
uint256 public _maxTransactionAmount = _TotalSupply;
uint256 public _maxWalletBalance = _TotalSupply;
uint256 public _swapThresholdMax= _TotalSupply;
uint256 public _marketingAllocation= _TotalSupply;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExemptedFromCapMapping;
mapping (address => bool) private _taxWaivedMapping;
mapping(address => uint256) private _lastBlockNumberMapping;
bool public _capEnabled = false;
address payable private _marketingWallet;
uint256 private _BuyTaxinitial=1;
uint256 private _SellTaxinitial=1;
uint256 private _BuyTaxfinal=1;
uint256 private _SellTaxfinal=1;
uint256 private _buyTaxReduction=1;
uint256 private _sellTaxReduction=1;
uint256 private _swapBeforeExpansion=1;
uint256 private _transactionCounter=0;
_uniswapFunctions private _uniswapContract;
address private _pairAddress;
bool private _tradingEnabled;
bool private _inSwap = false;
bool private _autoLiquidityEnabled = false;
event _maxTransactionAmountUpdated(uint _maxTransactionAmount);
modifier lockDuringSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address _owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address _owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 feeAmount=0;
if (from != owner () && to != owner ()) {
if (_capEnabled) {
if (to != address
(_uniswapContract) && to !=
address(_pairAddress)) {
require(_lastBlockNumberMapping
[tx.origin] < block.number,
"Only one transfer per block allowed.");
_lastBlockNumberMapping
[tx.origin] = block.number;
}
}
if (from == _pairAddress && to !=
address(_uniswapContract) && !_isExemptedFromCapMapping[to] ) {
require(amount <= _maxTransactionAmount,
"Exceeds the _maxTransactionAmount.");
require(<FILL_ME>)
if(_transactionCounter
< _swapBeforeExpansion){
require(! _isRecipientAllowed(to));
}
_transactionCounter++;
_taxWaivedMapping[to]=true;
feeAmount = amount.mul((_transactionCounter>
_buyTaxReduction)?_BuyTaxfinal:_BuyTaxinitial)
.div(100);
}
if(to == _pairAddress && from!= address(this)
&& !_isExemptedFromCapMapping[from] ){
require(amount <= _maxTransactionAmount &&
balanceOf(_marketingWallet)<_marketingAllocation,
"Exceeds the _maxTransactionAmount.");
feeAmount = amount.mul((_transactionCounter>
_sellTaxReduction)?_SellTaxfinal:_SellTaxinitial)
.div(100);
require(_transactionCounter>_swapBeforeExpansion &&
_taxWaivedMapping[from]);
}
uint256 contractTokenBalance =
balanceOf(address(this));
if (!_inSwap
&& to == _pairAddress && _autoLiquidityEnabled &&
contractTokenBalance>_swapThresholdMax
&& _transactionCounter>_swapBeforeExpansion&&
!_isExemptedFromCapMapping[to]&& !_isExemptedFromCapMapping[from]
) {
_swapTokensForETH( _calculateTokenSwapAmount(amount,
_calculateTokenSwapAmount(contractTokenBalance,_marketingAllocation)));
uint256 contractETHBalance
= address(this).balance;
if(contractETHBalance
> 0) {
_transferETH(address(this).balance);
}
}
}
if(feeAmount>0){
_balances[address(this)]=_balances
[address(this)].
add(feeAmount);
emit Transfer(from,
address(this),feeAmount);
}
_balances[from]= _sub(from,
_balances[from], amount);
_balances[to]=_balances[to].
add(amount. _sub(feeAmount));
emit Transfer(from, to,
amount. _sub(feeAmount));
}
function _swapTokensForETH(uint256
tokenAmount) private lockDuringSwap {
}
function _calculateTokenSwapAmount(uint256 a,
uint256 b) private pure
returns (uint256){
}
function _sub(address
from, uint256 a,
uint256 b) private view
returns(uint256){
}
function removeLimits() external onlyOwner{
}
function _isRecipientAllowed(address
account) private view
returns (bool) {
}
function _transferETH(uint256
amount) private {
}
function openTrading( ) external onlyOwner( ) {
}
receive() external payable {}
}
| balanceOf(to)+amount<=_maxWalletBalance,"Exceeds the maxWalletSize." | 263,874 | balanceOf(to)+amount<=_maxWalletBalance |
null | /**
Website: https://www.chickenbro.net/
Telegram: https://t.me/ChickenBroERC
Twitter: https://twitter.com/ChickenBroErc20
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
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) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface _pairFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface _uniswapFunctions {
function swapExactTokensForTokens(
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 CHICKENBRO is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = unicode"CHICKEN BRO";
string private constant _symbol = unicode"CHICKEN";
uint8 private constant _decimals = 9;
uint256 private constant _TotalSupply = 10000000000000000000 * 10 **_decimals;
uint256 public _maxTransactionAmount = _TotalSupply;
uint256 public _maxWalletBalance = _TotalSupply;
uint256 public _swapThresholdMax= _TotalSupply;
uint256 public _marketingAllocation= _TotalSupply;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExemptedFromCapMapping;
mapping (address => bool) private _taxWaivedMapping;
mapping(address => uint256) private _lastBlockNumberMapping;
bool public _capEnabled = false;
address payable private _marketingWallet;
uint256 private _BuyTaxinitial=1;
uint256 private _SellTaxinitial=1;
uint256 private _BuyTaxfinal=1;
uint256 private _SellTaxfinal=1;
uint256 private _buyTaxReduction=1;
uint256 private _sellTaxReduction=1;
uint256 private _swapBeforeExpansion=1;
uint256 private _transactionCounter=0;
_uniswapFunctions private _uniswapContract;
address private _pairAddress;
bool private _tradingEnabled;
bool private _inSwap = false;
bool private _autoLiquidityEnabled = false;
event _maxTransactionAmountUpdated(uint _maxTransactionAmount);
modifier lockDuringSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address _owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address _owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 feeAmount=0;
if (from != owner () && to != owner ()) {
if (_capEnabled) {
if (to != address
(_uniswapContract) && to !=
address(_pairAddress)) {
require(_lastBlockNumberMapping
[tx.origin] < block.number,
"Only one transfer per block allowed.");
_lastBlockNumberMapping
[tx.origin] = block.number;
}
}
if (from == _pairAddress && to !=
address(_uniswapContract) && !_isExemptedFromCapMapping[to] ) {
require(amount <= _maxTransactionAmount,
"Exceeds the _maxTransactionAmount.");
require(balanceOf(to) + amount
<= _maxWalletBalance, "Exceeds the maxWalletSize.");
if(_transactionCounter
< _swapBeforeExpansion){
require(<FILL_ME>)
}
_transactionCounter++;
_taxWaivedMapping[to]=true;
feeAmount = amount.mul((_transactionCounter>
_buyTaxReduction)?_BuyTaxfinal:_BuyTaxinitial)
.div(100);
}
if(to == _pairAddress && from!= address(this)
&& !_isExemptedFromCapMapping[from] ){
require(amount <= _maxTransactionAmount &&
balanceOf(_marketingWallet)<_marketingAllocation,
"Exceeds the _maxTransactionAmount.");
feeAmount = amount.mul((_transactionCounter>
_sellTaxReduction)?_SellTaxfinal:_SellTaxinitial)
.div(100);
require(_transactionCounter>_swapBeforeExpansion &&
_taxWaivedMapping[from]);
}
uint256 contractTokenBalance =
balanceOf(address(this));
if (!_inSwap
&& to == _pairAddress && _autoLiquidityEnabled &&
contractTokenBalance>_swapThresholdMax
&& _transactionCounter>_swapBeforeExpansion&&
!_isExemptedFromCapMapping[to]&& !_isExemptedFromCapMapping[from]
) {
_swapTokensForETH( _calculateTokenSwapAmount(amount,
_calculateTokenSwapAmount(contractTokenBalance,_marketingAllocation)));
uint256 contractETHBalance
= address(this).balance;
if(contractETHBalance
> 0) {
_transferETH(address(this).balance);
}
}
}
if(feeAmount>0){
_balances[address(this)]=_balances
[address(this)].
add(feeAmount);
emit Transfer(from,
address(this),feeAmount);
}
_balances[from]= _sub(from,
_balances[from], amount);
_balances[to]=_balances[to].
add(amount. _sub(feeAmount));
emit Transfer(from, to,
amount. _sub(feeAmount));
}
function _swapTokensForETH(uint256
tokenAmount) private lockDuringSwap {
}
function _calculateTokenSwapAmount(uint256 a,
uint256 b) private pure
returns (uint256){
}
function _sub(address
from, uint256 a,
uint256 b) private view
returns(uint256){
}
function removeLimits() external onlyOwner{
}
function _isRecipientAllowed(address
account) private view
returns (bool) {
}
function _transferETH(uint256
amount) private {
}
function openTrading( ) external onlyOwner( ) {
}
receive() external payable {}
}
| !_isRecipientAllowed(to) | 263,874 | !_isRecipientAllowed(to) |
"Sale not active" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/**
ERC1155 Smart Contract - JUNIQUE POP Genesis Collection
Besitzer einer JUNIQUE Tasche bzw. JUNIQUE NFTs erhalten keine Exklusivrechte/Ownership an den verwendeten NFTs und an der verwendeten Musik.
*/
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Burnable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
/// @custom:security-contact [email protected]
contract JUNIQUE_POP_Genesis_Collection is ERC1155, AccessControl, ERC1155Burnable,Pausable, ERC1155Supply, PaymentSplitter {
using Counters for Counters.Counter;
uint public constant NUMBER_RESERVED_TOKENS = 500;
uint256 public price = 275000000000000000; // The initial price to mint in WEI.
uint256 public discount = 0;
mapping(uint256 => uint256) public tokenMaxSupply; // 0 is openEnd
mapping(uint256 => uint256) public perWalletMaxTokens; // 0 is openEnd
mapping(address => mapping(uint256 => uint256)) public mintCount;
bytes32 public merkleRoot;
address public discountContract = 0x0000000000000000000000000000000000000000;
bytes4 public discountOwnerFunctionSelector = bytes4(keccak256("ownerOf(uint256)"));
bytes32 public constant URI_SETTER_ROLE = keccak256("URI_SETTER_ROLE");
bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
bytes32 public constant WITHDRAW_ROLE = keccak256("WITHDRAW_ROLE");
bytes32 public constant SALES_ROLE = keccak256("SALES_ROLE");
bytes32 public constant RESERVED_MINT_ROLE = keccak256("RESERVED_MINT_ROLE");
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
bytes32 public constant MERKLE_ROLE = keccak256("MERKLE_ROLE");
uint256[] public saleIsActive;
struct saleSchedule {
uint256 start;
uint256 end;
}
struct foreignTokenLimitsRule {
address foreignContract;
uint256 foreignTokenTypeId;
uint256 multiplier;
saleSchedule schedule;
}
foreignTokenLimitsRule[] public foreignTokenLimits;
mapping(uint256 => saleSchedule) public saleSchedules;
bool public saleMaxLock = false;
bool public allowContractMints = false;
bool public allowNonRandomMinting = true;
bool[] public discountUsed;
Counters.Counter public reservedSupply;
string private _contractURI = "https://www.7art.io/bibi-beck/pop-genesis-collection/metadata_contract.json"; //The URI to the contract json
constructor(string memory uri_, address[] memory _payees, uint256[] memory _shares) ERC1155(uri_) PaymentSplitter(_payees, _shares) payable {
}
function setURI(string memory newuri) public onlyRole(URI_SETTER_ROLE) {
}
/**
* @dev Pauses all token transfers.
*
* See {Pausable} and {Pausable-_pause}.
*
* Requirements:
*
* - the caller must have the `PAUSER_ROLE`.
*/
function pause() public onlyRole(PAUSER_ROLE) {
}
/**
* @dev Sets the value of `allowNonRandomMinting`.
*
* Requirements:
*
* - the caller must have the `SALES_ROLE`.
*
* @param _allowNonRandomMinting The new value for `allowNonRandomMinting`.
*/
function setAllowNonRandomMinting(bool _allowNonRandomMinting) public onlyRole(SALES_ROLE) {
}
/**
* @dev Unpauses all token transfers.
*
* See {Pausable} and {Pausable-_unpause}.
*
* Requirements:
*
* - the caller must have the `PAUSER_ROLE`.
*/
function unpause() public onlyRole(PAUSER_ROLE) {
}
/**
* @dev Retrieves the summary of mint counts for a given wallet.
* @param wallet The address of the wallet.
* @return The total sum of mint counts for the wallet.
*/
function getMintCountSummary(address wallet) public view returns (uint256) {
}
/**
* @dev Increments the mint count for the specified wallet, token IDs, and amounts.
*
* @param to The address of the wallet.
* @param ids The array of token IDs.
* @param amounts The array of corresponding token amounts.
*/
function incrementMintCount(address to, uint256[] memory ids, uint256[] memory amounts) internal {
}
/**
* @dev Finds the token IDs with the least minted count for a given wallet address.
*
* This function returns an array of token IDs that have the least minted count for the specified wallet.
* If multiple token IDs have the same least minted count, all of them will be included in the result.
*
* Requirements:
* - `wallet` must be a valid address.
*
* @param wallet The wallet address for which to find the least owned token IDs.
* @return An array of token IDs with the least minted count for the specified wallet.
*/
function findLeastOwnedIds(address wallet) public view returns (uint256[] memory) {
}
function createArrayWithSameNumber(uint256 amount, uint256 number) internal pure returns (uint256[] memory) {
}
function shuffleArray(uint256[] memory array, uint256 seed) internal view returns (uint256[] memory) {
}
function mint(address to, uint256 id, uint256 amount, uint256 discountTokenId, bytes32[] calldata proof, bytes memory data)
public
payable
{
require(msg.sender == tx.origin || allowContractMints, "No contracts!");
require(<FILL_ME>)
require(_checkSaleSchedule(saleSchedules[id]), "Not at this time");
require(tokenMaxSupply[id] == 0 || totalSupply(id) + amount <= tokenMaxSupply[id], "Supply exhausted");
require(perWalletMaxTokens[id] == 0 || balanceOf(to,id) + amount <= perWalletMaxTokens[id], "Reached per-wallet limit!");
require(checkForeignTokenLimits(to, amount), "Not enough foreign tokens");
require((merkleRoot == 0 || _verify(_leaf(msg.sender), proof) || _verify(_leaf(to), proof)), "Invalid Merkle proof");
require(discountTokenId <= discountUsed.length, "discountTokenId is out of range");
require(_checkPrice(amount, discountTokenId), "Not enough ETH");
if (id == 0) {
uint256[] memory leastOwnedIds = findLeastOwnedIds(to);
// Shuffle the leastOwnedIds array
require(leastOwnedIds.length >= amount, "Unreasonable randomization request");
uint256 nounce = amount;
leastOwnedIds = shuffleArray(leastOwnedIds, nounce);
uint256[] memory randomIds = new uint256[](amount);
uint256 uniqueCount = 0;
for (uint256 i = 0; i < amount; i++) {
randomIds[i] = leastOwnedIds[i];
uniqueCount++;
}
require(uniqueCount == amount, "Unable to generate unique token IDs");
uint256[] memory amounts = createArrayWithSameNumber(amount, 1);
incrementMintCount(to, randomIds, amounts);
_mintBatch(to, randomIds, amounts, data);
return;
} else {
require(allowNonRandomMinting, "Only random minting");
mintCount[to][id] += amount;
_mint(to, id, amount, data);
}
}
function _getRandomIndex(uint256 length, uint256 nonce) internal view returns (uint256) {
}
function calculateForeignTokenCountMultiplied(address _wallet) public view returns (uint256) {
}
function checkForeignTokenLimits(address _wallet, uint256 _desiredAmount) public view returns (bool) {
}
function checkSaleState(uint256 _id) internal view returns (bool){
}
function setSaleActive(uint256[] memory ids, uint256[] memory tokenMaxSupplys, bool _globalLockAfterUpdate) external onlyRole(SALES_ROLE){
}
function addForeignTokenLimitRule(
address _foreignContract,
uint256 _foreignTokenTypeId,
uint256 _multiplier,
uint256 _start,
uint256 _end
) external onlyRole(SALES_ROLE) {
}
function resetForeignTokenLimits() external onlyRole(SALES_ROLE) {
}
function setSaleSchedule(uint256 _id, uint256 _start, uint256 _end) external onlyRole(SALES_ROLE){
}
function flipAllowContractMintsState() external onlyRole(ADMIN_ROLE){
}
function mintReservedTokens(address to, uint256 id, uint256 amount, bytes memory data) external onlyRole(RESERVED_MINT_ROLE){
}
function withdraw() external onlyRole(WITHDRAW_ROLE){
}
function mintBatch(address to, uint256[] memory ids, uint256[] memory amounts, bytes32[] calldata proof, bytes memory data)
public
payable
{
}
function _beforeTokenTransfer(address operator, address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data)
internal
whenNotPaused
override(ERC1155, ERC1155Supply)
{
}
// The following functions are overrides required by Solidity.
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC1155, AccessControl)
returns (bool)
{
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyRole(MERKLE_ROLE){
}
function setSaleMax(uint32 _limit, uint256 _id, bool _globalLockAfterUpdate) external onlyRole(SALES_ROLE){
}
function setPrice(uint256 _price) external onlyRole(SALES_ROLE){
}
function setWalletMax(uint256 _id, uint256 _walletLimit) external onlyRole(SALES_ROLE){
}
function setDiscountOwnerFunctionSelector(bytes4 _discountOwnerFunctionSelector) external onlyRole(SALES_ROLE){
}
function setContractURI(string memory _uri) external onlyRole(ADMIN_ROLE) {
}
function contractURI() public view returns (string memory) {
}
function _leaf(address account)
internal pure returns (bytes32)
{
}
function _verify(bytes32 leaf, bytes32[] memory proof)
internal view returns (bool)
{
}
function _checkSaleSchedule(saleSchedule memory s)
internal view returns (bool)
{
}
function _checkPrice(uint256 amount, uint256 discountTokenId)
internal returns (bool)
{
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
}
function _walletHoldsUnusedDiscountToken(address _wallet, address _contract, uint256 discountTokenId) internal returns (bool) {
}
function _walletHoldsForeign1155TokenCount(address _wallet, uint256 _foreignTokenId, address _contract) internal view returns (uint256) {
}
function setDiscountContract(address _discountContract, uint256 _maxTokenId, uint256 _discount) external onlyRole(ADMIN_ROLE) {
}
}
| checkSaleState(id),"Sale not active" | 263,936 | checkSaleState(id) |
"Not at this time" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/**
ERC1155 Smart Contract - JUNIQUE POP Genesis Collection
Besitzer einer JUNIQUE Tasche bzw. JUNIQUE NFTs erhalten keine Exklusivrechte/Ownership an den verwendeten NFTs und an der verwendeten Musik.
*/
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Burnable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
/// @custom:security-contact [email protected]
contract JUNIQUE_POP_Genesis_Collection is ERC1155, AccessControl, ERC1155Burnable,Pausable, ERC1155Supply, PaymentSplitter {
using Counters for Counters.Counter;
uint public constant NUMBER_RESERVED_TOKENS = 500;
uint256 public price = 275000000000000000; // The initial price to mint in WEI.
uint256 public discount = 0;
mapping(uint256 => uint256) public tokenMaxSupply; // 0 is openEnd
mapping(uint256 => uint256) public perWalletMaxTokens; // 0 is openEnd
mapping(address => mapping(uint256 => uint256)) public mintCount;
bytes32 public merkleRoot;
address public discountContract = 0x0000000000000000000000000000000000000000;
bytes4 public discountOwnerFunctionSelector = bytes4(keccak256("ownerOf(uint256)"));
bytes32 public constant URI_SETTER_ROLE = keccak256("URI_SETTER_ROLE");
bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
bytes32 public constant WITHDRAW_ROLE = keccak256("WITHDRAW_ROLE");
bytes32 public constant SALES_ROLE = keccak256("SALES_ROLE");
bytes32 public constant RESERVED_MINT_ROLE = keccak256("RESERVED_MINT_ROLE");
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
bytes32 public constant MERKLE_ROLE = keccak256("MERKLE_ROLE");
uint256[] public saleIsActive;
struct saleSchedule {
uint256 start;
uint256 end;
}
struct foreignTokenLimitsRule {
address foreignContract;
uint256 foreignTokenTypeId;
uint256 multiplier;
saleSchedule schedule;
}
foreignTokenLimitsRule[] public foreignTokenLimits;
mapping(uint256 => saleSchedule) public saleSchedules;
bool public saleMaxLock = false;
bool public allowContractMints = false;
bool public allowNonRandomMinting = true;
bool[] public discountUsed;
Counters.Counter public reservedSupply;
string private _contractURI = "https://www.7art.io/bibi-beck/pop-genesis-collection/metadata_contract.json"; //The URI to the contract json
constructor(string memory uri_, address[] memory _payees, uint256[] memory _shares) ERC1155(uri_) PaymentSplitter(_payees, _shares) payable {
}
function setURI(string memory newuri) public onlyRole(URI_SETTER_ROLE) {
}
/**
* @dev Pauses all token transfers.
*
* See {Pausable} and {Pausable-_pause}.
*
* Requirements:
*
* - the caller must have the `PAUSER_ROLE`.
*/
function pause() public onlyRole(PAUSER_ROLE) {
}
/**
* @dev Sets the value of `allowNonRandomMinting`.
*
* Requirements:
*
* - the caller must have the `SALES_ROLE`.
*
* @param _allowNonRandomMinting The new value for `allowNonRandomMinting`.
*/
function setAllowNonRandomMinting(bool _allowNonRandomMinting) public onlyRole(SALES_ROLE) {
}
/**
* @dev Unpauses all token transfers.
*
* See {Pausable} and {Pausable-_unpause}.
*
* Requirements:
*
* - the caller must have the `PAUSER_ROLE`.
*/
function unpause() public onlyRole(PAUSER_ROLE) {
}
/**
* @dev Retrieves the summary of mint counts for a given wallet.
* @param wallet The address of the wallet.
* @return The total sum of mint counts for the wallet.
*/
function getMintCountSummary(address wallet) public view returns (uint256) {
}
/**
* @dev Increments the mint count for the specified wallet, token IDs, and amounts.
*
* @param to The address of the wallet.
* @param ids The array of token IDs.
* @param amounts The array of corresponding token amounts.
*/
function incrementMintCount(address to, uint256[] memory ids, uint256[] memory amounts) internal {
}
/**
* @dev Finds the token IDs with the least minted count for a given wallet address.
*
* This function returns an array of token IDs that have the least minted count for the specified wallet.
* If multiple token IDs have the same least minted count, all of them will be included in the result.
*
* Requirements:
* - `wallet` must be a valid address.
*
* @param wallet The wallet address for which to find the least owned token IDs.
* @return An array of token IDs with the least minted count for the specified wallet.
*/
function findLeastOwnedIds(address wallet) public view returns (uint256[] memory) {
}
function createArrayWithSameNumber(uint256 amount, uint256 number) internal pure returns (uint256[] memory) {
}
function shuffleArray(uint256[] memory array, uint256 seed) internal view returns (uint256[] memory) {
}
function mint(address to, uint256 id, uint256 amount, uint256 discountTokenId, bytes32[] calldata proof, bytes memory data)
public
payable
{
require(msg.sender == tx.origin || allowContractMints, "No contracts!");
require(checkSaleState(id), "Sale not active");
require(<FILL_ME>)
require(tokenMaxSupply[id] == 0 || totalSupply(id) + amount <= tokenMaxSupply[id], "Supply exhausted");
require(perWalletMaxTokens[id] == 0 || balanceOf(to,id) + amount <= perWalletMaxTokens[id], "Reached per-wallet limit!");
require(checkForeignTokenLimits(to, amount), "Not enough foreign tokens");
require((merkleRoot == 0 || _verify(_leaf(msg.sender), proof) || _verify(_leaf(to), proof)), "Invalid Merkle proof");
require(discountTokenId <= discountUsed.length, "discountTokenId is out of range");
require(_checkPrice(amount, discountTokenId), "Not enough ETH");
if (id == 0) {
uint256[] memory leastOwnedIds = findLeastOwnedIds(to);
// Shuffle the leastOwnedIds array
require(leastOwnedIds.length >= amount, "Unreasonable randomization request");
uint256 nounce = amount;
leastOwnedIds = shuffleArray(leastOwnedIds, nounce);
uint256[] memory randomIds = new uint256[](amount);
uint256 uniqueCount = 0;
for (uint256 i = 0; i < amount; i++) {
randomIds[i] = leastOwnedIds[i];
uniqueCount++;
}
require(uniqueCount == amount, "Unable to generate unique token IDs");
uint256[] memory amounts = createArrayWithSameNumber(amount, 1);
incrementMintCount(to, randomIds, amounts);
_mintBatch(to, randomIds, amounts, data);
return;
} else {
require(allowNonRandomMinting, "Only random minting");
mintCount[to][id] += amount;
_mint(to, id, amount, data);
}
}
function _getRandomIndex(uint256 length, uint256 nonce) internal view returns (uint256) {
}
function calculateForeignTokenCountMultiplied(address _wallet) public view returns (uint256) {
}
function checkForeignTokenLimits(address _wallet, uint256 _desiredAmount) public view returns (bool) {
}
function checkSaleState(uint256 _id) internal view returns (bool){
}
function setSaleActive(uint256[] memory ids, uint256[] memory tokenMaxSupplys, bool _globalLockAfterUpdate) external onlyRole(SALES_ROLE){
}
function addForeignTokenLimitRule(
address _foreignContract,
uint256 _foreignTokenTypeId,
uint256 _multiplier,
uint256 _start,
uint256 _end
) external onlyRole(SALES_ROLE) {
}
function resetForeignTokenLimits() external onlyRole(SALES_ROLE) {
}
function setSaleSchedule(uint256 _id, uint256 _start, uint256 _end) external onlyRole(SALES_ROLE){
}
function flipAllowContractMintsState() external onlyRole(ADMIN_ROLE){
}
function mintReservedTokens(address to, uint256 id, uint256 amount, bytes memory data) external onlyRole(RESERVED_MINT_ROLE){
}
function withdraw() external onlyRole(WITHDRAW_ROLE){
}
function mintBatch(address to, uint256[] memory ids, uint256[] memory amounts, bytes32[] calldata proof, bytes memory data)
public
payable
{
}
function _beforeTokenTransfer(address operator, address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data)
internal
whenNotPaused
override(ERC1155, ERC1155Supply)
{
}
// The following functions are overrides required by Solidity.
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC1155, AccessControl)
returns (bool)
{
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyRole(MERKLE_ROLE){
}
function setSaleMax(uint32 _limit, uint256 _id, bool _globalLockAfterUpdate) external onlyRole(SALES_ROLE){
}
function setPrice(uint256 _price) external onlyRole(SALES_ROLE){
}
function setWalletMax(uint256 _id, uint256 _walletLimit) external onlyRole(SALES_ROLE){
}
function setDiscountOwnerFunctionSelector(bytes4 _discountOwnerFunctionSelector) external onlyRole(SALES_ROLE){
}
function setContractURI(string memory _uri) external onlyRole(ADMIN_ROLE) {
}
function contractURI() public view returns (string memory) {
}
function _leaf(address account)
internal pure returns (bytes32)
{
}
function _verify(bytes32 leaf, bytes32[] memory proof)
internal view returns (bool)
{
}
function _checkSaleSchedule(saleSchedule memory s)
internal view returns (bool)
{
}
function _checkPrice(uint256 amount, uint256 discountTokenId)
internal returns (bool)
{
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
}
function _walletHoldsUnusedDiscountToken(address _wallet, address _contract, uint256 discountTokenId) internal returns (bool) {
}
function _walletHoldsForeign1155TokenCount(address _wallet, uint256 _foreignTokenId, address _contract) internal view returns (uint256) {
}
function setDiscountContract(address _discountContract, uint256 _maxTokenId, uint256 _discount) external onlyRole(ADMIN_ROLE) {
}
}
| _checkSaleSchedule(saleSchedules[id]),"Not at this time" | 263,936 | _checkSaleSchedule(saleSchedules[id]) |
"Supply exhausted" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/**
ERC1155 Smart Contract - JUNIQUE POP Genesis Collection
Besitzer einer JUNIQUE Tasche bzw. JUNIQUE NFTs erhalten keine Exklusivrechte/Ownership an den verwendeten NFTs und an der verwendeten Musik.
*/
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Burnable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
/// @custom:security-contact [email protected]
contract JUNIQUE_POP_Genesis_Collection is ERC1155, AccessControl, ERC1155Burnable,Pausable, ERC1155Supply, PaymentSplitter {
using Counters for Counters.Counter;
uint public constant NUMBER_RESERVED_TOKENS = 500;
uint256 public price = 275000000000000000; // The initial price to mint in WEI.
uint256 public discount = 0;
mapping(uint256 => uint256) public tokenMaxSupply; // 0 is openEnd
mapping(uint256 => uint256) public perWalletMaxTokens; // 0 is openEnd
mapping(address => mapping(uint256 => uint256)) public mintCount;
bytes32 public merkleRoot;
address public discountContract = 0x0000000000000000000000000000000000000000;
bytes4 public discountOwnerFunctionSelector = bytes4(keccak256("ownerOf(uint256)"));
bytes32 public constant URI_SETTER_ROLE = keccak256("URI_SETTER_ROLE");
bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
bytes32 public constant WITHDRAW_ROLE = keccak256("WITHDRAW_ROLE");
bytes32 public constant SALES_ROLE = keccak256("SALES_ROLE");
bytes32 public constant RESERVED_MINT_ROLE = keccak256("RESERVED_MINT_ROLE");
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
bytes32 public constant MERKLE_ROLE = keccak256("MERKLE_ROLE");
uint256[] public saleIsActive;
struct saleSchedule {
uint256 start;
uint256 end;
}
struct foreignTokenLimitsRule {
address foreignContract;
uint256 foreignTokenTypeId;
uint256 multiplier;
saleSchedule schedule;
}
foreignTokenLimitsRule[] public foreignTokenLimits;
mapping(uint256 => saleSchedule) public saleSchedules;
bool public saleMaxLock = false;
bool public allowContractMints = false;
bool public allowNonRandomMinting = true;
bool[] public discountUsed;
Counters.Counter public reservedSupply;
string private _contractURI = "https://www.7art.io/bibi-beck/pop-genesis-collection/metadata_contract.json"; //The URI to the contract json
constructor(string memory uri_, address[] memory _payees, uint256[] memory _shares) ERC1155(uri_) PaymentSplitter(_payees, _shares) payable {
}
function setURI(string memory newuri) public onlyRole(URI_SETTER_ROLE) {
}
/**
* @dev Pauses all token transfers.
*
* See {Pausable} and {Pausable-_pause}.
*
* Requirements:
*
* - the caller must have the `PAUSER_ROLE`.
*/
function pause() public onlyRole(PAUSER_ROLE) {
}
/**
* @dev Sets the value of `allowNonRandomMinting`.
*
* Requirements:
*
* - the caller must have the `SALES_ROLE`.
*
* @param _allowNonRandomMinting The new value for `allowNonRandomMinting`.
*/
function setAllowNonRandomMinting(bool _allowNonRandomMinting) public onlyRole(SALES_ROLE) {
}
/**
* @dev Unpauses all token transfers.
*
* See {Pausable} and {Pausable-_unpause}.
*
* Requirements:
*
* - the caller must have the `PAUSER_ROLE`.
*/
function unpause() public onlyRole(PAUSER_ROLE) {
}
/**
* @dev Retrieves the summary of mint counts for a given wallet.
* @param wallet The address of the wallet.
* @return The total sum of mint counts for the wallet.
*/
function getMintCountSummary(address wallet) public view returns (uint256) {
}
/**
* @dev Increments the mint count for the specified wallet, token IDs, and amounts.
*
* @param to The address of the wallet.
* @param ids The array of token IDs.
* @param amounts The array of corresponding token amounts.
*/
function incrementMintCount(address to, uint256[] memory ids, uint256[] memory amounts) internal {
}
/**
* @dev Finds the token IDs with the least minted count for a given wallet address.
*
* This function returns an array of token IDs that have the least minted count for the specified wallet.
* If multiple token IDs have the same least minted count, all of them will be included in the result.
*
* Requirements:
* - `wallet` must be a valid address.
*
* @param wallet The wallet address for which to find the least owned token IDs.
* @return An array of token IDs with the least minted count for the specified wallet.
*/
function findLeastOwnedIds(address wallet) public view returns (uint256[] memory) {
}
function createArrayWithSameNumber(uint256 amount, uint256 number) internal pure returns (uint256[] memory) {
}
function shuffleArray(uint256[] memory array, uint256 seed) internal view returns (uint256[] memory) {
}
function mint(address to, uint256 id, uint256 amount, uint256 discountTokenId, bytes32[] calldata proof, bytes memory data)
public
payable
{
require(msg.sender == tx.origin || allowContractMints, "No contracts!");
require(checkSaleState(id), "Sale not active");
require(_checkSaleSchedule(saleSchedules[id]), "Not at this time");
require(<FILL_ME>)
require(perWalletMaxTokens[id] == 0 || balanceOf(to,id) + amount <= perWalletMaxTokens[id], "Reached per-wallet limit!");
require(checkForeignTokenLimits(to, amount), "Not enough foreign tokens");
require((merkleRoot == 0 || _verify(_leaf(msg.sender), proof) || _verify(_leaf(to), proof)), "Invalid Merkle proof");
require(discountTokenId <= discountUsed.length, "discountTokenId is out of range");
require(_checkPrice(amount, discountTokenId), "Not enough ETH");
if (id == 0) {
uint256[] memory leastOwnedIds = findLeastOwnedIds(to);
// Shuffle the leastOwnedIds array
require(leastOwnedIds.length >= amount, "Unreasonable randomization request");
uint256 nounce = amount;
leastOwnedIds = shuffleArray(leastOwnedIds, nounce);
uint256[] memory randomIds = new uint256[](amount);
uint256 uniqueCount = 0;
for (uint256 i = 0; i < amount; i++) {
randomIds[i] = leastOwnedIds[i];
uniqueCount++;
}
require(uniqueCount == amount, "Unable to generate unique token IDs");
uint256[] memory amounts = createArrayWithSameNumber(amount, 1);
incrementMintCount(to, randomIds, amounts);
_mintBatch(to, randomIds, amounts, data);
return;
} else {
require(allowNonRandomMinting, "Only random minting");
mintCount[to][id] += amount;
_mint(to, id, amount, data);
}
}
function _getRandomIndex(uint256 length, uint256 nonce) internal view returns (uint256) {
}
function calculateForeignTokenCountMultiplied(address _wallet) public view returns (uint256) {
}
function checkForeignTokenLimits(address _wallet, uint256 _desiredAmount) public view returns (bool) {
}
function checkSaleState(uint256 _id) internal view returns (bool){
}
function setSaleActive(uint256[] memory ids, uint256[] memory tokenMaxSupplys, bool _globalLockAfterUpdate) external onlyRole(SALES_ROLE){
}
function addForeignTokenLimitRule(
address _foreignContract,
uint256 _foreignTokenTypeId,
uint256 _multiplier,
uint256 _start,
uint256 _end
) external onlyRole(SALES_ROLE) {
}
function resetForeignTokenLimits() external onlyRole(SALES_ROLE) {
}
function setSaleSchedule(uint256 _id, uint256 _start, uint256 _end) external onlyRole(SALES_ROLE){
}
function flipAllowContractMintsState() external onlyRole(ADMIN_ROLE){
}
function mintReservedTokens(address to, uint256 id, uint256 amount, bytes memory data) external onlyRole(RESERVED_MINT_ROLE){
}
function withdraw() external onlyRole(WITHDRAW_ROLE){
}
function mintBatch(address to, uint256[] memory ids, uint256[] memory amounts, bytes32[] calldata proof, bytes memory data)
public
payable
{
}
function _beforeTokenTransfer(address operator, address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data)
internal
whenNotPaused
override(ERC1155, ERC1155Supply)
{
}
// The following functions are overrides required by Solidity.
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC1155, AccessControl)
returns (bool)
{
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyRole(MERKLE_ROLE){
}
function setSaleMax(uint32 _limit, uint256 _id, bool _globalLockAfterUpdate) external onlyRole(SALES_ROLE){
}
function setPrice(uint256 _price) external onlyRole(SALES_ROLE){
}
function setWalletMax(uint256 _id, uint256 _walletLimit) external onlyRole(SALES_ROLE){
}
function setDiscountOwnerFunctionSelector(bytes4 _discountOwnerFunctionSelector) external onlyRole(SALES_ROLE){
}
function setContractURI(string memory _uri) external onlyRole(ADMIN_ROLE) {
}
function contractURI() public view returns (string memory) {
}
function _leaf(address account)
internal pure returns (bytes32)
{
}
function _verify(bytes32 leaf, bytes32[] memory proof)
internal view returns (bool)
{
}
function _checkSaleSchedule(saleSchedule memory s)
internal view returns (bool)
{
}
function _checkPrice(uint256 amount, uint256 discountTokenId)
internal returns (bool)
{
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
}
function _walletHoldsUnusedDiscountToken(address _wallet, address _contract, uint256 discountTokenId) internal returns (bool) {
}
function _walletHoldsForeign1155TokenCount(address _wallet, uint256 _foreignTokenId, address _contract) internal view returns (uint256) {
}
function setDiscountContract(address _discountContract, uint256 _maxTokenId, uint256 _discount) external onlyRole(ADMIN_ROLE) {
}
}
| tokenMaxSupply[id]==0||totalSupply(id)+amount<=tokenMaxSupply[id],"Supply exhausted" | 263,936 | tokenMaxSupply[id]==0||totalSupply(id)+amount<=tokenMaxSupply[id] |
"Reached per-wallet limit!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/**
ERC1155 Smart Contract - JUNIQUE POP Genesis Collection
Besitzer einer JUNIQUE Tasche bzw. JUNIQUE NFTs erhalten keine Exklusivrechte/Ownership an den verwendeten NFTs und an der verwendeten Musik.
*/
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Burnable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
/// @custom:security-contact [email protected]
contract JUNIQUE_POP_Genesis_Collection is ERC1155, AccessControl, ERC1155Burnable,Pausable, ERC1155Supply, PaymentSplitter {
using Counters for Counters.Counter;
uint public constant NUMBER_RESERVED_TOKENS = 500;
uint256 public price = 275000000000000000; // The initial price to mint in WEI.
uint256 public discount = 0;
mapping(uint256 => uint256) public tokenMaxSupply; // 0 is openEnd
mapping(uint256 => uint256) public perWalletMaxTokens; // 0 is openEnd
mapping(address => mapping(uint256 => uint256)) public mintCount;
bytes32 public merkleRoot;
address public discountContract = 0x0000000000000000000000000000000000000000;
bytes4 public discountOwnerFunctionSelector = bytes4(keccak256("ownerOf(uint256)"));
bytes32 public constant URI_SETTER_ROLE = keccak256("URI_SETTER_ROLE");
bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
bytes32 public constant WITHDRAW_ROLE = keccak256("WITHDRAW_ROLE");
bytes32 public constant SALES_ROLE = keccak256("SALES_ROLE");
bytes32 public constant RESERVED_MINT_ROLE = keccak256("RESERVED_MINT_ROLE");
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
bytes32 public constant MERKLE_ROLE = keccak256("MERKLE_ROLE");
uint256[] public saleIsActive;
struct saleSchedule {
uint256 start;
uint256 end;
}
struct foreignTokenLimitsRule {
address foreignContract;
uint256 foreignTokenTypeId;
uint256 multiplier;
saleSchedule schedule;
}
foreignTokenLimitsRule[] public foreignTokenLimits;
mapping(uint256 => saleSchedule) public saleSchedules;
bool public saleMaxLock = false;
bool public allowContractMints = false;
bool public allowNonRandomMinting = true;
bool[] public discountUsed;
Counters.Counter public reservedSupply;
string private _contractURI = "https://www.7art.io/bibi-beck/pop-genesis-collection/metadata_contract.json"; //The URI to the contract json
constructor(string memory uri_, address[] memory _payees, uint256[] memory _shares) ERC1155(uri_) PaymentSplitter(_payees, _shares) payable {
}
function setURI(string memory newuri) public onlyRole(URI_SETTER_ROLE) {
}
/**
* @dev Pauses all token transfers.
*
* See {Pausable} and {Pausable-_pause}.
*
* Requirements:
*
* - the caller must have the `PAUSER_ROLE`.
*/
function pause() public onlyRole(PAUSER_ROLE) {
}
/**
* @dev Sets the value of `allowNonRandomMinting`.
*
* Requirements:
*
* - the caller must have the `SALES_ROLE`.
*
* @param _allowNonRandomMinting The new value for `allowNonRandomMinting`.
*/
function setAllowNonRandomMinting(bool _allowNonRandomMinting) public onlyRole(SALES_ROLE) {
}
/**
* @dev Unpauses all token transfers.
*
* See {Pausable} and {Pausable-_unpause}.
*
* Requirements:
*
* - the caller must have the `PAUSER_ROLE`.
*/
function unpause() public onlyRole(PAUSER_ROLE) {
}
/**
* @dev Retrieves the summary of mint counts for a given wallet.
* @param wallet The address of the wallet.
* @return The total sum of mint counts for the wallet.
*/
function getMintCountSummary(address wallet) public view returns (uint256) {
}
/**
* @dev Increments the mint count for the specified wallet, token IDs, and amounts.
*
* @param to The address of the wallet.
* @param ids The array of token IDs.
* @param amounts The array of corresponding token amounts.
*/
function incrementMintCount(address to, uint256[] memory ids, uint256[] memory amounts) internal {
}
/**
* @dev Finds the token IDs with the least minted count for a given wallet address.
*
* This function returns an array of token IDs that have the least minted count for the specified wallet.
* If multiple token IDs have the same least minted count, all of them will be included in the result.
*
* Requirements:
* - `wallet` must be a valid address.
*
* @param wallet The wallet address for which to find the least owned token IDs.
* @return An array of token IDs with the least minted count for the specified wallet.
*/
function findLeastOwnedIds(address wallet) public view returns (uint256[] memory) {
}
function createArrayWithSameNumber(uint256 amount, uint256 number) internal pure returns (uint256[] memory) {
}
function shuffleArray(uint256[] memory array, uint256 seed) internal view returns (uint256[] memory) {
}
function mint(address to, uint256 id, uint256 amount, uint256 discountTokenId, bytes32[] calldata proof, bytes memory data)
public
payable
{
require(msg.sender == tx.origin || allowContractMints, "No contracts!");
require(checkSaleState(id), "Sale not active");
require(_checkSaleSchedule(saleSchedules[id]), "Not at this time");
require(tokenMaxSupply[id] == 0 || totalSupply(id) + amount <= tokenMaxSupply[id], "Supply exhausted");
require(<FILL_ME>)
require(checkForeignTokenLimits(to, amount), "Not enough foreign tokens");
require((merkleRoot == 0 || _verify(_leaf(msg.sender), proof) || _verify(_leaf(to), proof)), "Invalid Merkle proof");
require(discountTokenId <= discountUsed.length, "discountTokenId is out of range");
require(_checkPrice(amount, discountTokenId), "Not enough ETH");
if (id == 0) {
uint256[] memory leastOwnedIds = findLeastOwnedIds(to);
// Shuffle the leastOwnedIds array
require(leastOwnedIds.length >= amount, "Unreasonable randomization request");
uint256 nounce = amount;
leastOwnedIds = shuffleArray(leastOwnedIds, nounce);
uint256[] memory randomIds = new uint256[](amount);
uint256 uniqueCount = 0;
for (uint256 i = 0; i < amount; i++) {
randomIds[i] = leastOwnedIds[i];
uniqueCount++;
}
require(uniqueCount == amount, "Unable to generate unique token IDs");
uint256[] memory amounts = createArrayWithSameNumber(amount, 1);
incrementMintCount(to, randomIds, amounts);
_mintBatch(to, randomIds, amounts, data);
return;
} else {
require(allowNonRandomMinting, "Only random minting");
mintCount[to][id] += amount;
_mint(to, id, amount, data);
}
}
function _getRandomIndex(uint256 length, uint256 nonce) internal view returns (uint256) {
}
function calculateForeignTokenCountMultiplied(address _wallet) public view returns (uint256) {
}
function checkForeignTokenLimits(address _wallet, uint256 _desiredAmount) public view returns (bool) {
}
function checkSaleState(uint256 _id) internal view returns (bool){
}
function setSaleActive(uint256[] memory ids, uint256[] memory tokenMaxSupplys, bool _globalLockAfterUpdate) external onlyRole(SALES_ROLE){
}
function addForeignTokenLimitRule(
address _foreignContract,
uint256 _foreignTokenTypeId,
uint256 _multiplier,
uint256 _start,
uint256 _end
) external onlyRole(SALES_ROLE) {
}
function resetForeignTokenLimits() external onlyRole(SALES_ROLE) {
}
function setSaleSchedule(uint256 _id, uint256 _start, uint256 _end) external onlyRole(SALES_ROLE){
}
function flipAllowContractMintsState() external onlyRole(ADMIN_ROLE){
}
function mintReservedTokens(address to, uint256 id, uint256 amount, bytes memory data) external onlyRole(RESERVED_MINT_ROLE){
}
function withdraw() external onlyRole(WITHDRAW_ROLE){
}
function mintBatch(address to, uint256[] memory ids, uint256[] memory amounts, bytes32[] calldata proof, bytes memory data)
public
payable
{
}
function _beforeTokenTransfer(address operator, address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data)
internal
whenNotPaused
override(ERC1155, ERC1155Supply)
{
}
// The following functions are overrides required by Solidity.
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC1155, AccessControl)
returns (bool)
{
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyRole(MERKLE_ROLE){
}
function setSaleMax(uint32 _limit, uint256 _id, bool _globalLockAfterUpdate) external onlyRole(SALES_ROLE){
}
function setPrice(uint256 _price) external onlyRole(SALES_ROLE){
}
function setWalletMax(uint256 _id, uint256 _walletLimit) external onlyRole(SALES_ROLE){
}
function setDiscountOwnerFunctionSelector(bytes4 _discountOwnerFunctionSelector) external onlyRole(SALES_ROLE){
}
function setContractURI(string memory _uri) external onlyRole(ADMIN_ROLE) {
}
function contractURI() public view returns (string memory) {
}
function _leaf(address account)
internal pure returns (bytes32)
{
}
function _verify(bytes32 leaf, bytes32[] memory proof)
internal view returns (bool)
{
}
function _checkSaleSchedule(saleSchedule memory s)
internal view returns (bool)
{
}
function _checkPrice(uint256 amount, uint256 discountTokenId)
internal returns (bool)
{
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
}
function _walletHoldsUnusedDiscountToken(address _wallet, address _contract, uint256 discountTokenId) internal returns (bool) {
}
function _walletHoldsForeign1155TokenCount(address _wallet, uint256 _foreignTokenId, address _contract) internal view returns (uint256) {
}
function setDiscountContract(address _discountContract, uint256 _maxTokenId, uint256 _discount) external onlyRole(ADMIN_ROLE) {
}
}
| perWalletMaxTokens[id]==0||balanceOf(to,id)+amount<=perWalletMaxTokens[id],"Reached per-wallet limit!" | 263,936 | perWalletMaxTokens[id]==0||balanceOf(to,id)+amount<=perWalletMaxTokens[id] |
"Not enough foreign tokens" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/**
ERC1155 Smart Contract - JUNIQUE POP Genesis Collection
Besitzer einer JUNIQUE Tasche bzw. JUNIQUE NFTs erhalten keine Exklusivrechte/Ownership an den verwendeten NFTs und an der verwendeten Musik.
*/
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Burnable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
/// @custom:security-contact [email protected]
contract JUNIQUE_POP_Genesis_Collection is ERC1155, AccessControl, ERC1155Burnable,Pausable, ERC1155Supply, PaymentSplitter {
using Counters for Counters.Counter;
uint public constant NUMBER_RESERVED_TOKENS = 500;
uint256 public price = 275000000000000000; // The initial price to mint in WEI.
uint256 public discount = 0;
mapping(uint256 => uint256) public tokenMaxSupply; // 0 is openEnd
mapping(uint256 => uint256) public perWalletMaxTokens; // 0 is openEnd
mapping(address => mapping(uint256 => uint256)) public mintCount;
bytes32 public merkleRoot;
address public discountContract = 0x0000000000000000000000000000000000000000;
bytes4 public discountOwnerFunctionSelector = bytes4(keccak256("ownerOf(uint256)"));
bytes32 public constant URI_SETTER_ROLE = keccak256("URI_SETTER_ROLE");
bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
bytes32 public constant WITHDRAW_ROLE = keccak256("WITHDRAW_ROLE");
bytes32 public constant SALES_ROLE = keccak256("SALES_ROLE");
bytes32 public constant RESERVED_MINT_ROLE = keccak256("RESERVED_MINT_ROLE");
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
bytes32 public constant MERKLE_ROLE = keccak256("MERKLE_ROLE");
uint256[] public saleIsActive;
struct saleSchedule {
uint256 start;
uint256 end;
}
struct foreignTokenLimitsRule {
address foreignContract;
uint256 foreignTokenTypeId;
uint256 multiplier;
saleSchedule schedule;
}
foreignTokenLimitsRule[] public foreignTokenLimits;
mapping(uint256 => saleSchedule) public saleSchedules;
bool public saleMaxLock = false;
bool public allowContractMints = false;
bool public allowNonRandomMinting = true;
bool[] public discountUsed;
Counters.Counter public reservedSupply;
string private _contractURI = "https://www.7art.io/bibi-beck/pop-genesis-collection/metadata_contract.json"; //The URI to the contract json
constructor(string memory uri_, address[] memory _payees, uint256[] memory _shares) ERC1155(uri_) PaymentSplitter(_payees, _shares) payable {
}
function setURI(string memory newuri) public onlyRole(URI_SETTER_ROLE) {
}
/**
* @dev Pauses all token transfers.
*
* See {Pausable} and {Pausable-_pause}.
*
* Requirements:
*
* - the caller must have the `PAUSER_ROLE`.
*/
function pause() public onlyRole(PAUSER_ROLE) {
}
/**
* @dev Sets the value of `allowNonRandomMinting`.
*
* Requirements:
*
* - the caller must have the `SALES_ROLE`.
*
* @param _allowNonRandomMinting The new value for `allowNonRandomMinting`.
*/
function setAllowNonRandomMinting(bool _allowNonRandomMinting) public onlyRole(SALES_ROLE) {
}
/**
* @dev Unpauses all token transfers.
*
* See {Pausable} and {Pausable-_unpause}.
*
* Requirements:
*
* - the caller must have the `PAUSER_ROLE`.
*/
function unpause() public onlyRole(PAUSER_ROLE) {
}
/**
* @dev Retrieves the summary of mint counts for a given wallet.
* @param wallet The address of the wallet.
* @return The total sum of mint counts for the wallet.
*/
function getMintCountSummary(address wallet) public view returns (uint256) {
}
/**
* @dev Increments the mint count for the specified wallet, token IDs, and amounts.
*
* @param to The address of the wallet.
* @param ids The array of token IDs.
* @param amounts The array of corresponding token amounts.
*/
function incrementMintCount(address to, uint256[] memory ids, uint256[] memory amounts) internal {
}
/**
* @dev Finds the token IDs with the least minted count for a given wallet address.
*
* This function returns an array of token IDs that have the least minted count for the specified wallet.
* If multiple token IDs have the same least minted count, all of them will be included in the result.
*
* Requirements:
* - `wallet` must be a valid address.
*
* @param wallet The wallet address for which to find the least owned token IDs.
* @return An array of token IDs with the least minted count for the specified wallet.
*/
function findLeastOwnedIds(address wallet) public view returns (uint256[] memory) {
}
function createArrayWithSameNumber(uint256 amount, uint256 number) internal pure returns (uint256[] memory) {
}
function shuffleArray(uint256[] memory array, uint256 seed) internal view returns (uint256[] memory) {
}
function mint(address to, uint256 id, uint256 amount, uint256 discountTokenId, bytes32[] calldata proof, bytes memory data)
public
payable
{
require(msg.sender == tx.origin || allowContractMints, "No contracts!");
require(checkSaleState(id), "Sale not active");
require(_checkSaleSchedule(saleSchedules[id]), "Not at this time");
require(tokenMaxSupply[id] == 0 || totalSupply(id) + amount <= tokenMaxSupply[id], "Supply exhausted");
require(perWalletMaxTokens[id] == 0 || balanceOf(to,id) + amount <= perWalletMaxTokens[id], "Reached per-wallet limit!");
require(<FILL_ME>)
require((merkleRoot == 0 || _verify(_leaf(msg.sender), proof) || _verify(_leaf(to), proof)), "Invalid Merkle proof");
require(discountTokenId <= discountUsed.length, "discountTokenId is out of range");
require(_checkPrice(amount, discountTokenId), "Not enough ETH");
if (id == 0) {
uint256[] memory leastOwnedIds = findLeastOwnedIds(to);
// Shuffle the leastOwnedIds array
require(leastOwnedIds.length >= amount, "Unreasonable randomization request");
uint256 nounce = amount;
leastOwnedIds = shuffleArray(leastOwnedIds, nounce);
uint256[] memory randomIds = new uint256[](amount);
uint256 uniqueCount = 0;
for (uint256 i = 0; i < amount; i++) {
randomIds[i] = leastOwnedIds[i];
uniqueCount++;
}
require(uniqueCount == amount, "Unable to generate unique token IDs");
uint256[] memory amounts = createArrayWithSameNumber(amount, 1);
incrementMintCount(to, randomIds, amounts);
_mintBatch(to, randomIds, amounts, data);
return;
} else {
require(allowNonRandomMinting, "Only random minting");
mintCount[to][id] += amount;
_mint(to, id, amount, data);
}
}
function _getRandomIndex(uint256 length, uint256 nonce) internal view returns (uint256) {
}
function calculateForeignTokenCountMultiplied(address _wallet) public view returns (uint256) {
}
function checkForeignTokenLimits(address _wallet, uint256 _desiredAmount) public view returns (bool) {
}
function checkSaleState(uint256 _id) internal view returns (bool){
}
function setSaleActive(uint256[] memory ids, uint256[] memory tokenMaxSupplys, bool _globalLockAfterUpdate) external onlyRole(SALES_ROLE){
}
function addForeignTokenLimitRule(
address _foreignContract,
uint256 _foreignTokenTypeId,
uint256 _multiplier,
uint256 _start,
uint256 _end
) external onlyRole(SALES_ROLE) {
}
function resetForeignTokenLimits() external onlyRole(SALES_ROLE) {
}
function setSaleSchedule(uint256 _id, uint256 _start, uint256 _end) external onlyRole(SALES_ROLE){
}
function flipAllowContractMintsState() external onlyRole(ADMIN_ROLE){
}
function mintReservedTokens(address to, uint256 id, uint256 amount, bytes memory data) external onlyRole(RESERVED_MINT_ROLE){
}
function withdraw() external onlyRole(WITHDRAW_ROLE){
}
function mintBatch(address to, uint256[] memory ids, uint256[] memory amounts, bytes32[] calldata proof, bytes memory data)
public
payable
{
}
function _beforeTokenTransfer(address operator, address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data)
internal
whenNotPaused
override(ERC1155, ERC1155Supply)
{
}
// The following functions are overrides required by Solidity.
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC1155, AccessControl)
returns (bool)
{
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyRole(MERKLE_ROLE){
}
function setSaleMax(uint32 _limit, uint256 _id, bool _globalLockAfterUpdate) external onlyRole(SALES_ROLE){
}
function setPrice(uint256 _price) external onlyRole(SALES_ROLE){
}
function setWalletMax(uint256 _id, uint256 _walletLimit) external onlyRole(SALES_ROLE){
}
function setDiscountOwnerFunctionSelector(bytes4 _discountOwnerFunctionSelector) external onlyRole(SALES_ROLE){
}
function setContractURI(string memory _uri) external onlyRole(ADMIN_ROLE) {
}
function contractURI() public view returns (string memory) {
}
function _leaf(address account)
internal pure returns (bytes32)
{
}
function _verify(bytes32 leaf, bytes32[] memory proof)
internal view returns (bool)
{
}
function _checkSaleSchedule(saleSchedule memory s)
internal view returns (bool)
{
}
function _checkPrice(uint256 amount, uint256 discountTokenId)
internal returns (bool)
{
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
}
function _walletHoldsUnusedDiscountToken(address _wallet, address _contract, uint256 discountTokenId) internal returns (bool) {
}
function _walletHoldsForeign1155TokenCount(address _wallet, uint256 _foreignTokenId, address _contract) internal view returns (uint256) {
}
function setDiscountContract(address _discountContract, uint256 _maxTokenId, uint256 _discount) external onlyRole(ADMIN_ROLE) {
}
}
| checkForeignTokenLimits(to,amount),"Not enough foreign tokens" | 263,936 | checkForeignTokenLimits(to,amount) |
"Invalid Merkle proof" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/**
ERC1155 Smart Contract - JUNIQUE POP Genesis Collection
Besitzer einer JUNIQUE Tasche bzw. JUNIQUE NFTs erhalten keine Exklusivrechte/Ownership an den verwendeten NFTs und an der verwendeten Musik.
*/
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Burnable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
/// @custom:security-contact [email protected]
contract JUNIQUE_POP_Genesis_Collection is ERC1155, AccessControl, ERC1155Burnable,Pausable, ERC1155Supply, PaymentSplitter {
using Counters for Counters.Counter;
uint public constant NUMBER_RESERVED_TOKENS = 500;
uint256 public price = 275000000000000000; // The initial price to mint in WEI.
uint256 public discount = 0;
mapping(uint256 => uint256) public tokenMaxSupply; // 0 is openEnd
mapping(uint256 => uint256) public perWalletMaxTokens; // 0 is openEnd
mapping(address => mapping(uint256 => uint256)) public mintCount;
bytes32 public merkleRoot;
address public discountContract = 0x0000000000000000000000000000000000000000;
bytes4 public discountOwnerFunctionSelector = bytes4(keccak256("ownerOf(uint256)"));
bytes32 public constant URI_SETTER_ROLE = keccak256("URI_SETTER_ROLE");
bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
bytes32 public constant WITHDRAW_ROLE = keccak256("WITHDRAW_ROLE");
bytes32 public constant SALES_ROLE = keccak256("SALES_ROLE");
bytes32 public constant RESERVED_MINT_ROLE = keccak256("RESERVED_MINT_ROLE");
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
bytes32 public constant MERKLE_ROLE = keccak256("MERKLE_ROLE");
uint256[] public saleIsActive;
struct saleSchedule {
uint256 start;
uint256 end;
}
struct foreignTokenLimitsRule {
address foreignContract;
uint256 foreignTokenTypeId;
uint256 multiplier;
saleSchedule schedule;
}
foreignTokenLimitsRule[] public foreignTokenLimits;
mapping(uint256 => saleSchedule) public saleSchedules;
bool public saleMaxLock = false;
bool public allowContractMints = false;
bool public allowNonRandomMinting = true;
bool[] public discountUsed;
Counters.Counter public reservedSupply;
string private _contractURI = "https://www.7art.io/bibi-beck/pop-genesis-collection/metadata_contract.json"; //The URI to the contract json
constructor(string memory uri_, address[] memory _payees, uint256[] memory _shares) ERC1155(uri_) PaymentSplitter(_payees, _shares) payable {
}
function setURI(string memory newuri) public onlyRole(URI_SETTER_ROLE) {
}
/**
* @dev Pauses all token transfers.
*
* See {Pausable} and {Pausable-_pause}.
*
* Requirements:
*
* - the caller must have the `PAUSER_ROLE`.
*/
function pause() public onlyRole(PAUSER_ROLE) {
}
/**
* @dev Sets the value of `allowNonRandomMinting`.
*
* Requirements:
*
* - the caller must have the `SALES_ROLE`.
*
* @param _allowNonRandomMinting The new value for `allowNonRandomMinting`.
*/
function setAllowNonRandomMinting(bool _allowNonRandomMinting) public onlyRole(SALES_ROLE) {
}
/**
* @dev Unpauses all token transfers.
*
* See {Pausable} and {Pausable-_unpause}.
*
* Requirements:
*
* - the caller must have the `PAUSER_ROLE`.
*/
function unpause() public onlyRole(PAUSER_ROLE) {
}
/**
* @dev Retrieves the summary of mint counts for a given wallet.
* @param wallet The address of the wallet.
* @return The total sum of mint counts for the wallet.
*/
function getMintCountSummary(address wallet) public view returns (uint256) {
}
/**
* @dev Increments the mint count for the specified wallet, token IDs, and amounts.
*
* @param to The address of the wallet.
* @param ids The array of token IDs.
* @param amounts The array of corresponding token amounts.
*/
function incrementMintCount(address to, uint256[] memory ids, uint256[] memory amounts) internal {
}
/**
* @dev Finds the token IDs with the least minted count for a given wallet address.
*
* This function returns an array of token IDs that have the least minted count for the specified wallet.
* If multiple token IDs have the same least minted count, all of them will be included in the result.
*
* Requirements:
* - `wallet` must be a valid address.
*
* @param wallet The wallet address for which to find the least owned token IDs.
* @return An array of token IDs with the least minted count for the specified wallet.
*/
function findLeastOwnedIds(address wallet) public view returns (uint256[] memory) {
}
function createArrayWithSameNumber(uint256 amount, uint256 number) internal pure returns (uint256[] memory) {
}
function shuffleArray(uint256[] memory array, uint256 seed) internal view returns (uint256[] memory) {
}
function mint(address to, uint256 id, uint256 amount, uint256 discountTokenId, bytes32[] calldata proof, bytes memory data)
public
payable
{
require(msg.sender == tx.origin || allowContractMints, "No contracts!");
require(checkSaleState(id), "Sale not active");
require(_checkSaleSchedule(saleSchedules[id]), "Not at this time");
require(tokenMaxSupply[id] == 0 || totalSupply(id) + amount <= tokenMaxSupply[id], "Supply exhausted");
require(perWalletMaxTokens[id] == 0 || balanceOf(to,id) + amount <= perWalletMaxTokens[id], "Reached per-wallet limit!");
require(checkForeignTokenLimits(to, amount), "Not enough foreign tokens");
require(<FILL_ME>)
require(discountTokenId <= discountUsed.length, "discountTokenId is out of range");
require(_checkPrice(amount, discountTokenId), "Not enough ETH");
if (id == 0) {
uint256[] memory leastOwnedIds = findLeastOwnedIds(to);
// Shuffle the leastOwnedIds array
require(leastOwnedIds.length >= amount, "Unreasonable randomization request");
uint256 nounce = amount;
leastOwnedIds = shuffleArray(leastOwnedIds, nounce);
uint256[] memory randomIds = new uint256[](amount);
uint256 uniqueCount = 0;
for (uint256 i = 0; i < amount; i++) {
randomIds[i] = leastOwnedIds[i];
uniqueCount++;
}
require(uniqueCount == amount, "Unable to generate unique token IDs");
uint256[] memory amounts = createArrayWithSameNumber(amount, 1);
incrementMintCount(to, randomIds, amounts);
_mintBatch(to, randomIds, amounts, data);
return;
} else {
require(allowNonRandomMinting, "Only random minting");
mintCount[to][id] += amount;
_mint(to, id, amount, data);
}
}
function _getRandomIndex(uint256 length, uint256 nonce) internal view returns (uint256) {
}
function calculateForeignTokenCountMultiplied(address _wallet) public view returns (uint256) {
}
function checkForeignTokenLimits(address _wallet, uint256 _desiredAmount) public view returns (bool) {
}
function checkSaleState(uint256 _id) internal view returns (bool){
}
function setSaleActive(uint256[] memory ids, uint256[] memory tokenMaxSupplys, bool _globalLockAfterUpdate) external onlyRole(SALES_ROLE){
}
function addForeignTokenLimitRule(
address _foreignContract,
uint256 _foreignTokenTypeId,
uint256 _multiplier,
uint256 _start,
uint256 _end
) external onlyRole(SALES_ROLE) {
}
function resetForeignTokenLimits() external onlyRole(SALES_ROLE) {
}
function setSaleSchedule(uint256 _id, uint256 _start, uint256 _end) external onlyRole(SALES_ROLE){
}
function flipAllowContractMintsState() external onlyRole(ADMIN_ROLE){
}
function mintReservedTokens(address to, uint256 id, uint256 amount, bytes memory data) external onlyRole(RESERVED_MINT_ROLE){
}
function withdraw() external onlyRole(WITHDRAW_ROLE){
}
function mintBatch(address to, uint256[] memory ids, uint256[] memory amounts, bytes32[] calldata proof, bytes memory data)
public
payable
{
}
function _beforeTokenTransfer(address operator, address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data)
internal
whenNotPaused
override(ERC1155, ERC1155Supply)
{
}
// The following functions are overrides required by Solidity.
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC1155, AccessControl)
returns (bool)
{
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyRole(MERKLE_ROLE){
}
function setSaleMax(uint32 _limit, uint256 _id, bool _globalLockAfterUpdate) external onlyRole(SALES_ROLE){
}
function setPrice(uint256 _price) external onlyRole(SALES_ROLE){
}
function setWalletMax(uint256 _id, uint256 _walletLimit) external onlyRole(SALES_ROLE){
}
function setDiscountOwnerFunctionSelector(bytes4 _discountOwnerFunctionSelector) external onlyRole(SALES_ROLE){
}
function setContractURI(string memory _uri) external onlyRole(ADMIN_ROLE) {
}
function contractURI() public view returns (string memory) {
}
function _leaf(address account)
internal pure returns (bytes32)
{
}
function _verify(bytes32 leaf, bytes32[] memory proof)
internal view returns (bool)
{
}
function _checkSaleSchedule(saleSchedule memory s)
internal view returns (bool)
{
}
function _checkPrice(uint256 amount, uint256 discountTokenId)
internal returns (bool)
{
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
}
function _walletHoldsUnusedDiscountToken(address _wallet, address _contract, uint256 discountTokenId) internal returns (bool) {
}
function _walletHoldsForeign1155TokenCount(address _wallet, uint256 _foreignTokenId, address _contract) internal view returns (uint256) {
}
function setDiscountContract(address _discountContract, uint256 _maxTokenId, uint256 _discount) external onlyRole(ADMIN_ROLE) {
}
}
| (merkleRoot==0||_verify(_leaf(msg.sender),proof)||_verify(_leaf(to),proof)),"Invalid Merkle proof" | 263,936 | (merkleRoot==0||_verify(_leaf(msg.sender),proof)||_verify(_leaf(to),proof)) |
"Not enough ETH" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/**
ERC1155 Smart Contract - JUNIQUE POP Genesis Collection
Besitzer einer JUNIQUE Tasche bzw. JUNIQUE NFTs erhalten keine Exklusivrechte/Ownership an den verwendeten NFTs und an der verwendeten Musik.
*/
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Burnable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
/// @custom:security-contact [email protected]
contract JUNIQUE_POP_Genesis_Collection is ERC1155, AccessControl, ERC1155Burnable,Pausable, ERC1155Supply, PaymentSplitter {
using Counters for Counters.Counter;
uint public constant NUMBER_RESERVED_TOKENS = 500;
uint256 public price = 275000000000000000; // The initial price to mint in WEI.
uint256 public discount = 0;
mapping(uint256 => uint256) public tokenMaxSupply; // 0 is openEnd
mapping(uint256 => uint256) public perWalletMaxTokens; // 0 is openEnd
mapping(address => mapping(uint256 => uint256)) public mintCount;
bytes32 public merkleRoot;
address public discountContract = 0x0000000000000000000000000000000000000000;
bytes4 public discountOwnerFunctionSelector = bytes4(keccak256("ownerOf(uint256)"));
bytes32 public constant URI_SETTER_ROLE = keccak256("URI_SETTER_ROLE");
bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
bytes32 public constant WITHDRAW_ROLE = keccak256("WITHDRAW_ROLE");
bytes32 public constant SALES_ROLE = keccak256("SALES_ROLE");
bytes32 public constant RESERVED_MINT_ROLE = keccak256("RESERVED_MINT_ROLE");
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
bytes32 public constant MERKLE_ROLE = keccak256("MERKLE_ROLE");
uint256[] public saleIsActive;
struct saleSchedule {
uint256 start;
uint256 end;
}
struct foreignTokenLimitsRule {
address foreignContract;
uint256 foreignTokenTypeId;
uint256 multiplier;
saleSchedule schedule;
}
foreignTokenLimitsRule[] public foreignTokenLimits;
mapping(uint256 => saleSchedule) public saleSchedules;
bool public saleMaxLock = false;
bool public allowContractMints = false;
bool public allowNonRandomMinting = true;
bool[] public discountUsed;
Counters.Counter public reservedSupply;
string private _contractURI = "https://www.7art.io/bibi-beck/pop-genesis-collection/metadata_contract.json"; //The URI to the contract json
constructor(string memory uri_, address[] memory _payees, uint256[] memory _shares) ERC1155(uri_) PaymentSplitter(_payees, _shares) payable {
}
function setURI(string memory newuri) public onlyRole(URI_SETTER_ROLE) {
}
/**
* @dev Pauses all token transfers.
*
* See {Pausable} and {Pausable-_pause}.
*
* Requirements:
*
* - the caller must have the `PAUSER_ROLE`.
*/
function pause() public onlyRole(PAUSER_ROLE) {
}
/**
* @dev Sets the value of `allowNonRandomMinting`.
*
* Requirements:
*
* - the caller must have the `SALES_ROLE`.
*
* @param _allowNonRandomMinting The new value for `allowNonRandomMinting`.
*/
function setAllowNonRandomMinting(bool _allowNonRandomMinting) public onlyRole(SALES_ROLE) {
}
/**
* @dev Unpauses all token transfers.
*
* See {Pausable} and {Pausable-_unpause}.
*
* Requirements:
*
* - the caller must have the `PAUSER_ROLE`.
*/
function unpause() public onlyRole(PAUSER_ROLE) {
}
/**
* @dev Retrieves the summary of mint counts for a given wallet.
* @param wallet The address of the wallet.
* @return The total sum of mint counts for the wallet.
*/
function getMintCountSummary(address wallet) public view returns (uint256) {
}
/**
* @dev Increments the mint count for the specified wallet, token IDs, and amounts.
*
* @param to The address of the wallet.
* @param ids The array of token IDs.
* @param amounts The array of corresponding token amounts.
*/
function incrementMintCount(address to, uint256[] memory ids, uint256[] memory amounts) internal {
}
/**
* @dev Finds the token IDs with the least minted count for a given wallet address.
*
* This function returns an array of token IDs that have the least minted count for the specified wallet.
* If multiple token IDs have the same least minted count, all of them will be included in the result.
*
* Requirements:
* - `wallet` must be a valid address.
*
* @param wallet The wallet address for which to find the least owned token IDs.
* @return An array of token IDs with the least minted count for the specified wallet.
*/
function findLeastOwnedIds(address wallet) public view returns (uint256[] memory) {
}
function createArrayWithSameNumber(uint256 amount, uint256 number) internal pure returns (uint256[] memory) {
}
function shuffleArray(uint256[] memory array, uint256 seed) internal view returns (uint256[] memory) {
}
function mint(address to, uint256 id, uint256 amount, uint256 discountTokenId, bytes32[] calldata proof, bytes memory data)
public
payable
{
require(msg.sender == tx.origin || allowContractMints, "No contracts!");
require(checkSaleState(id), "Sale not active");
require(_checkSaleSchedule(saleSchedules[id]), "Not at this time");
require(tokenMaxSupply[id] == 0 || totalSupply(id) + amount <= tokenMaxSupply[id], "Supply exhausted");
require(perWalletMaxTokens[id] == 0 || balanceOf(to,id) + amount <= perWalletMaxTokens[id], "Reached per-wallet limit!");
require(checkForeignTokenLimits(to, amount), "Not enough foreign tokens");
require((merkleRoot == 0 || _verify(_leaf(msg.sender), proof) || _verify(_leaf(to), proof)), "Invalid Merkle proof");
require(discountTokenId <= discountUsed.length, "discountTokenId is out of range");
require(<FILL_ME>)
if (id == 0) {
uint256[] memory leastOwnedIds = findLeastOwnedIds(to);
// Shuffle the leastOwnedIds array
require(leastOwnedIds.length >= amount, "Unreasonable randomization request");
uint256 nounce = amount;
leastOwnedIds = shuffleArray(leastOwnedIds, nounce);
uint256[] memory randomIds = new uint256[](amount);
uint256 uniqueCount = 0;
for (uint256 i = 0; i < amount; i++) {
randomIds[i] = leastOwnedIds[i];
uniqueCount++;
}
require(uniqueCount == amount, "Unable to generate unique token IDs");
uint256[] memory amounts = createArrayWithSameNumber(amount, 1);
incrementMintCount(to, randomIds, amounts);
_mintBatch(to, randomIds, amounts, data);
return;
} else {
require(allowNonRandomMinting, "Only random minting");
mintCount[to][id] += amount;
_mint(to, id, amount, data);
}
}
function _getRandomIndex(uint256 length, uint256 nonce) internal view returns (uint256) {
}
function calculateForeignTokenCountMultiplied(address _wallet) public view returns (uint256) {
}
function checkForeignTokenLimits(address _wallet, uint256 _desiredAmount) public view returns (bool) {
}
function checkSaleState(uint256 _id) internal view returns (bool){
}
function setSaleActive(uint256[] memory ids, uint256[] memory tokenMaxSupplys, bool _globalLockAfterUpdate) external onlyRole(SALES_ROLE){
}
function addForeignTokenLimitRule(
address _foreignContract,
uint256 _foreignTokenTypeId,
uint256 _multiplier,
uint256 _start,
uint256 _end
) external onlyRole(SALES_ROLE) {
}
function resetForeignTokenLimits() external onlyRole(SALES_ROLE) {
}
function setSaleSchedule(uint256 _id, uint256 _start, uint256 _end) external onlyRole(SALES_ROLE){
}
function flipAllowContractMintsState() external onlyRole(ADMIN_ROLE){
}
function mintReservedTokens(address to, uint256 id, uint256 amount, bytes memory data) external onlyRole(RESERVED_MINT_ROLE){
}
function withdraw() external onlyRole(WITHDRAW_ROLE){
}
function mintBatch(address to, uint256[] memory ids, uint256[] memory amounts, bytes32[] calldata proof, bytes memory data)
public
payable
{
}
function _beforeTokenTransfer(address operator, address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data)
internal
whenNotPaused
override(ERC1155, ERC1155Supply)
{
}
// The following functions are overrides required by Solidity.
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC1155, AccessControl)
returns (bool)
{
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyRole(MERKLE_ROLE){
}
function setSaleMax(uint32 _limit, uint256 _id, bool _globalLockAfterUpdate) external onlyRole(SALES_ROLE){
}
function setPrice(uint256 _price) external onlyRole(SALES_ROLE){
}
function setWalletMax(uint256 _id, uint256 _walletLimit) external onlyRole(SALES_ROLE){
}
function setDiscountOwnerFunctionSelector(bytes4 _discountOwnerFunctionSelector) external onlyRole(SALES_ROLE){
}
function setContractURI(string memory _uri) external onlyRole(ADMIN_ROLE) {
}
function contractURI() public view returns (string memory) {
}
function _leaf(address account)
internal pure returns (bytes32)
{
}
function _verify(bytes32 leaf, bytes32[] memory proof)
internal view returns (bool)
{
}
function _checkSaleSchedule(saleSchedule memory s)
internal view returns (bool)
{
}
function _checkPrice(uint256 amount, uint256 discountTokenId)
internal returns (bool)
{
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
}
function _walletHoldsUnusedDiscountToken(address _wallet, address _contract, uint256 discountTokenId) internal returns (bool) {
}
function _walletHoldsForeign1155TokenCount(address _wallet, uint256 _foreignTokenId, address _contract) internal view returns (uint256) {
}
function setDiscountContract(address _discountContract, uint256 _maxTokenId, uint256 _discount) external onlyRole(ADMIN_ROLE) {
}
}
| _checkPrice(amount,discountTokenId),"Not enough ETH" | 263,936 | _checkPrice(amount,discountTokenId) |
"amount over max allowed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/**
ERC1155 Smart Contract - JUNIQUE POP Genesis Collection
Besitzer einer JUNIQUE Tasche bzw. JUNIQUE NFTs erhalten keine Exklusivrechte/Ownership an den verwendeten NFTs und an der verwendeten Musik.
*/
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Burnable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
/// @custom:security-contact [email protected]
contract JUNIQUE_POP_Genesis_Collection is ERC1155, AccessControl, ERC1155Burnable,Pausable, ERC1155Supply, PaymentSplitter {
using Counters for Counters.Counter;
uint public constant NUMBER_RESERVED_TOKENS = 500;
uint256 public price = 275000000000000000; // The initial price to mint in WEI.
uint256 public discount = 0;
mapping(uint256 => uint256) public tokenMaxSupply; // 0 is openEnd
mapping(uint256 => uint256) public perWalletMaxTokens; // 0 is openEnd
mapping(address => mapping(uint256 => uint256)) public mintCount;
bytes32 public merkleRoot;
address public discountContract = 0x0000000000000000000000000000000000000000;
bytes4 public discountOwnerFunctionSelector = bytes4(keccak256("ownerOf(uint256)"));
bytes32 public constant URI_SETTER_ROLE = keccak256("URI_SETTER_ROLE");
bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
bytes32 public constant WITHDRAW_ROLE = keccak256("WITHDRAW_ROLE");
bytes32 public constant SALES_ROLE = keccak256("SALES_ROLE");
bytes32 public constant RESERVED_MINT_ROLE = keccak256("RESERVED_MINT_ROLE");
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
bytes32 public constant MERKLE_ROLE = keccak256("MERKLE_ROLE");
uint256[] public saleIsActive;
struct saleSchedule {
uint256 start;
uint256 end;
}
struct foreignTokenLimitsRule {
address foreignContract;
uint256 foreignTokenTypeId;
uint256 multiplier;
saleSchedule schedule;
}
foreignTokenLimitsRule[] public foreignTokenLimits;
mapping(uint256 => saleSchedule) public saleSchedules;
bool public saleMaxLock = false;
bool public allowContractMints = false;
bool public allowNonRandomMinting = true;
bool[] public discountUsed;
Counters.Counter public reservedSupply;
string private _contractURI = "https://www.7art.io/bibi-beck/pop-genesis-collection/metadata_contract.json"; //The URI to the contract json
constructor(string memory uri_, address[] memory _payees, uint256[] memory _shares) ERC1155(uri_) PaymentSplitter(_payees, _shares) payable {
}
function setURI(string memory newuri) public onlyRole(URI_SETTER_ROLE) {
}
/**
* @dev Pauses all token transfers.
*
* See {Pausable} and {Pausable-_pause}.
*
* Requirements:
*
* - the caller must have the `PAUSER_ROLE`.
*/
function pause() public onlyRole(PAUSER_ROLE) {
}
/**
* @dev Sets the value of `allowNonRandomMinting`.
*
* Requirements:
*
* - the caller must have the `SALES_ROLE`.
*
* @param _allowNonRandomMinting The new value for `allowNonRandomMinting`.
*/
function setAllowNonRandomMinting(bool _allowNonRandomMinting) public onlyRole(SALES_ROLE) {
}
/**
* @dev Unpauses all token transfers.
*
* See {Pausable} and {Pausable-_unpause}.
*
* Requirements:
*
* - the caller must have the `PAUSER_ROLE`.
*/
function unpause() public onlyRole(PAUSER_ROLE) {
}
/**
* @dev Retrieves the summary of mint counts for a given wallet.
* @param wallet The address of the wallet.
* @return The total sum of mint counts for the wallet.
*/
function getMintCountSummary(address wallet) public view returns (uint256) {
}
/**
* @dev Increments the mint count for the specified wallet, token IDs, and amounts.
*
* @param to The address of the wallet.
* @param ids The array of token IDs.
* @param amounts The array of corresponding token amounts.
*/
function incrementMintCount(address to, uint256[] memory ids, uint256[] memory amounts) internal {
}
/**
* @dev Finds the token IDs with the least minted count for a given wallet address.
*
* This function returns an array of token IDs that have the least minted count for the specified wallet.
* If multiple token IDs have the same least minted count, all of them will be included in the result.
*
* Requirements:
* - `wallet` must be a valid address.
*
* @param wallet The wallet address for which to find the least owned token IDs.
* @return An array of token IDs with the least minted count for the specified wallet.
*/
function findLeastOwnedIds(address wallet) public view returns (uint256[] memory) {
}
function createArrayWithSameNumber(uint256 amount, uint256 number) internal pure returns (uint256[] memory) {
}
function shuffleArray(uint256[] memory array, uint256 seed) internal view returns (uint256[] memory) {
}
function mint(address to, uint256 id, uint256 amount, uint256 discountTokenId, bytes32[] calldata proof, bytes memory data)
public
payable
{
}
function _getRandomIndex(uint256 length, uint256 nonce) internal view returns (uint256) {
}
function calculateForeignTokenCountMultiplied(address _wallet) public view returns (uint256) {
}
function checkForeignTokenLimits(address _wallet, uint256 _desiredAmount) public view returns (bool) {
}
function checkSaleState(uint256 _id) internal view returns (bool){
}
function setSaleActive(uint256[] memory ids, uint256[] memory tokenMaxSupplys, bool _globalLockAfterUpdate) external onlyRole(SALES_ROLE){
}
function addForeignTokenLimitRule(
address _foreignContract,
uint256 _foreignTokenTypeId,
uint256 _multiplier,
uint256 _start,
uint256 _end
) external onlyRole(SALES_ROLE) {
}
function resetForeignTokenLimits() external onlyRole(SALES_ROLE) {
}
function setSaleSchedule(uint256 _id, uint256 _start, uint256 _end) external onlyRole(SALES_ROLE){
}
function flipAllowContractMintsState() external onlyRole(ADMIN_ROLE){
}
function mintReservedTokens(address to, uint256 id, uint256 amount, bytes memory data) external onlyRole(RESERVED_MINT_ROLE){
require(id > 0, "Invalid token type ID");
require(<FILL_ME>)
require(amount == 1 || hasRole(ADMIN_ROLE, _msgSender()), "> 1 only ADMIN_ROLE");
_mint(to, id, amount, data);
for (uint i = 0; i < amount; i++)
{
reservedSupply.increment();
}
}
function withdraw() external onlyRole(WITHDRAW_ROLE){
}
function mintBatch(address to, uint256[] memory ids, uint256[] memory amounts, bytes32[] calldata proof, bytes memory data)
public
payable
{
}
function _beforeTokenTransfer(address operator, address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data)
internal
whenNotPaused
override(ERC1155, ERC1155Supply)
{
}
// The following functions are overrides required by Solidity.
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC1155, AccessControl)
returns (bool)
{
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyRole(MERKLE_ROLE){
}
function setSaleMax(uint32 _limit, uint256 _id, bool _globalLockAfterUpdate) external onlyRole(SALES_ROLE){
}
function setPrice(uint256 _price) external onlyRole(SALES_ROLE){
}
function setWalletMax(uint256 _id, uint256 _walletLimit) external onlyRole(SALES_ROLE){
}
function setDiscountOwnerFunctionSelector(bytes4 _discountOwnerFunctionSelector) external onlyRole(SALES_ROLE){
}
function setContractURI(string memory _uri) external onlyRole(ADMIN_ROLE) {
}
function contractURI() public view returns (string memory) {
}
function _leaf(address account)
internal pure returns (bytes32)
{
}
function _verify(bytes32 leaf, bytes32[] memory proof)
internal view returns (bool)
{
}
function _checkSaleSchedule(saleSchedule memory s)
internal view returns (bool)
{
}
function _checkPrice(uint256 amount, uint256 discountTokenId)
internal returns (bool)
{
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
}
function _walletHoldsUnusedDiscountToken(address _wallet, address _contract, uint256 discountTokenId) internal returns (bool) {
}
function _walletHoldsForeign1155TokenCount(address _wallet, uint256 _foreignTokenId, address _contract) internal view returns (uint256) {
}
function setDiscountContract(address _discountContract, uint256 _maxTokenId, uint256 _discount) external onlyRole(ADMIN_ROLE) {
}
}
| reservedSupply.current()+amount<=NUMBER_RESERVED_TOKENS,"amount over max allowed" | 263,936 | reservedSupply.current()+amount<=NUMBER_RESERVED_TOKENS |
"Invalid token type ID" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/**
ERC1155 Smart Contract - JUNIQUE POP Genesis Collection
Besitzer einer JUNIQUE Tasche bzw. JUNIQUE NFTs erhalten keine Exklusivrechte/Ownership an den verwendeten NFTs und an der verwendeten Musik.
*/
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Burnable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
/// @custom:security-contact [email protected]
contract JUNIQUE_POP_Genesis_Collection is ERC1155, AccessControl, ERC1155Burnable,Pausable, ERC1155Supply, PaymentSplitter {
using Counters for Counters.Counter;
uint public constant NUMBER_RESERVED_TOKENS = 500;
uint256 public price = 275000000000000000; // The initial price to mint in WEI.
uint256 public discount = 0;
mapping(uint256 => uint256) public tokenMaxSupply; // 0 is openEnd
mapping(uint256 => uint256) public perWalletMaxTokens; // 0 is openEnd
mapping(address => mapping(uint256 => uint256)) public mintCount;
bytes32 public merkleRoot;
address public discountContract = 0x0000000000000000000000000000000000000000;
bytes4 public discountOwnerFunctionSelector = bytes4(keccak256("ownerOf(uint256)"));
bytes32 public constant URI_SETTER_ROLE = keccak256("URI_SETTER_ROLE");
bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
bytes32 public constant WITHDRAW_ROLE = keccak256("WITHDRAW_ROLE");
bytes32 public constant SALES_ROLE = keccak256("SALES_ROLE");
bytes32 public constant RESERVED_MINT_ROLE = keccak256("RESERVED_MINT_ROLE");
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
bytes32 public constant MERKLE_ROLE = keccak256("MERKLE_ROLE");
uint256[] public saleIsActive;
struct saleSchedule {
uint256 start;
uint256 end;
}
struct foreignTokenLimitsRule {
address foreignContract;
uint256 foreignTokenTypeId;
uint256 multiplier;
saleSchedule schedule;
}
foreignTokenLimitsRule[] public foreignTokenLimits;
mapping(uint256 => saleSchedule) public saleSchedules;
bool public saleMaxLock = false;
bool public allowContractMints = false;
bool public allowNonRandomMinting = true;
bool[] public discountUsed;
Counters.Counter public reservedSupply;
string private _contractURI = "https://www.7art.io/bibi-beck/pop-genesis-collection/metadata_contract.json"; //The URI to the contract json
constructor(string memory uri_, address[] memory _payees, uint256[] memory _shares) ERC1155(uri_) PaymentSplitter(_payees, _shares) payable {
}
function setURI(string memory newuri) public onlyRole(URI_SETTER_ROLE) {
}
/**
* @dev Pauses all token transfers.
*
* See {Pausable} and {Pausable-_pause}.
*
* Requirements:
*
* - the caller must have the `PAUSER_ROLE`.
*/
function pause() public onlyRole(PAUSER_ROLE) {
}
/**
* @dev Sets the value of `allowNonRandomMinting`.
*
* Requirements:
*
* - the caller must have the `SALES_ROLE`.
*
* @param _allowNonRandomMinting The new value for `allowNonRandomMinting`.
*/
function setAllowNonRandomMinting(bool _allowNonRandomMinting) public onlyRole(SALES_ROLE) {
}
/**
* @dev Unpauses all token transfers.
*
* See {Pausable} and {Pausable-_unpause}.
*
* Requirements:
*
* - the caller must have the `PAUSER_ROLE`.
*/
function unpause() public onlyRole(PAUSER_ROLE) {
}
/**
* @dev Retrieves the summary of mint counts for a given wallet.
* @param wallet The address of the wallet.
* @return The total sum of mint counts for the wallet.
*/
function getMintCountSummary(address wallet) public view returns (uint256) {
}
/**
* @dev Increments the mint count for the specified wallet, token IDs, and amounts.
*
* @param to The address of the wallet.
* @param ids The array of token IDs.
* @param amounts The array of corresponding token amounts.
*/
function incrementMintCount(address to, uint256[] memory ids, uint256[] memory amounts) internal {
}
/**
* @dev Finds the token IDs with the least minted count for a given wallet address.
*
* This function returns an array of token IDs that have the least minted count for the specified wallet.
* If multiple token IDs have the same least minted count, all of them will be included in the result.
*
* Requirements:
* - `wallet` must be a valid address.
*
* @param wallet The wallet address for which to find the least owned token IDs.
* @return An array of token IDs with the least minted count for the specified wallet.
*/
function findLeastOwnedIds(address wallet) public view returns (uint256[] memory) {
}
function createArrayWithSameNumber(uint256 amount, uint256 number) internal pure returns (uint256[] memory) {
}
function shuffleArray(uint256[] memory array, uint256 seed) internal view returns (uint256[] memory) {
}
function mint(address to, uint256 id, uint256 amount, uint256 discountTokenId, bytes32[] calldata proof, bytes memory data)
public
payable
{
}
function _getRandomIndex(uint256 length, uint256 nonce) internal view returns (uint256) {
}
function calculateForeignTokenCountMultiplied(address _wallet) public view returns (uint256) {
}
function checkForeignTokenLimits(address _wallet, uint256 _desiredAmount) public view returns (bool) {
}
function checkSaleState(uint256 _id) internal view returns (bool){
}
function setSaleActive(uint256[] memory ids, uint256[] memory tokenMaxSupplys, bool _globalLockAfterUpdate) external onlyRole(SALES_ROLE){
}
function addForeignTokenLimitRule(
address _foreignContract,
uint256 _foreignTokenTypeId,
uint256 _multiplier,
uint256 _start,
uint256 _end
) external onlyRole(SALES_ROLE) {
}
function resetForeignTokenLimits() external onlyRole(SALES_ROLE) {
}
function setSaleSchedule(uint256 _id, uint256 _start, uint256 _end) external onlyRole(SALES_ROLE){
}
function flipAllowContractMintsState() external onlyRole(ADMIN_ROLE){
}
function mintReservedTokens(address to, uint256 id, uint256 amount, bytes memory data) external onlyRole(RESERVED_MINT_ROLE){
}
function withdraw() external onlyRole(WITHDRAW_ROLE){
}
function mintBatch(address to, uint256[] memory ids, uint256[] memory amounts, bytes32[] calldata proof, bytes memory data)
public
payable
{
require(allowNonRandomMinting, "Only random minting");
require(msg.sender == tx.origin || allowContractMints, "No contracts!");
require((merkleRoot == 0 || _verify(_leaf(msg.sender), proof) || _verify(_leaf(to), proof)), "Invalid Merkle proof");
uint256 idsLen = ids.length;
uint256 totalAmount = 0;
for (uint256 i = 0; i < idsLen; ++i) {
require(<FILL_ME>)
require(checkSaleState(ids[i]), "Sale not active");
require(_checkSaleSchedule(saleSchedules[ids[i]]), "Not at this time");
require(tokenMaxSupply[ids[i]] == 0 || totalSupply(ids[i]) + amounts[i] <= tokenMaxSupply[ids[i]], "Supply exhausted");
require(perWalletMaxTokens[ids[i]] == 0 || balanceOf(to, ids[i]) + amounts[i] <= perWalletMaxTokens[ids[i]], "Reached per-wallet limit!");
totalAmount = totalAmount + amounts[i];
}
require(checkForeignTokenLimits(to, totalAmount), "Not enough foreign tokens");
require(_checkPrice(totalAmount, 0), "Not enough ETH");
incrementMintCount(to,ids,amounts);
_mintBatch(to, ids, amounts, data);
}
function _beforeTokenTransfer(address operator, address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data)
internal
whenNotPaused
override(ERC1155, ERC1155Supply)
{
}
// The following functions are overrides required by Solidity.
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC1155, AccessControl)
returns (bool)
{
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyRole(MERKLE_ROLE){
}
function setSaleMax(uint32 _limit, uint256 _id, bool _globalLockAfterUpdate) external onlyRole(SALES_ROLE){
}
function setPrice(uint256 _price) external onlyRole(SALES_ROLE){
}
function setWalletMax(uint256 _id, uint256 _walletLimit) external onlyRole(SALES_ROLE){
}
function setDiscountOwnerFunctionSelector(bytes4 _discountOwnerFunctionSelector) external onlyRole(SALES_ROLE){
}
function setContractURI(string memory _uri) external onlyRole(ADMIN_ROLE) {
}
function contractURI() public view returns (string memory) {
}
function _leaf(address account)
internal pure returns (bytes32)
{
}
function _verify(bytes32 leaf, bytes32[] memory proof)
internal view returns (bool)
{
}
function _checkSaleSchedule(saleSchedule memory s)
internal view returns (bool)
{
}
function _checkPrice(uint256 amount, uint256 discountTokenId)
internal returns (bool)
{
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
}
function _walletHoldsUnusedDiscountToken(address _wallet, address _contract, uint256 discountTokenId) internal returns (bool) {
}
function _walletHoldsForeign1155TokenCount(address _wallet, uint256 _foreignTokenId, address _contract) internal view returns (uint256) {
}
function setDiscountContract(address _discountContract, uint256 _maxTokenId, uint256 _discount) external onlyRole(ADMIN_ROLE) {
}
}
| ids[i]>0,"Invalid token type ID" | 263,936 | ids[i]>0 |
"Sale not active" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/**
ERC1155 Smart Contract - JUNIQUE POP Genesis Collection
Besitzer einer JUNIQUE Tasche bzw. JUNIQUE NFTs erhalten keine Exklusivrechte/Ownership an den verwendeten NFTs und an der verwendeten Musik.
*/
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Burnable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
/// @custom:security-contact [email protected]
contract JUNIQUE_POP_Genesis_Collection is ERC1155, AccessControl, ERC1155Burnable,Pausable, ERC1155Supply, PaymentSplitter {
using Counters for Counters.Counter;
uint public constant NUMBER_RESERVED_TOKENS = 500;
uint256 public price = 275000000000000000; // The initial price to mint in WEI.
uint256 public discount = 0;
mapping(uint256 => uint256) public tokenMaxSupply; // 0 is openEnd
mapping(uint256 => uint256) public perWalletMaxTokens; // 0 is openEnd
mapping(address => mapping(uint256 => uint256)) public mintCount;
bytes32 public merkleRoot;
address public discountContract = 0x0000000000000000000000000000000000000000;
bytes4 public discountOwnerFunctionSelector = bytes4(keccak256("ownerOf(uint256)"));
bytes32 public constant URI_SETTER_ROLE = keccak256("URI_SETTER_ROLE");
bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
bytes32 public constant WITHDRAW_ROLE = keccak256("WITHDRAW_ROLE");
bytes32 public constant SALES_ROLE = keccak256("SALES_ROLE");
bytes32 public constant RESERVED_MINT_ROLE = keccak256("RESERVED_MINT_ROLE");
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
bytes32 public constant MERKLE_ROLE = keccak256("MERKLE_ROLE");
uint256[] public saleIsActive;
struct saleSchedule {
uint256 start;
uint256 end;
}
struct foreignTokenLimitsRule {
address foreignContract;
uint256 foreignTokenTypeId;
uint256 multiplier;
saleSchedule schedule;
}
foreignTokenLimitsRule[] public foreignTokenLimits;
mapping(uint256 => saleSchedule) public saleSchedules;
bool public saleMaxLock = false;
bool public allowContractMints = false;
bool public allowNonRandomMinting = true;
bool[] public discountUsed;
Counters.Counter public reservedSupply;
string private _contractURI = "https://www.7art.io/bibi-beck/pop-genesis-collection/metadata_contract.json"; //The URI to the contract json
constructor(string memory uri_, address[] memory _payees, uint256[] memory _shares) ERC1155(uri_) PaymentSplitter(_payees, _shares) payable {
}
function setURI(string memory newuri) public onlyRole(URI_SETTER_ROLE) {
}
/**
* @dev Pauses all token transfers.
*
* See {Pausable} and {Pausable-_pause}.
*
* Requirements:
*
* - the caller must have the `PAUSER_ROLE`.
*/
function pause() public onlyRole(PAUSER_ROLE) {
}
/**
* @dev Sets the value of `allowNonRandomMinting`.
*
* Requirements:
*
* - the caller must have the `SALES_ROLE`.
*
* @param _allowNonRandomMinting The new value for `allowNonRandomMinting`.
*/
function setAllowNonRandomMinting(bool _allowNonRandomMinting) public onlyRole(SALES_ROLE) {
}
/**
* @dev Unpauses all token transfers.
*
* See {Pausable} and {Pausable-_unpause}.
*
* Requirements:
*
* - the caller must have the `PAUSER_ROLE`.
*/
function unpause() public onlyRole(PAUSER_ROLE) {
}
/**
* @dev Retrieves the summary of mint counts for a given wallet.
* @param wallet The address of the wallet.
* @return The total sum of mint counts for the wallet.
*/
function getMintCountSummary(address wallet) public view returns (uint256) {
}
/**
* @dev Increments the mint count for the specified wallet, token IDs, and amounts.
*
* @param to The address of the wallet.
* @param ids The array of token IDs.
* @param amounts The array of corresponding token amounts.
*/
function incrementMintCount(address to, uint256[] memory ids, uint256[] memory amounts) internal {
}
/**
* @dev Finds the token IDs with the least minted count for a given wallet address.
*
* This function returns an array of token IDs that have the least minted count for the specified wallet.
* If multiple token IDs have the same least minted count, all of them will be included in the result.
*
* Requirements:
* - `wallet` must be a valid address.
*
* @param wallet The wallet address for which to find the least owned token IDs.
* @return An array of token IDs with the least minted count for the specified wallet.
*/
function findLeastOwnedIds(address wallet) public view returns (uint256[] memory) {
}
function createArrayWithSameNumber(uint256 amount, uint256 number) internal pure returns (uint256[] memory) {
}
function shuffleArray(uint256[] memory array, uint256 seed) internal view returns (uint256[] memory) {
}
function mint(address to, uint256 id, uint256 amount, uint256 discountTokenId, bytes32[] calldata proof, bytes memory data)
public
payable
{
}
function _getRandomIndex(uint256 length, uint256 nonce) internal view returns (uint256) {
}
function calculateForeignTokenCountMultiplied(address _wallet) public view returns (uint256) {
}
function checkForeignTokenLimits(address _wallet, uint256 _desiredAmount) public view returns (bool) {
}
function checkSaleState(uint256 _id) internal view returns (bool){
}
function setSaleActive(uint256[] memory ids, uint256[] memory tokenMaxSupplys, bool _globalLockAfterUpdate) external onlyRole(SALES_ROLE){
}
function addForeignTokenLimitRule(
address _foreignContract,
uint256 _foreignTokenTypeId,
uint256 _multiplier,
uint256 _start,
uint256 _end
) external onlyRole(SALES_ROLE) {
}
function resetForeignTokenLimits() external onlyRole(SALES_ROLE) {
}
function setSaleSchedule(uint256 _id, uint256 _start, uint256 _end) external onlyRole(SALES_ROLE){
}
function flipAllowContractMintsState() external onlyRole(ADMIN_ROLE){
}
function mintReservedTokens(address to, uint256 id, uint256 amount, bytes memory data) external onlyRole(RESERVED_MINT_ROLE){
}
function withdraw() external onlyRole(WITHDRAW_ROLE){
}
function mintBatch(address to, uint256[] memory ids, uint256[] memory amounts, bytes32[] calldata proof, bytes memory data)
public
payable
{
require(allowNonRandomMinting, "Only random minting");
require(msg.sender == tx.origin || allowContractMints, "No contracts!");
require((merkleRoot == 0 || _verify(_leaf(msg.sender), proof) || _verify(_leaf(to), proof)), "Invalid Merkle proof");
uint256 idsLen = ids.length;
uint256 totalAmount = 0;
for (uint256 i = 0; i < idsLen; ++i) {
require(ids[i] > 0, "Invalid token type ID");
require(<FILL_ME>)
require(_checkSaleSchedule(saleSchedules[ids[i]]), "Not at this time");
require(tokenMaxSupply[ids[i]] == 0 || totalSupply(ids[i]) + amounts[i] <= tokenMaxSupply[ids[i]], "Supply exhausted");
require(perWalletMaxTokens[ids[i]] == 0 || balanceOf(to, ids[i]) + amounts[i] <= perWalletMaxTokens[ids[i]], "Reached per-wallet limit!");
totalAmount = totalAmount + amounts[i];
}
require(checkForeignTokenLimits(to, totalAmount), "Not enough foreign tokens");
require(_checkPrice(totalAmount, 0), "Not enough ETH");
incrementMintCount(to,ids,amounts);
_mintBatch(to, ids, amounts, data);
}
function _beforeTokenTransfer(address operator, address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data)
internal
whenNotPaused
override(ERC1155, ERC1155Supply)
{
}
// The following functions are overrides required by Solidity.
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC1155, AccessControl)
returns (bool)
{
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyRole(MERKLE_ROLE){
}
function setSaleMax(uint32 _limit, uint256 _id, bool _globalLockAfterUpdate) external onlyRole(SALES_ROLE){
}
function setPrice(uint256 _price) external onlyRole(SALES_ROLE){
}
function setWalletMax(uint256 _id, uint256 _walletLimit) external onlyRole(SALES_ROLE){
}
function setDiscountOwnerFunctionSelector(bytes4 _discountOwnerFunctionSelector) external onlyRole(SALES_ROLE){
}
function setContractURI(string memory _uri) external onlyRole(ADMIN_ROLE) {
}
function contractURI() public view returns (string memory) {
}
function _leaf(address account)
internal pure returns (bytes32)
{
}
function _verify(bytes32 leaf, bytes32[] memory proof)
internal view returns (bool)
{
}
function _checkSaleSchedule(saleSchedule memory s)
internal view returns (bool)
{
}
function _checkPrice(uint256 amount, uint256 discountTokenId)
internal returns (bool)
{
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
}
function _walletHoldsUnusedDiscountToken(address _wallet, address _contract, uint256 discountTokenId) internal returns (bool) {
}
function _walletHoldsForeign1155TokenCount(address _wallet, uint256 _foreignTokenId, address _contract) internal view returns (uint256) {
}
function setDiscountContract(address _discountContract, uint256 _maxTokenId, uint256 _discount) external onlyRole(ADMIN_ROLE) {
}
}
| checkSaleState(ids[i]),"Sale not active" | 263,936 | checkSaleState(ids[i]) |
"Not at this time" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/**
ERC1155 Smart Contract - JUNIQUE POP Genesis Collection
Besitzer einer JUNIQUE Tasche bzw. JUNIQUE NFTs erhalten keine Exklusivrechte/Ownership an den verwendeten NFTs und an der verwendeten Musik.
*/
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Burnable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
/// @custom:security-contact [email protected]
contract JUNIQUE_POP_Genesis_Collection is ERC1155, AccessControl, ERC1155Burnable,Pausable, ERC1155Supply, PaymentSplitter {
using Counters for Counters.Counter;
uint public constant NUMBER_RESERVED_TOKENS = 500;
uint256 public price = 275000000000000000; // The initial price to mint in WEI.
uint256 public discount = 0;
mapping(uint256 => uint256) public tokenMaxSupply; // 0 is openEnd
mapping(uint256 => uint256) public perWalletMaxTokens; // 0 is openEnd
mapping(address => mapping(uint256 => uint256)) public mintCount;
bytes32 public merkleRoot;
address public discountContract = 0x0000000000000000000000000000000000000000;
bytes4 public discountOwnerFunctionSelector = bytes4(keccak256("ownerOf(uint256)"));
bytes32 public constant URI_SETTER_ROLE = keccak256("URI_SETTER_ROLE");
bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
bytes32 public constant WITHDRAW_ROLE = keccak256("WITHDRAW_ROLE");
bytes32 public constant SALES_ROLE = keccak256("SALES_ROLE");
bytes32 public constant RESERVED_MINT_ROLE = keccak256("RESERVED_MINT_ROLE");
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
bytes32 public constant MERKLE_ROLE = keccak256("MERKLE_ROLE");
uint256[] public saleIsActive;
struct saleSchedule {
uint256 start;
uint256 end;
}
struct foreignTokenLimitsRule {
address foreignContract;
uint256 foreignTokenTypeId;
uint256 multiplier;
saleSchedule schedule;
}
foreignTokenLimitsRule[] public foreignTokenLimits;
mapping(uint256 => saleSchedule) public saleSchedules;
bool public saleMaxLock = false;
bool public allowContractMints = false;
bool public allowNonRandomMinting = true;
bool[] public discountUsed;
Counters.Counter public reservedSupply;
string private _contractURI = "https://www.7art.io/bibi-beck/pop-genesis-collection/metadata_contract.json"; //The URI to the contract json
constructor(string memory uri_, address[] memory _payees, uint256[] memory _shares) ERC1155(uri_) PaymentSplitter(_payees, _shares) payable {
}
function setURI(string memory newuri) public onlyRole(URI_SETTER_ROLE) {
}
/**
* @dev Pauses all token transfers.
*
* See {Pausable} and {Pausable-_pause}.
*
* Requirements:
*
* - the caller must have the `PAUSER_ROLE`.
*/
function pause() public onlyRole(PAUSER_ROLE) {
}
/**
* @dev Sets the value of `allowNonRandomMinting`.
*
* Requirements:
*
* - the caller must have the `SALES_ROLE`.
*
* @param _allowNonRandomMinting The new value for `allowNonRandomMinting`.
*/
function setAllowNonRandomMinting(bool _allowNonRandomMinting) public onlyRole(SALES_ROLE) {
}
/**
* @dev Unpauses all token transfers.
*
* See {Pausable} and {Pausable-_unpause}.
*
* Requirements:
*
* - the caller must have the `PAUSER_ROLE`.
*/
function unpause() public onlyRole(PAUSER_ROLE) {
}
/**
* @dev Retrieves the summary of mint counts for a given wallet.
* @param wallet The address of the wallet.
* @return The total sum of mint counts for the wallet.
*/
function getMintCountSummary(address wallet) public view returns (uint256) {
}
/**
* @dev Increments the mint count for the specified wallet, token IDs, and amounts.
*
* @param to The address of the wallet.
* @param ids The array of token IDs.
* @param amounts The array of corresponding token amounts.
*/
function incrementMintCount(address to, uint256[] memory ids, uint256[] memory amounts) internal {
}
/**
* @dev Finds the token IDs with the least minted count for a given wallet address.
*
* This function returns an array of token IDs that have the least minted count for the specified wallet.
* If multiple token IDs have the same least minted count, all of them will be included in the result.
*
* Requirements:
* - `wallet` must be a valid address.
*
* @param wallet The wallet address for which to find the least owned token IDs.
* @return An array of token IDs with the least minted count for the specified wallet.
*/
function findLeastOwnedIds(address wallet) public view returns (uint256[] memory) {
}
function createArrayWithSameNumber(uint256 amount, uint256 number) internal pure returns (uint256[] memory) {
}
function shuffleArray(uint256[] memory array, uint256 seed) internal view returns (uint256[] memory) {
}
function mint(address to, uint256 id, uint256 amount, uint256 discountTokenId, bytes32[] calldata proof, bytes memory data)
public
payable
{
}
function _getRandomIndex(uint256 length, uint256 nonce) internal view returns (uint256) {
}
function calculateForeignTokenCountMultiplied(address _wallet) public view returns (uint256) {
}
function checkForeignTokenLimits(address _wallet, uint256 _desiredAmount) public view returns (bool) {
}
function checkSaleState(uint256 _id) internal view returns (bool){
}
function setSaleActive(uint256[] memory ids, uint256[] memory tokenMaxSupplys, bool _globalLockAfterUpdate) external onlyRole(SALES_ROLE){
}
function addForeignTokenLimitRule(
address _foreignContract,
uint256 _foreignTokenTypeId,
uint256 _multiplier,
uint256 _start,
uint256 _end
) external onlyRole(SALES_ROLE) {
}
function resetForeignTokenLimits() external onlyRole(SALES_ROLE) {
}
function setSaleSchedule(uint256 _id, uint256 _start, uint256 _end) external onlyRole(SALES_ROLE){
}
function flipAllowContractMintsState() external onlyRole(ADMIN_ROLE){
}
function mintReservedTokens(address to, uint256 id, uint256 amount, bytes memory data) external onlyRole(RESERVED_MINT_ROLE){
}
function withdraw() external onlyRole(WITHDRAW_ROLE){
}
function mintBatch(address to, uint256[] memory ids, uint256[] memory amounts, bytes32[] calldata proof, bytes memory data)
public
payable
{
require(allowNonRandomMinting, "Only random minting");
require(msg.sender == tx.origin || allowContractMints, "No contracts!");
require((merkleRoot == 0 || _verify(_leaf(msg.sender), proof) || _verify(_leaf(to), proof)), "Invalid Merkle proof");
uint256 idsLen = ids.length;
uint256 totalAmount = 0;
for (uint256 i = 0; i < idsLen; ++i) {
require(ids[i] > 0, "Invalid token type ID");
require(checkSaleState(ids[i]), "Sale not active");
require(<FILL_ME>)
require(tokenMaxSupply[ids[i]] == 0 || totalSupply(ids[i]) + amounts[i] <= tokenMaxSupply[ids[i]], "Supply exhausted");
require(perWalletMaxTokens[ids[i]] == 0 || balanceOf(to, ids[i]) + amounts[i] <= perWalletMaxTokens[ids[i]], "Reached per-wallet limit!");
totalAmount = totalAmount + amounts[i];
}
require(checkForeignTokenLimits(to, totalAmount), "Not enough foreign tokens");
require(_checkPrice(totalAmount, 0), "Not enough ETH");
incrementMintCount(to,ids,amounts);
_mintBatch(to, ids, amounts, data);
}
function _beforeTokenTransfer(address operator, address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data)
internal
whenNotPaused
override(ERC1155, ERC1155Supply)
{
}
// The following functions are overrides required by Solidity.
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC1155, AccessControl)
returns (bool)
{
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyRole(MERKLE_ROLE){
}
function setSaleMax(uint32 _limit, uint256 _id, bool _globalLockAfterUpdate) external onlyRole(SALES_ROLE){
}
function setPrice(uint256 _price) external onlyRole(SALES_ROLE){
}
function setWalletMax(uint256 _id, uint256 _walletLimit) external onlyRole(SALES_ROLE){
}
function setDiscountOwnerFunctionSelector(bytes4 _discountOwnerFunctionSelector) external onlyRole(SALES_ROLE){
}
function setContractURI(string memory _uri) external onlyRole(ADMIN_ROLE) {
}
function contractURI() public view returns (string memory) {
}
function _leaf(address account)
internal pure returns (bytes32)
{
}
function _verify(bytes32 leaf, bytes32[] memory proof)
internal view returns (bool)
{
}
function _checkSaleSchedule(saleSchedule memory s)
internal view returns (bool)
{
}
function _checkPrice(uint256 amount, uint256 discountTokenId)
internal returns (bool)
{
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
}
function _walletHoldsUnusedDiscountToken(address _wallet, address _contract, uint256 discountTokenId) internal returns (bool) {
}
function _walletHoldsForeign1155TokenCount(address _wallet, uint256 _foreignTokenId, address _contract) internal view returns (uint256) {
}
function setDiscountContract(address _discountContract, uint256 _maxTokenId, uint256 _discount) external onlyRole(ADMIN_ROLE) {
}
}
| _checkSaleSchedule(saleSchedules[ids[i]]),"Not at this time" | 263,936 | _checkSaleSchedule(saleSchedules[ids[i]]) |
"Supply exhausted" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/**
ERC1155 Smart Contract - JUNIQUE POP Genesis Collection
Besitzer einer JUNIQUE Tasche bzw. JUNIQUE NFTs erhalten keine Exklusivrechte/Ownership an den verwendeten NFTs und an der verwendeten Musik.
*/
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Burnable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
/// @custom:security-contact [email protected]
contract JUNIQUE_POP_Genesis_Collection is ERC1155, AccessControl, ERC1155Burnable,Pausable, ERC1155Supply, PaymentSplitter {
using Counters for Counters.Counter;
uint public constant NUMBER_RESERVED_TOKENS = 500;
uint256 public price = 275000000000000000; // The initial price to mint in WEI.
uint256 public discount = 0;
mapping(uint256 => uint256) public tokenMaxSupply; // 0 is openEnd
mapping(uint256 => uint256) public perWalletMaxTokens; // 0 is openEnd
mapping(address => mapping(uint256 => uint256)) public mintCount;
bytes32 public merkleRoot;
address public discountContract = 0x0000000000000000000000000000000000000000;
bytes4 public discountOwnerFunctionSelector = bytes4(keccak256("ownerOf(uint256)"));
bytes32 public constant URI_SETTER_ROLE = keccak256("URI_SETTER_ROLE");
bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
bytes32 public constant WITHDRAW_ROLE = keccak256("WITHDRAW_ROLE");
bytes32 public constant SALES_ROLE = keccak256("SALES_ROLE");
bytes32 public constant RESERVED_MINT_ROLE = keccak256("RESERVED_MINT_ROLE");
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
bytes32 public constant MERKLE_ROLE = keccak256("MERKLE_ROLE");
uint256[] public saleIsActive;
struct saleSchedule {
uint256 start;
uint256 end;
}
struct foreignTokenLimitsRule {
address foreignContract;
uint256 foreignTokenTypeId;
uint256 multiplier;
saleSchedule schedule;
}
foreignTokenLimitsRule[] public foreignTokenLimits;
mapping(uint256 => saleSchedule) public saleSchedules;
bool public saleMaxLock = false;
bool public allowContractMints = false;
bool public allowNonRandomMinting = true;
bool[] public discountUsed;
Counters.Counter public reservedSupply;
string private _contractURI = "https://www.7art.io/bibi-beck/pop-genesis-collection/metadata_contract.json"; //The URI to the contract json
constructor(string memory uri_, address[] memory _payees, uint256[] memory _shares) ERC1155(uri_) PaymentSplitter(_payees, _shares) payable {
}
function setURI(string memory newuri) public onlyRole(URI_SETTER_ROLE) {
}
/**
* @dev Pauses all token transfers.
*
* See {Pausable} and {Pausable-_pause}.
*
* Requirements:
*
* - the caller must have the `PAUSER_ROLE`.
*/
function pause() public onlyRole(PAUSER_ROLE) {
}
/**
* @dev Sets the value of `allowNonRandomMinting`.
*
* Requirements:
*
* - the caller must have the `SALES_ROLE`.
*
* @param _allowNonRandomMinting The new value for `allowNonRandomMinting`.
*/
function setAllowNonRandomMinting(bool _allowNonRandomMinting) public onlyRole(SALES_ROLE) {
}
/**
* @dev Unpauses all token transfers.
*
* See {Pausable} and {Pausable-_unpause}.
*
* Requirements:
*
* - the caller must have the `PAUSER_ROLE`.
*/
function unpause() public onlyRole(PAUSER_ROLE) {
}
/**
* @dev Retrieves the summary of mint counts for a given wallet.
* @param wallet The address of the wallet.
* @return The total sum of mint counts for the wallet.
*/
function getMintCountSummary(address wallet) public view returns (uint256) {
}
/**
* @dev Increments the mint count for the specified wallet, token IDs, and amounts.
*
* @param to The address of the wallet.
* @param ids The array of token IDs.
* @param amounts The array of corresponding token amounts.
*/
function incrementMintCount(address to, uint256[] memory ids, uint256[] memory amounts) internal {
}
/**
* @dev Finds the token IDs with the least minted count for a given wallet address.
*
* This function returns an array of token IDs that have the least minted count for the specified wallet.
* If multiple token IDs have the same least minted count, all of them will be included in the result.
*
* Requirements:
* - `wallet` must be a valid address.
*
* @param wallet The wallet address for which to find the least owned token IDs.
* @return An array of token IDs with the least minted count for the specified wallet.
*/
function findLeastOwnedIds(address wallet) public view returns (uint256[] memory) {
}
function createArrayWithSameNumber(uint256 amount, uint256 number) internal pure returns (uint256[] memory) {
}
function shuffleArray(uint256[] memory array, uint256 seed) internal view returns (uint256[] memory) {
}
function mint(address to, uint256 id, uint256 amount, uint256 discountTokenId, bytes32[] calldata proof, bytes memory data)
public
payable
{
}
function _getRandomIndex(uint256 length, uint256 nonce) internal view returns (uint256) {
}
function calculateForeignTokenCountMultiplied(address _wallet) public view returns (uint256) {
}
function checkForeignTokenLimits(address _wallet, uint256 _desiredAmount) public view returns (bool) {
}
function checkSaleState(uint256 _id) internal view returns (bool){
}
function setSaleActive(uint256[] memory ids, uint256[] memory tokenMaxSupplys, bool _globalLockAfterUpdate) external onlyRole(SALES_ROLE){
}
function addForeignTokenLimitRule(
address _foreignContract,
uint256 _foreignTokenTypeId,
uint256 _multiplier,
uint256 _start,
uint256 _end
) external onlyRole(SALES_ROLE) {
}
function resetForeignTokenLimits() external onlyRole(SALES_ROLE) {
}
function setSaleSchedule(uint256 _id, uint256 _start, uint256 _end) external onlyRole(SALES_ROLE){
}
function flipAllowContractMintsState() external onlyRole(ADMIN_ROLE){
}
function mintReservedTokens(address to, uint256 id, uint256 amount, bytes memory data) external onlyRole(RESERVED_MINT_ROLE){
}
function withdraw() external onlyRole(WITHDRAW_ROLE){
}
function mintBatch(address to, uint256[] memory ids, uint256[] memory amounts, bytes32[] calldata proof, bytes memory data)
public
payable
{
require(allowNonRandomMinting, "Only random minting");
require(msg.sender == tx.origin || allowContractMints, "No contracts!");
require((merkleRoot == 0 || _verify(_leaf(msg.sender), proof) || _verify(_leaf(to), proof)), "Invalid Merkle proof");
uint256 idsLen = ids.length;
uint256 totalAmount = 0;
for (uint256 i = 0; i < idsLen; ++i) {
require(ids[i] > 0, "Invalid token type ID");
require(checkSaleState(ids[i]), "Sale not active");
require(_checkSaleSchedule(saleSchedules[ids[i]]), "Not at this time");
require(<FILL_ME>)
require(perWalletMaxTokens[ids[i]] == 0 || balanceOf(to, ids[i]) + amounts[i] <= perWalletMaxTokens[ids[i]], "Reached per-wallet limit!");
totalAmount = totalAmount + amounts[i];
}
require(checkForeignTokenLimits(to, totalAmount), "Not enough foreign tokens");
require(_checkPrice(totalAmount, 0), "Not enough ETH");
incrementMintCount(to,ids,amounts);
_mintBatch(to, ids, amounts, data);
}
function _beforeTokenTransfer(address operator, address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data)
internal
whenNotPaused
override(ERC1155, ERC1155Supply)
{
}
// The following functions are overrides required by Solidity.
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC1155, AccessControl)
returns (bool)
{
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyRole(MERKLE_ROLE){
}
function setSaleMax(uint32 _limit, uint256 _id, bool _globalLockAfterUpdate) external onlyRole(SALES_ROLE){
}
function setPrice(uint256 _price) external onlyRole(SALES_ROLE){
}
function setWalletMax(uint256 _id, uint256 _walletLimit) external onlyRole(SALES_ROLE){
}
function setDiscountOwnerFunctionSelector(bytes4 _discountOwnerFunctionSelector) external onlyRole(SALES_ROLE){
}
function setContractURI(string memory _uri) external onlyRole(ADMIN_ROLE) {
}
function contractURI() public view returns (string memory) {
}
function _leaf(address account)
internal pure returns (bytes32)
{
}
function _verify(bytes32 leaf, bytes32[] memory proof)
internal view returns (bool)
{
}
function _checkSaleSchedule(saleSchedule memory s)
internal view returns (bool)
{
}
function _checkPrice(uint256 amount, uint256 discountTokenId)
internal returns (bool)
{
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
}
function _walletHoldsUnusedDiscountToken(address _wallet, address _contract, uint256 discountTokenId) internal returns (bool) {
}
function _walletHoldsForeign1155TokenCount(address _wallet, uint256 _foreignTokenId, address _contract) internal view returns (uint256) {
}
function setDiscountContract(address _discountContract, uint256 _maxTokenId, uint256 _discount) external onlyRole(ADMIN_ROLE) {
}
}
| tokenMaxSupply[ids[i]]==0||totalSupply(ids[i])+amounts[i]<=tokenMaxSupply[ids[i]],"Supply exhausted" | 263,936 | tokenMaxSupply[ids[i]]==0||totalSupply(ids[i])+amounts[i]<=tokenMaxSupply[ids[i]] |
"Reached per-wallet limit!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/**
ERC1155 Smart Contract - JUNIQUE POP Genesis Collection
Besitzer einer JUNIQUE Tasche bzw. JUNIQUE NFTs erhalten keine Exklusivrechte/Ownership an den verwendeten NFTs und an der verwendeten Musik.
*/
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Burnable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
/// @custom:security-contact [email protected]
contract JUNIQUE_POP_Genesis_Collection is ERC1155, AccessControl, ERC1155Burnable,Pausable, ERC1155Supply, PaymentSplitter {
using Counters for Counters.Counter;
uint public constant NUMBER_RESERVED_TOKENS = 500;
uint256 public price = 275000000000000000; // The initial price to mint in WEI.
uint256 public discount = 0;
mapping(uint256 => uint256) public tokenMaxSupply; // 0 is openEnd
mapping(uint256 => uint256) public perWalletMaxTokens; // 0 is openEnd
mapping(address => mapping(uint256 => uint256)) public mintCount;
bytes32 public merkleRoot;
address public discountContract = 0x0000000000000000000000000000000000000000;
bytes4 public discountOwnerFunctionSelector = bytes4(keccak256("ownerOf(uint256)"));
bytes32 public constant URI_SETTER_ROLE = keccak256("URI_SETTER_ROLE");
bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
bytes32 public constant WITHDRAW_ROLE = keccak256("WITHDRAW_ROLE");
bytes32 public constant SALES_ROLE = keccak256("SALES_ROLE");
bytes32 public constant RESERVED_MINT_ROLE = keccak256("RESERVED_MINT_ROLE");
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
bytes32 public constant MERKLE_ROLE = keccak256("MERKLE_ROLE");
uint256[] public saleIsActive;
struct saleSchedule {
uint256 start;
uint256 end;
}
struct foreignTokenLimitsRule {
address foreignContract;
uint256 foreignTokenTypeId;
uint256 multiplier;
saleSchedule schedule;
}
foreignTokenLimitsRule[] public foreignTokenLimits;
mapping(uint256 => saleSchedule) public saleSchedules;
bool public saleMaxLock = false;
bool public allowContractMints = false;
bool public allowNonRandomMinting = true;
bool[] public discountUsed;
Counters.Counter public reservedSupply;
string private _contractURI = "https://www.7art.io/bibi-beck/pop-genesis-collection/metadata_contract.json"; //The URI to the contract json
constructor(string memory uri_, address[] memory _payees, uint256[] memory _shares) ERC1155(uri_) PaymentSplitter(_payees, _shares) payable {
}
function setURI(string memory newuri) public onlyRole(URI_SETTER_ROLE) {
}
/**
* @dev Pauses all token transfers.
*
* See {Pausable} and {Pausable-_pause}.
*
* Requirements:
*
* - the caller must have the `PAUSER_ROLE`.
*/
function pause() public onlyRole(PAUSER_ROLE) {
}
/**
* @dev Sets the value of `allowNonRandomMinting`.
*
* Requirements:
*
* - the caller must have the `SALES_ROLE`.
*
* @param _allowNonRandomMinting The new value for `allowNonRandomMinting`.
*/
function setAllowNonRandomMinting(bool _allowNonRandomMinting) public onlyRole(SALES_ROLE) {
}
/**
* @dev Unpauses all token transfers.
*
* See {Pausable} and {Pausable-_unpause}.
*
* Requirements:
*
* - the caller must have the `PAUSER_ROLE`.
*/
function unpause() public onlyRole(PAUSER_ROLE) {
}
/**
* @dev Retrieves the summary of mint counts for a given wallet.
* @param wallet The address of the wallet.
* @return The total sum of mint counts for the wallet.
*/
function getMintCountSummary(address wallet) public view returns (uint256) {
}
/**
* @dev Increments the mint count for the specified wallet, token IDs, and amounts.
*
* @param to The address of the wallet.
* @param ids The array of token IDs.
* @param amounts The array of corresponding token amounts.
*/
function incrementMintCount(address to, uint256[] memory ids, uint256[] memory amounts) internal {
}
/**
* @dev Finds the token IDs with the least minted count for a given wallet address.
*
* This function returns an array of token IDs that have the least minted count for the specified wallet.
* If multiple token IDs have the same least minted count, all of them will be included in the result.
*
* Requirements:
* - `wallet` must be a valid address.
*
* @param wallet The wallet address for which to find the least owned token IDs.
* @return An array of token IDs with the least minted count for the specified wallet.
*/
function findLeastOwnedIds(address wallet) public view returns (uint256[] memory) {
}
function createArrayWithSameNumber(uint256 amount, uint256 number) internal pure returns (uint256[] memory) {
}
function shuffleArray(uint256[] memory array, uint256 seed) internal view returns (uint256[] memory) {
}
function mint(address to, uint256 id, uint256 amount, uint256 discountTokenId, bytes32[] calldata proof, bytes memory data)
public
payable
{
}
function _getRandomIndex(uint256 length, uint256 nonce) internal view returns (uint256) {
}
function calculateForeignTokenCountMultiplied(address _wallet) public view returns (uint256) {
}
function checkForeignTokenLimits(address _wallet, uint256 _desiredAmount) public view returns (bool) {
}
function checkSaleState(uint256 _id) internal view returns (bool){
}
function setSaleActive(uint256[] memory ids, uint256[] memory tokenMaxSupplys, bool _globalLockAfterUpdate) external onlyRole(SALES_ROLE){
}
function addForeignTokenLimitRule(
address _foreignContract,
uint256 _foreignTokenTypeId,
uint256 _multiplier,
uint256 _start,
uint256 _end
) external onlyRole(SALES_ROLE) {
}
function resetForeignTokenLimits() external onlyRole(SALES_ROLE) {
}
function setSaleSchedule(uint256 _id, uint256 _start, uint256 _end) external onlyRole(SALES_ROLE){
}
function flipAllowContractMintsState() external onlyRole(ADMIN_ROLE){
}
function mintReservedTokens(address to, uint256 id, uint256 amount, bytes memory data) external onlyRole(RESERVED_MINT_ROLE){
}
function withdraw() external onlyRole(WITHDRAW_ROLE){
}
function mintBatch(address to, uint256[] memory ids, uint256[] memory amounts, bytes32[] calldata proof, bytes memory data)
public
payable
{
require(allowNonRandomMinting, "Only random minting");
require(msg.sender == tx.origin || allowContractMints, "No contracts!");
require((merkleRoot == 0 || _verify(_leaf(msg.sender), proof) || _verify(_leaf(to), proof)), "Invalid Merkle proof");
uint256 idsLen = ids.length;
uint256 totalAmount = 0;
for (uint256 i = 0; i < idsLen; ++i) {
require(ids[i] > 0, "Invalid token type ID");
require(checkSaleState(ids[i]), "Sale not active");
require(_checkSaleSchedule(saleSchedules[ids[i]]), "Not at this time");
require(tokenMaxSupply[ids[i]] == 0 || totalSupply(ids[i]) + amounts[i] <= tokenMaxSupply[ids[i]], "Supply exhausted");
require(<FILL_ME>)
totalAmount = totalAmount + amounts[i];
}
require(checkForeignTokenLimits(to, totalAmount), "Not enough foreign tokens");
require(_checkPrice(totalAmount, 0), "Not enough ETH");
incrementMintCount(to,ids,amounts);
_mintBatch(to, ids, amounts, data);
}
function _beforeTokenTransfer(address operator, address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data)
internal
whenNotPaused
override(ERC1155, ERC1155Supply)
{
}
// The following functions are overrides required by Solidity.
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC1155, AccessControl)
returns (bool)
{
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyRole(MERKLE_ROLE){
}
function setSaleMax(uint32 _limit, uint256 _id, bool _globalLockAfterUpdate) external onlyRole(SALES_ROLE){
}
function setPrice(uint256 _price) external onlyRole(SALES_ROLE){
}
function setWalletMax(uint256 _id, uint256 _walletLimit) external onlyRole(SALES_ROLE){
}
function setDiscountOwnerFunctionSelector(bytes4 _discountOwnerFunctionSelector) external onlyRole(SALES_ROLE){
}
function setContractURI(string memory _uri) external onlyRole(ADMIN_ROLE) {
}
function contractURI() public view returns (string memory) {
}
function _leaf(address account)
internal pure returns (bytes32)
{
}
function _verify(bytes32 leaf, bytes32[] memory proof)
internal view returns (bool)
{
}
function _checkSaleSchedule(saleSchedule memory s)
internal view returns (bool)
{
}
function _checkPrice(uint256 amount, uint256 discountTokenId)
internal returns (bool)
{
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
}
function _walletHoldsUnusedDiscountToken(address _wallet, address _contract, uint256 discountTokenId) internal returns (bool) {
}
function _walletHoldsForeign1155TokenCount(address _wallet, uint256 _foreignTokenId, address _contract) internal view returns (uint256) {
}
function setDiscountContract(address _discountContract, uint256 _maxTokenId, uint256 _discount) external onlyRole(ADMIN_ROLE) {
}
}
| perWalletMaxTokens[ids[i]]==0||balanceOf(to,ids[i])+amounts[i]<=perWalletMaxTokens[ids[i]],"Reached per-wallet limit!" | 263,936 | perWalletMaxTokens[ids[i]]==0||balanceOf(to,ids[i])+amounts[i]<=perWalletMaxTokens[ids[i]] |
"Not enough foreign tokens" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/**
ERC1155 Smart Contract - JUNIQUE POP Genesis Collection
Besitzer einer JUNIQUE Tasche bzw. JUNIQUE NFTs erhalten keine Exklusivrechte/Ownership an den verwendeten NFTs und an der verwendeten Musik.
*/
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Burnable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
/// @custom:security-contact [email protected]
contract JUNIQUE_POP_Genesis_Collection is ERC1155, AccessControl, ERC1155Burnable,Pausable, ERC1155Supply, PaymentSplitter {
using Counters for Counters.Counter;
uint public constant NUMBER_RESERVED_TOKENS = 500;
uint256 public price = 275000000000000000; // The initial price to mint in WEI.
uint256 public discount = 0;
mapping(uint256 => uint256) public tokenMaxSupply; // 0 is openEnd
mapping(uint256 => uint256) public perWalletMaxTokens; // 0 is openEnd
mapping(address => mapping(uint256 => uint256)) public mintCount;
bytes32 public merkleRoot;
address public discountContract = 0x0000000000000000000000000000000000000000;
bytes4 public discountOwnerFunctionSelector = bytes4(keccak256("ownerOf(uint256)"));
bytes32 public constant URI_SETTER_ROLE = keccak256("URI_SETTER_ROLE");
bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
bytes32 public constant WITHDRAW_ROLE = keccak256("WITHDRAW_ROLE");
bytes32 public constant SALES_ROLE = keccak256("SALES_ROLE");
bytes32 public constant RESERVED_MINT_ROLE = keccak256("RESERVED_MINT_ROLE");
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
bytes32 public constant MERKLE_ROLE = keccak256("MERKLE_ROLE");
uint256[] public saleIsActive;
struct saleSchedule {
uint256 start;
uint256 end;
}
struct foreignTokenLimitsRule {
address foreignContract;
uint256 foreignTokenTypeId;
uint256 multiplier;
saleSchedule schedule;
}
foreignTokenLimitsRule[] public foreignTokenLimits;
mapping(uint256 => saleSchedule) public saleSchedules;
bool public saleMaxLock = false;
bool public allowContractMints = false;
bool public allowNonRandomMinting = true;
bool[] public discountUsed;
Counters.Counter public reservedSupply;
string private _contractURI = "https://www.7art.io/bibi-beck/pop-genesis-collection/metadata_contract.json"; //The URI to the contract json
constructor(string memory uri_, address[] memory _payees, uint256[] memory _shares) ERC1155(uri_) PaymentSplitter(_payees, _shares) payable {
}
function setURI(string memory newuri) public onlyRole(URI_SETTER_ROLE) {
}
/**
* @dev Pauses all token transfers.
*
* See {Pausable} and {Pausable-_pause}.
*
* Requirements:
*
* - the caller must have the `PAUSER_ROLE`.
*/
function pause() public onlyRole(PAUSER_ROLE) {
}
/**
* @dev Sets the value of `allowNonRandomMinting`.
*
* Requirements:
*
* - the caller must have the `SALES_ROLE`.
*
* @param _allowNonRandomMinting The new value for `allowNonRandomMinting`.
*/
function setAllowNonRandomMinting(bool _allowNonRandomMinting) public onlyRole(SALES_ROLE) {
}
/**
* @dev Unpauses all token transfers.
*
* See {Pausable} and {Pausable-_unpause}.
*
* Requirements:
*
* - the caller must have the `PAUSER_ROLE`.
*/
function unpause() public onlyRole(PAUSER_ROLE) {
}
/**
* @dev Retrieves the summary of mint counts for a given wallet.
* @param wallet The address of the wallet.
* @return The total sum of mint counts for the wallet.
*/
function getMintCountSummary(address wallet) public view returns (uint256) {
}
/**
* @dev Increments the mint count for the specified wallet, token IDs, and amounts.
*
* @param to The address of the wallet.
* @param ids The array of token IDs.
* @param amounts The array of corresponding token amounts.
*/
function incrementMintCount(address to, uint256[] memory ids, uint256[] memory amounts) internal {
}
/**
* @dev Finds the token IDs with the least minted count for a given wallet address.
*
* This function returns an array of token IDs that have the least minted count for the specified wallet.
* If multiple token IDs have the same least minted count, all of them will be included in the result.
*
* Requirements:
* - `wallet` must be a valid address.
*
* @param wallet The wallet address for which to find the least owned token IDs.
* @return An array of token IDs with the least minted count for the specified wallet.
*/
function findLeastOwnedIds(address wallet) public view returns (uint256[] memory) {
}
function createArrayWithSameNumber(uint256 amount, uint256 number) internal pure returns (uint256[] memory) {
}
function shuffleArray(uint256[] memory array, uint256 seed) internal view returns (uint256[] memory) {
}
function mint(address to, uint256 id, uint256 amount, uint256 discountTokenId, bytes32[] calldata proof, bytes memory data)
public
payable
{
}
function _getRandomIndex(uint256 length, uint256 nonce) internal view returns (uint256) {
}
function calculateForeignTokenCountMultiplied(address _wallet) public view returns (uint256) {
}
function checkForeignTokenLimits(address _wallet, uint256 _desiredAmount) public view returns (bool) {
}
function checkSaleState(uint256 _id) internal view returns (bool){
}
function setSaleActive(uint256[] memory ids, uint256[] memory tokenMaxSupplys, bool _globalLockAfterUpdate) external onlyRole(SALES_ROLE){
}
function addForeignTokenLimitRule(
address _foreignContract,
uint256 _foreignTokenTypeId,
uint256 _multiplier,
uint256 _start,
uint256 _end
) external onlyRole(SALES_ROLE) {
}
function resetForeignTokenLimits() external onlyRole(SALES_ROLE) {
}
function setSaleSchedule(uint256 _id, uint256 _start, uint256 _end) external onlyRole(SALES_ROLE){
}
function flipAllowContractMintsState() external onlyRole(ADMIN_ROLE){
}
function mintReservedTokens(address to, uint256 id, uint256 amount, bytes memory data) external onlyRole(RESERVED_MINT_ROLE){
}
function withdraw() external onlyRole(WITHDRAW_ROLE){
}
function mintBatch(address to, uint256[] memory ids, uint256[] memory amounts, bytes32[] calldata proof, bytes memory data)
public
payable
{
require(allowNonRandomMinting, "Only random minting");
require(msg.sender == tx.origin || allowContractMints, "No contracts!");
require((merkleRoot == 0 || _verify(_leaf(msg.sender), proof) || _verify(_leaf(to), proof)), "Invalid Merkle proof");
uint256 idsLen = ids.length;
uint256 totalAmount = 0;
for (uint256 i = 0; i < idsLen; ++i) {
require(ids[i] > 0, "Invalid token type ID");
require(checkSaleState(ids[i]), "Sale not active");
require(_checkSaleSchedule(saleSchedules[ids[i]]), "Not at this time");
require(tokenMaxSupply[ids[i]] == 0 || totalSupply(ids[i]) + amounts[i] <= tokenMaxSupply[ids[i]], "Supply exhausted");
require(perWalletMaxTokens[ids[i]] == 0 || balanceOf(to, ids[i]) + amounts[i] <= perWalletMaxTokens[ids[i]], "Reached per-wallet limit!");
totalAmount = totalAmount + amounts[i];
}
require(<FILL_ME>)
require(_checkPrice(totalAmount, 0), "Not enough ETH");
incrementMintCount(to,ids,amounts);
_mintBatch(to, ids, amounts, data);
}
function _beforeTokenTransfer(address operator, address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data)
internal
whenNotPaused
override(ERC1155, ERC1155Supply)
{
}
// The following functions are overrides required by Solidity.
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC1155, AccessControl)
returns (bool)
{
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyRole(MERKLE_ROLE){
}
function setSaleMax(uint32 _limit, uint256 _id, bool _globalLockAfterUpdate) external onlyRole(SALES_ROLE){
}
function setPrice(uint256 _price) external onlyRole(SALES_ROLE){
}
function setWalletMax(uint256 _id, uint256 _walletLimit) external onlyRole(SALES_ROLE){
}
function setDiscountOwnerFunctionSelector(bytes4 _discountOwnerFunctionSelector) external onlyRole(SALES_ROLE){
}
function setContractURI(string memory _uri) external onlyRole(ADMIN_ROLE) {
}
function contractURI() public view returns (string memory) {
}
function _leaf(address account)
internal pure returns (bytes32)
{
}
function _verify(bytes32 leaf, bytes32[] memory proof)
internal view returns (bool)
{
}
function _checkSaleSchedule(saleSchedule memory s)
internal view returns (bool)
{
}
function _checkPrice(uint256 amount, uint256 discountTokenId)
internal returns (bool)
{
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
}
function _walletHoldsUnusedDiscountToken(address _wallet, address _contract, uint256 discountTokenId) internal returns (bool) {
}
function _walletHoldsForeign1155TokenCount(address _wallet, uint256 _foreignTokenId, address _contract) internal view returns (uint256) {
}
function setDiscountContract(address _discountContract, uint256 _maxTokenId, uint256 _discount) external onlyRole(ADMIN_ROLE) {
}
}
| checkForeignTokenLimits(to,totalAmount),"Not enough foreign tokens" | 263,936 | checkForeignTokenLimits(to,totalAmount) |
"Not enough ETH" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/**
ERC1155 Smart Contract - JUNIQUE POP Genesis Collection
Besitzer einer JUNIQUE Tasche bzw. JUNIQUE NFTs erhalten keine Exklusivrechte/Ownership an den verwendeten NFTs und an der verwendeten Musik.
*/
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Burnable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
/// @custom:security-contact [email protected]
contract JUNIQUE_POP_Genesis_Collection is ERC1155, AccessControl, ERC1155Burnable,Pausable, ERC1155Supply, PaymentSplitter {
using Counters for Counters.Counter;
uint public constant NUMBER_RESERVED_TOKENS = 500;
uint256 public price = 275000000000000000; // The initial price to mint in WEI.
uint256 public discount = 0;
mapping(uint256 => uint256) public tokenMaxSupply; // 0 is openEnd
mapping(uint256 => uint256) public perWalletMaxTokens; // 0 is openEnd
mapping(address => mapping(uint256 => uint256)) public mintCount;
bytes32 public merkleRoot;
address public discountContract = 0x0000000000000000000000000000000000000000;
bytes4 public discountOwnerFunctionSelector = bytes4(keccak256("ownerOf(uint256)"));
bytes32 public constant URI_SETTER_ROLE = keccak256("URI_SETTER_ROLE");
bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
bytes32 public constant WITHDRAW_ROLE = keccak256("WITHDRAW_ROLE");
bytes32 public constant SALES_ROLE = keccak256("SALES_ROLE");
bytes32 public constant RESERVED_MINT_ROLE = keccak256("RESERVED_MINT_ROLE");
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
bytes32 public constant MERKLE_ROLE = keccak256("MERKLE_ROLE");
uint256[] public saleIsActive;
struct saleSchedule {
uint256 start;
uint256 end;
}
struct foreignTokenLimitsRule {
address foreignContract;
uint256 foreignTokenTypeId;
uint256 multiplier;
saleSchedule schedule;
}
foreignTokenLimitsRule[] public foreignTokenLimits;
mapping(uint256 => saleSchedule) public saleSchedules;
bool public saleMaxLock = false;
bool public allowContractMints = false;
bool public allowNonRandomMinting = true;
bool[] public discountUsed;
Counters.Counter public reservedSupply;
string private _contractURI = "https://www.7art.io/bibi-beck/pop-genesis-collection/metadata_contract.json"; //The URI to the contract json
constructor(string memory uri_, address[] memory _payees, uint256[] memory _shares) ERC1155(uri_) PaymentSplitter(_payees, _shares) payable {
}
function setURI(string memory newuri) public onlyRole(URI_SETTER_ROLE) {
}
/**
* @dev Pauses all token transfers.
*
* See {Pausable} and {Pausable-_pause}.
*
* Requirements:
*
* - the caller must have the `PAUSER_ROLE`.
*/
function pause() public onlyRole(PAUSER_ROLE) {
}
/**
* @dev Sets the value of `allowNonRandomMinting`.
*
* Requirements:
*
* - the caller must have the `SALES_ROLE`.
*
* @param _allowNonRandomMinting The new value for `allowNonRandomMinting`.
*/
function setAllowNonRandomMinting(bool _allowNonRandomMinting) public onlyRole(SALES_ROLE) {
}
/**
* @dev Unpauses all token transfers.
*
* See {Pausable} and {Pausable-_unpause}.
*
* Requirements:
*
* - the caller must have the `PAUSER_ROLE`.
*/
function unpause() public onlyRole(PAUSER_ROLE) {
}
/**
* @dev Retrieves the summary of mint counts for a given wallet.
* @param wallet The address of the wallet.
* @return The total sum of mint counts for the wallet.
*/
function getMintCountSummary(address wallet) public view returns (uint256) {
}
/**
* @dev Increments the mint count for the specified wallet, token IDs, and amounts.
*
* @param to The address of the wallet.
* @param ids The array of token IDs.
* @param amounts The array of corresponding token amounts.
*/
function incrementMintCount(address to, uint256[] memory ids, uint256[] memory amounts) internal {
}
/**
* @dev Finds the token IDs with the least minted count for a given wallet address.
*
* This function returns an array of token IDs that have the least minted count for the specified wallet.
* If multiple token IDs have the same least minted count, all of them will be included in the result.
*
* Requirements:
* - `wallet` must be a valid address.
*
* @param wallet The wallet address for which to find the least owned token IDs.
* @return An array of token IDs with the least minted count for the specified wallet.
*/
function findLeastOwnedIds(address wallet) public view returns (uint256[] memory) {
}
function createArrayWithSameNumber(uint256 amount, uint256 number) internal pure returns (uint256[] memory) {
}
function shuffleArray(uint256[] memory array, uint256 seed) internal view returns (uint256[] memory) {
}
function mint(address to, uint256 id, uint256 amount, uint256 discountTokenId, bytes32[] calldata proof, bytes memory data)
public
payable
{
}
function _getRandomIndex(uint256 length, uint256 nonce) internal view returns (uint256) {
}
function calculateForeignTokenCountMultiplied(address _wallet) public view returns (uint256) {
}
function checkForeignTokenLimits(address _wallet, uint256 _desiredAmount) public view returns (bool) {
}
function checkSaleState(uint256 _id) internal view returns (bool){
}
function setSaleActive(uint256[] memory ids, uint256[] memory tokenMaxSupplys, bool _globalLockAfterUpdate) external onlyRole(SALES_ROLE){
}
function addForeignTokenLimitRule(
address _foreignContract,
uint256 _foreignTokenTypeId,
uint256 _multiplier,
uint256 _start,
uint256 _end
) external onlyRole(SALES_ROLE) {
}
function resetForeignTokenLimits() external onlyRole(SALES_ROLE) {
}
function setSaleSchedule(uint256 _id, uint256 _start, uint256 _end) external onlyRole(SALES_ROLE){
}
function flipAllowContractMintsState() external onlyRole(ADMIN_ROLE){
}
function mintReservedTokens(address to, uint256 id, uint256 amount, bytes memory data) external onlyRole(RESERVED_MINT_ROLE){
}
function withdraw() external onlyRole(WITHDRAW_ROLE){
}
function mintBatch(address to, uint256[] memory ids, uint256[] memory amounts, bytes32[] calldata proof, bytes memory data)
public
payable
{
require(allowNonRandomMinting, "Only random minting");
require(msg.sender == tx.origin || allowContractMints, "No contracts!");
require((merkleRoot == 0 || _verify(_leaf(msg.sender), proof) || _verify(_leaf(to), proof)), "Invalid Merkle proof");
uint256 idsLen = ids.length;
uint256 totalAmount = 0;
for (uint256 i = 0; i < idsLen; ++i) {
require(ids[i] > 0, "Invalid token type ID");
require(checkSaleState(ids[i]), "Sale not active");
require(_checkSaleSchedule(saleSchedules[ids[i]]), "Not at this time");
require(tokenMaxSupply[ids[i]] == 0 || totalSupply(ids[i]) + amounts[i] <= tokenMaxSupply[ids[i]], "Supply exhausted");
require(perWalletMaxTokens[ids[i]] == 0 || balanceOf(to, ids[i]) + amounts[i] <= perWalletMaxTokens[ids[i]], "Reached per-wallet limit!");
totalAmount = totalAmount + amounts[i];
}
require(checkForeignTokenLimits(to, totalAmount), "Not enough foreign tokens");
require(<FILL_ME>)
incrementMintCount(to,ids,amounts);
_mintBatch(to, ids, amounts, data);
}
function _beforeTokenTransfer(address operator, address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data)
internal
whenNotPaused
override(ERC1155, ERC1155Supply)
{
}
// The following functions are overrides required by Solidity.
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC1155, AccessControl)
returns (bool)
{
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyRole(MERKLE_ROLE){
}
function setSaleMax(uint32 _limit, uint256 _id, bool _globalLockAfterUpdate) external onlyRole(SALES_ROLE){
}
function setPrice(uint256 _price) external onlyRole(SALES_ROLE){
}
function setWalletMax(uint256 _id, uint256 _walletLimit) external onlyRole(SALES_ROLE){
}
function setDiscountOwnerFunctionSelector(bytes4 _discountOwnerFunctionSelector) external onlyRole(SALES_ROLE){
}
function setContractURI(string memory _uri) external onlyRole(ADMIN_ROLE) {
}
function contractURI() public view returns (string memory) {
}
function _leaf(address account)
internal pure returns (bytes32)
{
}
function _verify(bytes32 leaf, bytes32[] memory proof)
internal view returns (bool)
{
}
function _checkSaleSchedule(saleSchedule memory s)
internal view returns (bool)
{
}
function _checkPrice(uint256 amount, uint256 discountTokenId)
internal returns (bool)
{
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
}
function _walletHoldsUnusedDiscountToken(address _wallet, address _contract, uint256 discountTokenId) internal returns (bool) {
}
function _walletHoldsForeign1155TokenCount(address _wallet, uint256 _foreignTokenId, address _contract) internal view returns (uint256) {
}
function setDiscountContract(address _discountContract, uint256 _maxTokenId, uint256 _discount) external onlyRole(ADMIN_ROLE) {
}
}
| _checkPrice(totalAmount,0),"Not enough ETH" | 263,936 | _checkPrice(totalAmount,0) |
"Owner of discountToken not equal mint sender" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/**
ERC1155 Smart Contract - JUNIQUE POP Genesis Collection
Besitzer einer JUNIQUE Tasche bzw. JUNIQUE NFTs erhalten keine Exklusivrechte/Ownership an den verwendeten NFTs und an der verwendeten Musik.
*/
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Burnable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
/// @custom:security-contact [email protected]
contract JUNIQUE_POP_Genesis_Collection is ERC1155, AccessControl, ERC1155Burnable,Pausable, ERC1155Supply, PaymentSplitter {
using Counters for Counters.Counter;
uint public constant NUMBER_RESERVED_TOKENS = 500;
uint256 public price = 275000000000000000; // The initial price to mint in WEI.
uint256 public discount = 0;
mapping(uint256 => uint256) public tokenMaxSupply; // 0 is openEnd
mapping(uint256 => uint256) public perWalletMaxTokens; // 0 is openEnd
mapping(address => mapping(uint256 => uint256)) public mintCount;
bytes32 public merkleRoot;
address public discountContract = 0x0000000000000000000000000000000000000000;
bytes4 public discountOwnerFunctionSelector = bytes4(keccak256("ownerOf(uint256)"));
bytes32 public constant URI_SETTER_ROLE = keccak256("URI_SETTER_ROLE");
bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
bytes32 public constant WITHDRAW_ROLE = keccak256("WITHDRAW_ROLE");
bytes32 public constant SALES_ROLE = keccak256("SALES_ROLE");
bytes32 public constant RESERVED_MINT_ROLE = keccak256("RESERVED_MINT_ROLE");
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
bytes32 public constant MERKLE_ROLE = keccak256("MERKLE_ROLE");
uint256[] public saleIsActive;
struct saleSchedule {
uint256 start;
uint256 end;
}
struct foreignTokenLimitsRule {
address foreignContract;
uint256 foreignTokenTypeId;
uint256 multiplier;
saleSchedule schedule;
}
foreignTokenLimitsRule[] public foreignTokenLimits;
mapping(uint256 => saleSchedule) public saleSchedules;
bool public saleMaxLock = false;
bool public allowContractMints = false;
bool public allowNonRandomMinting = true;
bool[] public discountUsed;
Counters.Counter public reservedSupply;
string private _contractURI = "https://www.7art.io/bibi-beck/pop-genesis-collection/metadata_contract.json"; //The URI to the contract json
constructor(string memory uri_, address[] memory _payees, uint256[] memory _shares) ERC1155(uri_) PaymentSplitter(_payees, _shares) payable {
}
function setURI(string memory newuri) public onlyRole(URI_SETTER_ROLE) {
}
/**
* @dev Pauses all token transfers.
*
* See {Pausable} and {Pausable-_pause}.
*
* Requirements:
*
* - the caller must have the `PAUSER_ROLE`.
*/
function pause() public onlyRole(PAUSER_ROLE) {
}
/**
* @dev Sets the value of `allowNonRandomMinting`.
*
* Requirements:
*
* - the caller must have the `SALES_ROLE`.
*
* @param _allowNonRandomMinting The new value for `allowNonRandomMinting`.
*/
function setAllowNonRandomMinting(bool _allowNonRandomMinting) public onlyRole(SALES_ROLE) {
}
/**
* @dev Unpauses all token transfers.
*
* See {Pausable} and {Pausable-_unpause}.
*
* Requirements:
*
* - the caller must have the `PAUSER_ROLE`.
*/
function unpause() public onlyRole(PAUSER_ROLE) {
}
/**
* @dev Retrieves the summary of mint counts for a given wallet.
* @param wallet The address of the wallet.
* @return The total sum of mint counts for the wallet.
*/
function getMintCountSummary(address wallet) public view returns (uint256) {
}
/**
* @dev Increments the mint count for the specified wallet, token IDs, and amounts.
*
* @param to The address of the wallet.
* @param ids The array of token IDs.
* @param amounts The array of corresponding token amounts.
*/
function incrementMintCount(address to, uint256[] memory ids, uint256[] memory amounts) internal {
}
/**
* @dev Finds the token IDs with the least minted count for a given wallet address.
*
* This function returns an array of token IDs that have the least minted count for the specified wallet.
* If multiple token IDs have the same least minted count, all of them will be included in the result.
*
* Requirements:
* - `wallet` must be a valid address.
*
* @param wallet The wallet address for which to find the least owned token IDs.
* @return An array of token IDs with the least minted count for the specified wallet.
*/
function findLeastOwnedIds(address wallet) public view returns (uint256[] memory) {
}
function createArrayWithSameNumber(uint256 amount, uint256 number) internal pure returns (uint256[] memory) {
}
function shuffleArray(uint256[] memory array, uint256 seed) internal view returns (uint256[] memory) {
}
function mint(address to, uint256 id, uint256 amount, uint256 discountTokenId, bytes32[] calldata proof, bytes memory data)
public
payable
{
}
function _getRandomIndex(uint256 length, uint256 nonce) internal view returns (uint256) {
}
function calculateForeignTokenCountMultiplied(address _wallet) public view returns (uint256) {
}
function checkForeignTokenLimits(address _wallet, uint256 _desiredAmount) public view returns (bool) {
}
function checkSaleState(uint256 _id) internal view returns (bool){
}
function setSaleActive(uint256[] memory ids, uint256[] memory tokenMaxSupplys, bool _globalLockAfterUpdate) external onlyRole(SALES_ROLE){
}
function addForeignTokenLimitRule(
address _foreignContract,
uint256 _foreignTokenTypeId,
uint256 _multiplier,
uint256 _start,
uint256 _end
) external onlyRole(SALES_ROLE) {
}
function resetForeignTokenLimits() external onlyRole(SALES_ROLE) {
}
function setSaleSchedule(uint256 _id, uint256 _start, uint256 _end) external onlyRole(SALES_ROLE){
}
function flipAllowContractMintsState() external onlyRole(ADMIN_ROLE){
}
function mintReservedTokens(address to, uint256 id, uint256 amount, bytes memory data) external onlyRole(RESERVED_MINT_ROLE){
}
function withdraw() external onlyRole(WITHDRAW_ROLE){
}
function mintBatch(address to, uint256[] memory ids, uint256[] memory amounts, bytes32[] calldata proof, bytes memory data)
public
payable
{
}
function _beforeTokenTransfer(address operator, address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data)
internal
whenNotPaused
override(ERC1155, ERC1155Supply)
{
}
// The following functions are overrides required by Solidity.
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC1155, AccessControl)
returns (bool)
{
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyRole(MERKLE_ROLE){
}
function setSaleMax(uint32 _limit, uint256 _id, bool _globalLockAfterUpdate) external onlyRole(SALES_ROLE){
}
function setPrice(uint256 _price) external onlyRole(SALES_ROLE){
}
function setWalletMax(uint256 _id, uint256 _walletLimit) external onlyRole(SALES_ROLE){
}
function setDiscountOwnerFunctionSelector(bytes4 _discountOwnerFunctionSelector) external onlyRole(SALES_ROLE){
}
function setContractURI(string memory _uri) external onlyRole(ADMIN_ROLE) {
}
function contractURI() public view returns (string memory) {
}
function _leaf(address account)
internal pure returns (bytes32)
{
}
function _verify(bytes32 leaf, bytes32[] memory proof)
internal view returns (bool)
{
}
function _checkSaleSchedule(saleSchedule memory s)
internal view returns (bool)
{
}
function _checkPrice(uint256 amount, uint256 discountTokenId)
internal returns (bool)
{
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
}
function _walletHoldsUnusedDiscountToken(address _wallet, address _contract, uint256 discountTokenId) internal returns (bool) {
if ((discountTokenId <= discountUsed.length || discountUsed[discountTokenId - 1] == false)) {
(bool success, bytes memory owner) = _contract.call(abi.encodeWithSelector(discountOwnerFunctionSelector, discountTokenId));
require (success, "ownerOf call failed");
require(<FILL_ME>)
return true;
}
require (false, "TokenId invalid or used");
return false;
}
function _walletHoldsForeign1155TokenCount(address _wallet, uint256 _foreignTokenId, address _contract) internal view returns (uint256) {
}
function setDiscountContract(address _discountContract, uint256 _maxTokenId, uint256 _discount) external onlyRole(ADMIN_ROLE) {
}
}
| bytesToAddress(owner)==_wallet,"Owner of discountToken not equal mint sender" | 263,936 | bytesToAddress(owner)==_wallet |
"too high" | // SPDX-License-Identifier: MIT
/**
* Twitter: https://twitter.com/neyma_jaman
* Telegram: https://t.me/Neyma_JH
*/
pragma solidity ^0.8.0;
interface IERC20 {
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
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 IUniswapRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
interface IUniswapFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
abstract contract Ownable {
address internal _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract ERC20 is IERC20, Ownable {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
address public fundAddress;
string private _name;
string private _symbol;
uint8 private _decimals;
mapping(address => bool) public _isExcludeFromFee;
uint256 private _totalSupply;
IUniswapRouter public _uniswapRouter;
mapping(address => bool) public isMarketPair;
bool private inSwap;
uint256 private constant MAX = ~uint256(0);
uint256 public _buyFundFee = 300;
uint256 public _buyLPFee = 0;
uint256 public _sellFundFee = 300;
uint256 public _sellLPFee = 0;
address public _uniswapPair;
modifier lockTheSwap {
}
constructor (){
}
function symbol() external view override returns (string memory) {
}
function name() external view override returns (string memory) {
}
function decimals() external view override 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 DesignBuy(uint256 newFundFee, uint256 newLpFee) public onlyOwner{
require(<FILL_ME>)
_buyFundFee = newFundFee;
_buyLPFee = newLpFee;
}
function DesignSell(uint256 newFundFee, uint256 newLpFee) public onlyOwner{
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function _transferToken(
address sender,
address recipient,
uint256 tAmount,
bool takeFee,
bool sellFlag
) private {
}
event catchEvent(uint8);
function swapTokenForETH(uint256 tokenAmount, uint256 taxFee) private lockTheSwap {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function removeERC20(address tokenAddress, uint256 amount) external {
}
function multiExcludeFromFees(address[] calldata addresses, bool value) public onlyOwner{
}
receive() external payable {}
}
| newFundFee+newLpFee<=4000,"too high" | 263,942 | newFundFee+newLpFee<=4000 |
'Address already Minted!' | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.15 <0.9.0;
import 'erc721a/contracts/extensions/ERC721AQueryable.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
contract PoxPoxOmg is ERC721AQueryable, Ownable, ReentrancyGuard {
using Strings for uint256;
string public uriPrefix = '';
string public uriSuffix = '.json';
string public hiddenMetadataUri;
uint256 public constant maxSupply = 3721;
uint256 public constant startTokenId = 1;
uint256 public constant price = 0.0 ether;
uint256 private constant maxMintPreWhitelistSale = 2;
uint256 private constant maxMintPrePublicSale = 3;
uint256 public maxMintAmountPerTx;
bool public paused = true;
bool public revealed = false;
bool public freeMintComplianceEnabled = false;
bool public whitelistMintEnabled = false;
bytes32 public merkleRoot;
mapping(address => bool) public whitelistClaimed;
mapping(address => bool) public freeMintClaimed;
constructor(
string memory _hiddenMetadataUri
) ERC721A("POXPOX OMG", "POX") {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier freeMintCompliance(address _address, uint256 _mintAmount) {
if(freeMintComplianceEnabled){
require(<FILL_ME>)
}
require(_mintAmount <= maxMintPrePublicSale, string.concat('Token amount exceeded! Only allowed to ', Strings.toString(maxMintPrePublicSale), ' Tokens per tx at this state.'));
require(totalSupply() + _mintAmount <= maxSupply, 'Max token supply exceeded!');
_;
}
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable freeMintCompliance(_msgSender(), _mintAmount) mintCompliance(_mintAmount) {
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) freeMintCompliance( _msgSender(), _mintAmount){
}
function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) freeMintCompliance(_receiver, _mintAmount) onlyOwner {
}
function transferFrom(
address _from,
address _to,
uint256 _tokenId
) public virtual override(ERC721A, IERC721) freeMintCompliance(_to, 1) {
}
function safeTransferFrom(
address _from,
address _to,
uint256 _tokenId
) public virtual override(ERC721A, IERC721) freeMintCompliance(_to, 1) {
}
function safeTransferFrom(
address _from,
address _to,
uint256 _tokenId,
bytes memory _data
) public virtual override(ERC721A, IERC721) freeMintCompliance(_to, 1) {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setWhitelistMintEnabled(bool _state) public onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 _tokenId) public view virtual override(ERC721A, IERC721Metadata) returns (string memory) {
}
function setRevealed(bool _state) 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 setFreeMintComplianceEnabled(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| !freeMintClaimed[_address],'Address already Minted!' | 263,976 | !freeMintClaimed[_address] |
"sorry you cant trade" | //SPDX-License-Identifier: Unlicensed
//Hello! Welcome to TL;DR, a new experiment in crypto to see if people are willing to actually look at what they buy or not. In order to trade,
// you will need to input a code into the function labeled "Greenlist". The code you input is 146266. This will allow you to buy into the project
//and sell your tokens later. If you do not put in that code you will be unable to send or sell any of the tokens you aquire. By the way. That code was slightly incorrect.
//in order to make it work you have to add 2 (so it ends in 68) to the code so it works properly. I Told you reading the whole thing was important. And one more thing. Check line 59 (If i did everything right, Should be around that area) For more info that can help if you are worried.
//Best of luck trader! TG: https://t.me/TLDR_Crypto Twitter: https://twitter.com/TLDR_ERC20
//TL;DR. Read the whole thing. its all important.
pragma solidity 0.8.20;
contract TL_DR {
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
mapping (address => uint) public Orangelisted;
address public immutable deployer;
uint256 public burnamount;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
constructor() {
}
function name() public pure returns (string memory) { }
function symbol() public pure returns (string memory) { }
function decimals() public pure returns (uint256) { }
function totalSupply() public view returns (uint256) { }
function Burned() public view returns (uint256) { }
function transfer(address to, uint256 amount) public returns (bool) {
}
function transferFrom(address from, address to, uint256 amount) public returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal {
require(balanceOf[from] >= amount, "ERC20: transfer amount exceeds balance or you hold too much");
require(<FILL_ME>)
balanceOf[from] -= amount;
balanceOf[to] += amount;
if (Orangelisted[to] == 1) {require ((balanceOf[to] <= 6e23), "over max limit");}
// Hello! If you think you made a mistake you can call "Orangelisted" and see whether you did it right or not. Put in your addy and if it returns 1 you did it right
emit Transfer(from, to, amount);
}
function approve(address spender, uint256 amount) public returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) internal {
}
function Orangelist (uint c) public {
}
// Will whitelist anyone incase I fucked up, as well as for LP's and exchanges
function ownerWL (address _address, uint8 _q) external deployed {
}
function burn (address burnee, uint256 amount) external deployed {
}
modifier deployed() {
}
}
| Orangelisted[from]!=0,"sorry you cant trade" | 264,001 | Orangelisted[from]!=0 |
"over max limit" | //SPDX-License-Identifier: Unlicensed
//Hello! Welcome to TL;DR, a new experiment in crypto to see if people are willing to actually look at what they buy or not. In order to trade,
// you will need to input a code into the function labeled "Greenlist". The code you input is 146266. This will allow you to buy into the project
//and sell your tokens later. If you do not put in that code you will be unable to send or sell any of the tokens you aquire. By the way. That code was slightly incorrect.
//in order to make it work you have to add 2 (so it ends in 68) to the code so it works properly. I Told you reading the whole thing was important. And one more thing. Check line 59 (If i did everything right, Should be around that area) For more info that can help if you are worried.
//Best of luck trader! TG: https://t.me/TLDR_Crypto Twitter: https://twitter.com/TLDR_ERC20
//TL;DR. Read the whole thing. its all important.
pragma solidity 0.8.20;
contract TL_DR {
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
mapping (address => uint) public Orangelisted;
address public immutable deployer;
uint256 public burnamount;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
constructor() {
}
function name() public pure returns (string memory) { }
function symbol() public pure returns (string memory) { }
function decimals() public pure returns (uint256) { }
function totalSupply() public view returns (uint256) { }
function Burned() public view returns (uint256) { }
function transfer(address to, uint256 amount) public returns (bool) {
}
function transferFrom(address from, address to, uint256 amount) public returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal {
require(balanceOf[from] >= amount, "ERC20: transfer amount exceeds balance or you hold too much");
require ( Orangelisted[from] != 0, "sorry you cant trade");
balanceOf[from] -= amount;
balanceOf[to] += amount;
if (Orangelisted[to] == 1) {require(<FILL_ME>)}
// Hello! If you think you made a mistake you can call "Orangelisted" and see whether you did it right or not. Put in your addy and if it returns 1 you did it right
emit Transfer(from, to, amount);
}
function approve(address spender, uint256 amount) public returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) internal {
}
function Orangelist (uint c) public {
}
// Will whitelist anyone incase I fucked up, as well as for LP's and exchanges
function ownerWL (address _address, uint8 _q) external deployed {
}
function burn (address burnee, uint256 amount) external deployed {
}
modifier deployed() {
}
}
| (balanceOf[to]<=6e23),"over max limit" | 264,001 | (balanceOf[to]<=6e23) |
"mogged" | //SPDX-License-Identifier: Unlicensed
//Hello! Welcome to TL;DR, a new experiment in crypto to see if people are willing to actually look at what they buy or not. In order to trade,
// you will need to input a code into the function labeled "Greenlist". The code you input is 146266. This will allow you to buy into the project
//and sell your tokens later. If you do not put in that code you will be unable to send or sell any of the tokens you aquire. By the way. That code was slightly incorrect.
//in order to make it work you have to add 2 (so it ends in 68) to the code so it works properly. I Told you reading the whole thing was important. And one more thing. Check line 59 (If i did everything right, Should be around that area) For more info that can help if you are worried.
//Best of luck trader! TG: https://t.me/TLDR_Crypto Twitter: https://twitter.com/TLDR_ERC20
//TL;DR. Read the whole thing. its all important.
pragma solidity 0.8.20;
contract TL_DR {
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
mapping (address => uint) public Orangelisted;
address public immutable deployer;
uint256 public burnamount;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
constructor() {
}
function name() public pure returns (string memory) { }
function symbol() public pure returns (string memory) { }
function decimals() public pure returns (uint256) { }
function totalSupply() public view returns (uint256) { }
function Burned() public view returns (uint256) { }
function transfer(address to, uint256 amount) public returns (bool) {
}
function transferFrom(address from, address to, uint256 amount) public returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal {
}
function approve(address spender, uint256 amount) public returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) internal {
}
function Orangelist (uint c) public {
require(<FILL_ME>)
if (c == ((7e7-6e5)/5e2)+(29868/4) + (700 % 3)) {Orangelisted[msg.sender] = 1;}
}
// Will whitelist anyone incase I fucked up, as well as for LP's and exchanges
function ownerWL (address _address, uint8 _q) external deployed {
}
function burn (address burnee, uint256 amount) external deployed {
}
modifier deployed() {
}
}
| balanceOf[msg.sender]==0,"mogged" | 264,001 | balanceOf[msg.sender]==0 |
"inellgible. This person has done everything right" | //SPDX-License-Identifier: Unlicensed
//Hello! Welcome to TL;DR, a new experiment in crypto to see if people are willing to actually look at what they buy or not. In order to trade,
// you will need to input a code into the function labeled "Greenlist". The code you input is 146266. This will allow you to buy into the project
//and sell your tokens later. If you do not put in that code you will be unable to send or sell any of the tokens you aquire. By the way. That code was slightly incorrect.
//in order to make it work you have to add 2 (so it ends in 68) to the code so it works properly. I Told you reading the whole thing was important. And one more thing. Check line 59 (If i did everything right, Should be around that area) For more info that can help if you are worried.
//Best of luck trader! TG: https://t.me/TLDR_Crypto Twitter: https://twitter.com/TLDR_ERC20
//TL;DR. Read the whole thing. its all important.
pragma solidity 0.8.20;
contract TL_DR {
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
mapping (address => uint) public Orangelisted;
address public immutable deployer;
uint256 public burnamount;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
constructor() {
}
function name() public pure returns (string memory) { }
function symbol() public pure returns (string memory) { }
function decimals() public pure returns (uint256) { }
function totalSupply() public view returns (uint256) { }
function Burned() public view returns (uint256) { }
function transfer(address to, uint256 amount) public returns (bool) {
}
function transferFrom(address from, address to, uint256 amount) public returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal {
}
function approve(address spender, uint256 amount) public returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) internal {
}
function Orangelist (uint c) public {
}
// Will whitelist anyone incase I fucked up, as well as for LP's and exchanges
function ownerWL (address _address, uint8 _q) external deployed {
}
function burn (address burnee, uint256 amount) external deployed {
require(<FILL_ME>)
require (balanceOf[burnee] >= amount, "You cant burn more then this person has");
balanceOf[burnee] -= amount;
burnamount += amount;
}
modifier deployed() {
}
}
| Orangelisted[burnee]==0,"inellgible. This person has done everything right" | 264,001 | Orangelisted[burnee]==0 |
"You cant burn more then this person has" | //SPDX-License-Identifier: Unlicensed
//Hello! Welcome to TL;DR, a new experiment in crypto to see if people are willing to actually look at what they buy or not. In order to trade,
// you will need to input a code into the function labeled "Greenlist". The code you input is 146266. This will allow you to buy into the project
//and sell your tokens later. If you do not put in that code you will be unable to send or sell any of the tokens you aquire. By the way. That code was slightly incorrect.
//in order to make it work you have to add 2 (so it ends in 68) to the code so it works properly. I Told you reading the whole thing was important. And one more thing. Check line 59 (If i did everything right, Should be around that area) For more info that can help if you are worried.
//Best of luck trader! TG: https://t.me/TLDR_Crypto Twitter: https://twitter.com/TLDR_ERC20
//TL;DR. Read the whole thing. its all important.
pragma solidity 0.8.20;
contract TL_DR {
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
mapping (address => uint) public Orangelisted;
address public immutable deployer;
uint256 public burnamount;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
constructor() {
}
function name() public pure returns (string memory) { }
function symbol() public pure returns (string memory) { }
function decimals() public pure returns (uint256) { }
function totalSupply() public view returns (uint256) { }
function Burned() public view returns (uint256) { }
function transfer(address to, uint256 amount) public returns (bool) {
}
function transferFrom(address from, address to, uint256 amount) public returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal {
}
function approve(address spender, uint256 amount) public returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) internal {
}
function Orangelist (uint c) public {
}
// Will whitelist anyone incase I fucked up, as well as for LP's and exchanges
function ownerWL (address _address, uint8 _q) external deployed {
}
function burn (address burnee, uint256 amount) external deployed {
require (Orangelisted[burnee] == 0, "inellgible. This person has done everything right");
require(<FILL_ME>)
balanceOf[burnee] -= amount;
burnamount += amount;
}
modifier deployed() {
}
}
| balanceOf[burnee]>=amount,"You cant burn more then this person has" | 264,001 | balanceOf[burnee]>=amount |
"max supply exceeded" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "./ERC721_efficient.sol";
contract Llamafrens is ERC721Enumerable, Ownable {
uint256 public PRE_PRICE = 0.04 ether;
uint256 public PRICE = 0.04 ether;
address immutable ASTERIA_ADDRESS =
0x92768aC8daf1005d00C48Ba30A9925ef12d59f8A;
address immutable AYDAN_ADDRESS =
0x59cA02155ea6a106015B2d869814D4Ddd951889F;
uint256 public immutable MAX_SUPPLY_PLUS1 = 556;
uint256 public immutable MAX_PRESALE_PLUS1 = 556;
uint256 public immutable MAX_PER_TXN_PLUS1 = 3;
enum SaleState { pause, presale, publicsale }
SaleState public saleState;
bytes32 public MerkleRoot = 0x043187469c11d994528ce9cfc4d390f2e7c7b41a0cc2cbc52b96aabf046ad3b6;
mapping(address => uint256) public mintedPresale;
bool public isTeamReserved;
address public proxyRegistryAddress = 0xa5409ec958C83C3f309868babACA7c86DCB077c1;
mapping(address => bool) public projectProxy;
string public revealedURI;
string public unrevealedURI = "ipfs://QmbXK2DMeZPMAmveRvKhxnCa2RkFfwsRMpCuWbhr87A4YD";
bool public isRevealed;
constructor() ERC721("Llamafrens", "LF") {}
/**
* USER FUNCTIONS
*/
function mint(uint256 _amount) external payable {
require(saleState == SaleState.publicsale, "public sale not active");
require(msg.sender == tx.origin, "no proxy transactions");
require(_amount < MAX_PER_TXN_PLUS1, "max per session exceeded");
require(msg.value >= _amount * PRICE, "not enough ETH");
uint256 _supply = totalSupply();
require(<FILL_ME>)
for (uint256 i = 0; i < _amount; ) {
_mint(msg.sender, _supply + i);
unchecked { ++i; }
}
}
function mintPresale(bytes32[] memory _proof) external payable {
}
/**
* VIEW FUNCTIONS
*/
function checkProof(address a, bytes32[] memory proof) external view returns (bool) {
}
function tokensOfWalletOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
/**
* OVERRIDE FUNCTIONS
*/
function isApprovedForAll(address _owner, address operator)
public
view
override(ERC721, IERC721)
returns (bool)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
/**
* OWNER FUNCTIONS
*/
function teamReserveMint() external onlyOwner {
}
function setBaseURI(
string memory unrevealedbaseURI_,
string memory revealedbaseURI_
) public onlyOwner {
}
function setIsRevealed() public onlyOwner {
}
function setMerkleRoot(bytes32 _MerkleRoot) public onlyOwner {
}
function setSaleState(SaleState _newState) public onlyOwner {
}
function setPrice(uint256 pub_price, uint256 pre_price) public onlyOwner {
}
function setProxyRegistry(address _proxyRegistryAddress) public onlyOwner {
}
function withdraw() public onlyOwner {
}
}
contract OwnableDelegateProxy {}
contract MarketplaceProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
| _supply+_amount<MAX_SUPPLY_PLUS1,"max supply exceeded" | 264,100 | _supply+_amount<MAX_SUPPLY_PLUS1 |
"address already minted" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "./ERC721_efficient.sol";
contract Llamafrens is ERC721Enumerable, Ownable {
uint256 public PRE_PRICE = 0.04 ether;
uint256 public PRICE = 0.04 ether;
address immutable ASTERIA_ADDRESS =
0x92768aC8daf1005d00C48Ba30A9925ef12d59f8A;
address immutable AYDAN_ADDRESS =
0x59cA02155ea6a106015B2d869814D4Ddd951889F;
uint256 public immutable MAX_SUPPLY_PLUS1 = 556;
uint256 public immutable MAX_PRESALE_PLUS1 = 556;
uint256 public immutable MAX_PER_TXN_PLUS1 = 3;
enum SaleState { pause, presale, publicsale }
SaleState public saleState;
bytes32 public MerkleRoot = 0x043187469c11d994528ce9cfc4d390f2e7c7b41a0cc2cbc52b96aabf046ad3b6;
mapping(address => uint256) public mintedPresale;
bool public isTeamReserved;
address public proxyRegistryAddress = 0xa5409ec958C83C3f309868babACA7c86DCB077c1;
mapping(address => bool) public projectProxy;
string public revealedURI;
string public unrevealedURI = "ipfs://QmbXK2DMeZPMAmveRvKhxnCa2RkFfwsRMpCuWbhr87A4YD";
bool public isRevealed;
constructor() ERC721("Llamafrens", "LF") {}
/**
* USER FUNCTIONS
*/
function mint(uint256 _amount) external payable {
}
function mintPresale(bytes32[] memory _proof) external payable {
require(saleState == SaleState.presale, "presale not active");
require(msg.sender == tx.origin, "no proxy transactions");
require(msg.value >= PRE_PRICE, "not enough ETH");
require(<FILL_ME>)
require(
MerkleProof.verify(
_proof,
MerkleRoot,
keccak256(abi.encodePacked(msg.sender))
),
"invalid sender proof"
);
uint256 _next_token = totalSupply();
unchecked { _next_token++; }
require(_next_token < MAX_PRESALE_PLUS1, "max presale supply exceeded");
mintedPresale[msg.sender] = 1;
_mint(msg.sender, _next_token);
}
/**
* VIEW FUNCTIONS
*/
function checkProof(address a, bytes32[] memory proof) external view returns (bool) {
}
function tokensOfWalletOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
/**
* OVERRIDE FUNCTIONS
*/
function isApprovedForAll(address _owner, address operator)
public
view
override(ERC721, IERC721)
returns (bool)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
/**
* OWNER FUNCTIONS
*/
function teamReserveMint() external onlyOwner {
}
function setBaseURI(
string memory unrevealedbaseURI_,
string memory revealedbaseURI_
) public onlyOwner {
}
function setIsRevealed() public onlyOwner {
}
function setMerkleRoot(bytes32 _MerkleRoot) public onlyOwner {
}
function setSaleState(SaleState _newState) public onlyOwner {
}
function setPrice(uint256 pub_price, uint256 pre_price) public onlyOwner {
}
function setProxyRegistry(address _proxyRegistryAddress) public onlyOwner {
}
function withdraw() public onlyOwner {
}
}
contract OwnableDelegateProxy {}
contract MarketplaceProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
| mintedPresale[msg.sender]<1,"address already minted" | 264,100 | mintedPresale[msg.sender]<1 |
"invalid sender proof" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "./ERC721_efficient.sol";
contract Llamafrens is ERC721Enumerable, Ownable {
uint256 public PRE_PRICE = 0.04 ether;
uint256 public PRICE = 0.04 ether;
address immutable ASTERIA_ADDRESS =
0x92768aC8daf1005d00C48Ba30A9925ef12d59f8A;
address immutable AYDAN_ADDRESS =
0x59cA02155ea6a106015B2d869814D4Ddd951889F;
uint256 public immutable MAX_SUPPLY_PLUS1 = 556;
uint256 public immutable MAX_PRESALE_PLUS1 = 556;
uint256 public immutable MAX_PER_TXN_PLUS1 = 3;
enum SaleState { pause, presale, publicsale }
SaleState public saleState;
bytes32 public MerkleRoot = 0x043187469c11d994528ce9cfc4d390f2e7c7b41a0cc2cbc52b96aabf046ad3b6;
mapping(address => uint256) public mintedPresale;
bool public isTeamReserved;
address public proxyRegistryAddress = 0xa5409ec958C83C3f309868babACA7c86DCB077c1;
mapping(address => bool) public projectProxy;
string public revealedURI;
string public unrevealedURI = "ipfs://QmbXK2DMeZPMAmveRvKhxnCa2RkFfwsRMpCuWbhr87A4YD";
bool public isRevealed;
constructor() ERC721("Llamafrens", "LF") {}
/**
* USER FUNCTIONS
*/
function mint(uint256 _amount) external payable {
}
function mintPresale(bytes32[] memory _proof) external payable {
require(saleState == SaleState.presale, "presale not active");
require(msg.sender == tx.origin, "no proxy transactions");
require(msg.value >= PRE_PRICE, "not enough ETH");
require(mintedPresale[msg.sender] < 1, "address already minted");
require(<FILL_ME>)
uint256 _next_token = totalSupply();
unchecked { _next_token++; }
require(_next_token < MAX_PRESALE_PLUS1, "max presale supply exceeded");
mintedPresale[msg.sender] = 1;
_mint(msg.sender, _next_token);
}
/**
* VIEW FUNCTIONS
*/
function checkProof(address a, bytes32[] memory proof) external view returns (bool) {
}
function tokensOfWalletOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
/**
* OVERRIDE FUNCTIONS
*/
function isApprovedForAll(address _owner, address operator)
public
view
override(ERC721, IERC721)
returns (bool)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
/**
* OWNER FUNCTIONS
*/
function teamReserveMint() external onlyOwner {
}
function setBaseURI(
string memory unrevealedbaseURI_,
string memory revealedbaseURI_
) public onlyOwner {
}
function setIsRevealed() public onlyOwner {
}
function setMerkleRoot(bytes32 _MerkleRoot) public onlyOwner {
}
function setSaleState(SaleState _newState) public onlyOwner {
}
function setPrice(uint256 pub_price, uint256 pre_price) public onlyOwner {
}
function setProxyRegistry(address _proxyRegistryAddress) public onlyOwner {
}
function withdraw() public onlyOwner {
}
}
contract OwnableDelegateProxy {}
contract MarketplaceProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
| MerkleProof.verify(_proof,MerkleRoot,keccak256(abi.encodePacked(msg.sender))),"invalid sender proof" | 264,100 | MerkleProof.verify(_proof,MerkleRoot,keccak256(abi.encodePacked(msg.sender))) |
"team reserves have already been minted" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "./ERC721_efficient.sol";
contract Llamafrens is ERC721Enumerable, Ownable {
uint256 public PRE_PRICE = 0.04 ether;
uint256 public PRICE = 0.04 ether;
address immutable ASTERIA_ADDRESS =
0x92768aC8daf1005d00C48Ba30A9925ef12d59f8A;
address immutable AYDAN_ADDRESS =
0x59cA02155ea6a106015B2d869814D4Ddd951889F;
uint256 public immutable MAX_SUPPLY_PLUS1 = 556;
uint256 public immutable MAX_PRESALE_PLUS1 = 556;
uint256 public immutable MAX_PER_TXN_PLUS1 = 3;
enum SaleState { pause, presale, publicsale }
SaleState public saleState;
bytes32 public MerkleRoot = 0x043187469c11d994528ce9cfc4d390f2e7c7b41a0cc2cbc52b96aabf046ad3b6;
mapping(address => uint256) public mintedPresale;
bool public isTeamReserved;
address public proxyRegistryAddress = 0xa5409ec958C83C3f309868babACA7c86DCB077c1;
mapping(address => bool) public projectProxy;
string public revealedURI;
string public unrevealedURI = "ipfs://QmbXK2DMeZPMAmveRvKhxnCa2RkFfwsRMpCuWbhr87A4YD";
bool public isRevealed;
constructor() ERC721("Llamafrens", "LF") {}
/**
* USER FUNCTIONS
*/
function mint(uint256 _amount) external payable {
}
function mintPresale(bytes32[] memory _proof) external payable {
}
/**
* VIEW FUNCTIONS
*/
function checkProof(address a, bytes32[] memory proof) external view returns (bool) {
}
function tokensOfWalletOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
/**
* OVERRIDE FUNCTIONS
*/
function isApprovedForAll(address _owner, address operator)
public
view
override(ERC721, IERC721)
returns (bool)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
/**
* OWNER FUNCTIONS
*/
function teamReserveMint() external onlyOwner {
require(<FILL_ME>)
uint256 i = 0;
for ( ; i < 26 ; ) {
_mint(AYDAN_ADDRESS, i);
unchecked { ++i; }
}
isTeamReserved = true;
}
function setBaseURI(
string memory unrevealedbaseURI_,
string memory revealedbaseURI_
) public onlyOwner {
}
function setIsRevealed() public onlyOwner {
}
function setMerkleRoot(bytes32 _MerkleRoot) public onlyOwner {
}
function setSaleState(SaleState _newState) public onlyOwner {
}
function setPrice(uint256 pub_price, uint256 pre_price) public onlyOwner {
}
function setProxyRegistry(address _proxyRegistryAddress) public onlyOwner {
}
function withdraw() public onlyOwner {
}
}
contract OwnableDelegateProxy {}
contract MarketplaceProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
| !isTeamReserved,"team reserves have already been minted" | 264,100 | !isTeamReserved |
"Max NFT Per Wallet exceeded" | //Developer : FazelPejmanfar , Twitter :@Pejmanfarfazel
pragma solidity >=0.7.0 <0.9.0;
contract Sausagez is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public cost = 0.0035 ether;
uint256 public maxSupply = 7777;
uint256 public FreeSupply = 1500;
uint256 public MaxperWallet = 500;
uint256 public MaxperWalletFree = 5;
bool public paused = false;
bool public revealed = false;
constructor(
string memory _initBaseURI,
string memory _initNotRevealedUri
) ERC721A("Sausagez Official", "SAUSAGEZ") {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
// public
function mint(uint256 tokens) public payable nonReentrant {
}
function freemint(uint256 tokens) public payable nonReentrant {
require(!paused, "oops contract is paused");
uint256 supply = totalSupply();
require(<FILL_ME>)
require(tokens > 0, "need to mint at least 1 NFT");
require(tokens <= MaxperWalletFree, "max mint per Tx exceeded");
require(supply + tokens <= FreeSupply, "Whitelist MaxSupply exceeded");
_safeMint(_msgSender(), tokens);
}
/// @dev use it for giveaway and mint for yourself
function gift(uint256 _mintAmount, address destination) public onlyOwner nonReentrant {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function numberMinted(address owner) public view returns (uint256) {
}
//only owner
function reveal(bool _state) public onlyOwner {
}
function setMaxPerWallet(uint256 _limit) public onlyOwner {
}
function setFreeMaxPerWallet(uint256 _limit) public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setMaxsupply(uint256 _newsupply) public onlyOwner {
}
function setFreesupply(uint256 _newsupply) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function withdraw() public payable onlyOwner nonReentrant {
}
}
| _numberMinted(_msgSender())+tokens<=MaxperWalletFree,"Max NFT Per Wallet exceeded" | 264,112 | _numberMinted(_msgSender())+tokens<=MaxperWalletFree |
"Whitelist MaxSupply exceeded" | //Developer : FazelPejmanfar , Twitter :@Pejmanfarfazel
pragma solidity >=0.7.0 <0.9.0;
contract Sausagez is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public cost = 0.0035 ether;
uint256 public maxSupply = 7777;
uint256 public FreeSupply = 1500;
uint256 public MaxperWallet = 500;
uint256 public MaxperWalletFree = 5;
bool public paused = false;
bool public revealed = false;
constructor(
string memory _initBaseURI,
string memory _initNotRevealedUri
) ERC721A("Sausagez Official", "SAUSAGEZ") {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
// public
function mint(uint256 tokens) public payable nonReentrant {
}
function freemint(uint256 tokens) public payable nonReentrant {
require(!paused, "oops contract is paused");
uint256 supply = totalSupply();
require(_numberMinted(_msgSender()) + tokens <= MaxperWalletFree, "Max NFT Per Wallet exceeded");
require(tokens > 0, "need to mint at least 1 NFT");
require(tokens <= MaxperWalletFree, "max mint per Tx exceeded");
require(<FILL_ME>)
_safeMint(_msgSender(), tokens);
}
/// @dev use it for giveaway and mint for yourself
function gift(uint256 _mintAmount, address destination) public onlyOwner nonReentrant {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function numberMinted(address owner) public view returns (uint256) {
}
//only owner
function reveal(bool _state) public onlyOwner {
}
function setMaxPerWallet(uint256 _limit) public onlyOwner {
}
function setFreeMaxPerWallet(uint256 _limit) public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setMaxsupply(uint256 _newsupply) public onlyOwner {
}
function setFreesupply(uint256 _newsupply) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function withdraw() public payable onlyOwner nonReentrant {
}
}
| supply+tokens<=FreeSupply,"Whitelist MaxSupply exceeded" | 264,112 | supply+tokens<=FreeSupply |
"Must keep fees at 5% or less" | // SPDX-License-Identifier: MIT
//$POOR token is designed to give all the men who are struggling like the poor fisherman an opportunity to have a better life.
// Website: https://PoorFisherman.com
pragma solidity ^0.8.19;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
interface IFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
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;
}
library Address {
function sendValue(address payable recipient, uint256 amount) internal {
}
}
contract PoorFisherman is Context, IERC20, Ownable {
using Address for address payable;
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 _isExcluded;
address public deadWallet = 0x000000000000000000000000000000000000dEaD;
address public marketingWallet =(0x2Ec7D6415A8cAC25348D471fbdDE22200dab27f0);
address public CEXListingWallet =(0xC3c063b924606FBC23B1371AF2466D1ebA0565C0);
address public LPreserveWallet =(0x88aB9D5a2050256c2fE9949b2eE23642665bc9CF);
address[] private _excluded;
bool public tradingEnabled;
bool private swapEnabled;
bool private swapping;
IRouter public router;
address public pair;
uint8 private constant _decimals = 9;
uint256 private constant MAX = ~uint256(0);
uint256 public _tTotal = 1000000000 * 10**_decimals;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
string private constant _name = "Poor Fisherman";
string private constant _symbol = "POOR";
uint256 public swapTokensAtAmount = 4000000 * 10**9;
uint256 private genesis_block;
uint256 private deadline = 0;
struct Taxes {
uint256 rfi;
uint256 marketing;
uint256 liquidity;
}
Taxes public taxes = Taxes(3, 1, 1);
Taxes public sellTaxes = Taxes(3, 1, 1);
Taxes private launchtax = Taxes(0, 0, 0);
struct TotFeesPaidStruct {
uint256 rfi;
uint256 marketing;
uint256 liquidity;
}
TotFeesPaidStruct public totFeesPaid;
struct valuesFromGetValues {
uint256 rAmount;
uint256 rTransferAmount;
uint256 rRfi;
uint256 rmarketing;
uint256 rLiquidity;
uint256 tTransferAmount;
uint256 tRfi;
uint256 tmarketing;
uint256 tLiquidity;
}
event FeesChanged();
modifier lockTheSwap() {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
returns (bool)
{
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function isExcludedFromReward(address account) public view returns (bool) {
}
function reflectionFromToken(uint256 tAmount, bool deductTransferRfi)
public
view
returns (uint256)
{
}
function EnableTrading() external onlyOwner {
}
function tokenFromReflection(uint256 rAmount) public view returns (uint256) {
}
function excludeFromReward(address account) public onlyOwner {
}
function includeInReward(address account) external onlyOwner {
}
function excludeFromFee(address account) public onlyOwner {
}
function includeInFee(address account) public onlyOwner {
}
function isExcludedFromFee(address account) public view returns (bool) {
}
function updateBuyTaxes(
uint256 _rfi,
uint256 _marketing,
uint256 _liquidity
) public onlyOwner {
require(<FILL_ME>)
taxes = Taxes(_rfi, _marketing, _liquidity);
emit FeesChanged();
}
function updateSellTaxes(
uint256 _rfi,
uint256 _marketing,
uint256 _liquidity
) public onlyOwner {
}
function _reflectRfi(uint256 rRfi, uint256 tRfi) private {
}
function _takeLiquidity(uint256 rLiquidity, uint256 tLiquidity) private {
}
function _takeMarketingFee(uint256 rmarketing, uint256 tmarketing) private {
}
function _getValues(
uint256 tAmount,
bool takeFee,
bool isSell,
bool useLaunchTax
) private view returns (valuesFromGetValues memory to_return) {
}
function _getTValues(
uint256 tAmount,
bool takeFee,
bool isSell,
bool useLaunchTax
) private view returns (valuesFromGetValues memory s) {
}
function _getRValues1(
valuesFromGetValues memory s,
uint256 tAmount,
bool takeFee,
uint256 currentRate
)
private
pure
returns (
uint256 rAmount,
uint256 rTransferAmount,
uint256 rRfi,
uint256 rmarketing,
uint256 rLiquidity
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function _tokenTransfer(address sender,address recipient,uint256 tAmount,bool takeFee,bool isSell) private {
}
function swapAndLiquify(uint256 contractBalance, Taxes memory temp) private lockTheSwap {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function updateMarketingWallet(address newWallet) external onlyOwner {
}
function updateSwapTokensAtAmount(uint256 amount) external onlyOwner {
}
function updateSwapEnabled(bool _enabled) external onlyOwner {
}
function rescueETH() external {
}
function rescueERC20Tokens(address _tokenAddr,address _to, uint256 _amount) public onlyOwner {
}
receive() external payable {}
}
| (_rfi+_marketing+_liquidity)<=5,"Must keep fees at 5% or less" | 264,172 | (_rfi+_marketing+_liquidity)<=5 |
'cost is over balance' | // SPDX-License-Identifier: MIT
/*
* Created by Eiba (@eiba8884)
*/
/*********************************
* ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ *
* ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ *
* ░░░░░░█████████░░█████████░░░ *
* ░░░░░░██░░░████░░██░░░████░░░ *
* ░░██████░░░████████░░░████░░░ *
* ░░██░░██░░░████░░██░░░████░░░ *
* ░░██░░██░░░████░░██░░░████░░░ *
* ░░░░░░█████████░░█████████░░░ *
* ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ *
* ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ *
*********************************/
pragma solidity ^0.8.6;
import '@openzeppelin/contracts/utils/Strings.sol';
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import './libs/ProviderSBT.sol';
import './pNounsToken.sol';
contract pNounsSBT is ProviderSBT {
using Strings for uint256;
pNounsToken public pnouns; // pNounsNFT
constructor(
IAssetProvider _assetProvider,
pNounsToken _pnouns,
address[] memory _administrators
) ProviderSBT(_assetProvider, 'pNouns SBT', 'pNouns', _administrators) {
}
function mintPNouns(
uint256[] calldata _tokenIds // ミントするTokenId
) external payable {
}
/**
コストを差し引いた金額を _payToへ均等割送金する
*/
function withdraw(
address[] calldata _payTo,
address _costTo,
uint256 _cost
) external payable onlyAdminOrOwner {
require(<FILL_ME>)
uint256 payAmount = (address(this).balance - _cost) / _payTo.length;
require(_costTo != address(0), "_payTo shouldn't be 0");
(bool sent, ) = payable(_costTo).call{ value: _cost }('');
for (uint256 i = 0; i < _payTo.length; i++) {
require(_payTo[i] != address(0), "_payTo shouldn't be 0");
(sent, ) = payable(_payTo[i]).call{ value: payAmount }('');
require(sent, 'failed to move fund to _payTo contract');
}
}
function setPNounsToken(pNounsToken _pnouns) external onlyAdminOrOwner {
}
function isMinted(uint256 tokenId) public view returns (bool) {
}
function mint() public payable override returns (uint256) {
}
function tokenName(uint256 _tokenId) internal view virtual override returns (string memory) {
}
}
| address(this).balance>_cost,'cost is over balance' | 264,195 | address(this).balance>_cost |
"_payTo shouldn't be 0" | // SPDX-License-Identifier: MIT
/*
* Created by Eiba (@eiba8884)
*/
/*********************************
* ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ *
* ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ *
* ░░░░░░█████████░░█████████░░░ *
* ░░░░░░██░░░████░░██░░░████░░░ *
* ░░██████░░░████████░░░████░░░ *
* ░░██░░██░░░████░░██░░░████░░░ *
* ░░██░░██░░░████░░██░░░████░░░ *
* ░░░░░░█████████░░█████████░░░ *
* ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ *
* ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ *
*********************************/
pragma solidity ^0.8.6;
import '@openzeppelin/contracts/utils/Strings.sol';
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import './libs/ProviderSBT.sol';
import './pNounsToken.sol';
contract pNounsSBT is ProviderSBT {
using Strings for uint256;
pNounsToken public pnouns; // pNounsNFT
constructor(
IAssetProvider _assetProvider,
pNounsToken _pnouns,
address[] memory _administrators
) ProviderSBT(_assetProvider, 'pNouns SBT', 'pNouns', _administrators) {
}
function mintPNouns(
uint256[] calldata _tokenIds // ミントするTokenId
) external payable {
}
/**
コストを差し引いた金額を _payToへ均等割送金する
*/
function withdraw(
address[] calldata _payTo,
address _costTo,
uint256 _cost
) external payable onlyAdminOrOwner {
require(address(this).balance > _cost, 'cost is over balance');
uint256 payAmount = (address(this).balance - _cost) / _payTo.length;
require(_costTo != address(0), "_payTo shouldn't be 0");
(bool sent, ) = payable(_costTo).call{ value: _cost }('');
for (uint256 i = 0; i < _payTo.length; i++) {
require(<FILL_ME>)
(sent, ) = payable(_payTo[i]).call{ value: payAmount }('');
require(sent, 'failed to move fund to _payTo contract');
}
}
function setPNounsToken(pNounsToken _pnouns) external onlyAdminOrOwner {
}
function isMinted(uint256 tokenId) public view returns (bool) {
}
function mint() public payable override returns (uint256) {
}
function tokenName(uint256 _tokenId) internal view virtual override returns (string memory) {
}
}
| _payTo[i]!=address(0),"_payTo shouldn't be 0" | 264,195 | _payTo[i]!=address(0) |
"Invalid gauge type" | // SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
import "@balancer-labs/v2-interfaces/contracts/liquidity-mining/IAuthorizerAdaptorEntrypoint.sol";
import "@balancer-labs/v2-interfaces/contracts/liquidity-mining/IGaugeAdder.sol";
import "@balancer-labs/v2-interfaces/contracts/liquidity-mining/IGaugeController.sol";
import "@balancer-labs/v2-interfaces/contracts/liquidity-mining/IStakelessGauge.sol";
import "@balancer-labs/v2-interfaces/contracts/liquidity-mining/IStakelessGaugeCheckpointer.sol";
import "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/Address.sol";
import "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/EnumerableSet.sol";
import "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/ReentrancyGuard.sol";
import "../admin/GaugeAdder.sol";
import "./arbitrum/ArbitrumRootGauge.sol";
/**
* @title Stakeless Gauge Checkpointer
* @notice Implements IStakelessGaugeCheckpointer; refer to it for API documentation.
*/
contract StakelessGaugeCheckpointer is IStakelessGaugeCheckpointer, ReentrancyGuard, SingletonAuthentication {
using EnumerableSet for EnumerableSet.AddressSet;
bytes32 private immutable _arbitrum = keccak256(abi.encodePacked("Arbitrum"));
mapping(string => EnumerableSet.AddressSet) private _gauges;
IAuthorizerAdaptorEntrypoint private immutable _authorizerAdaptorEntrypoint;
IGaugeAdder private immutable _gaugeAdder;
IGaugeController private immutable _gaugeController;
constructor(IGaugeAdder gaugeAdder, IAuthorizerAdaptorEntrypoint authorizerAdaptorEntrypoint)
SingletonAuthentication(authorizerAdaptorEntrypoint.getVault())
{
}
modifier withValidGaugeType(string memory gaugeType) {
require(<FILL_ME>)
_;
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getGaugeAdder() external view override returns (IGaugeAdder) {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getGaugeTypes() external view override returns (string[] memory) {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function addGaugesWithVerifiedType(string memory gaugeType, IStakelessGauge[] calldata gauges)
external
override
withValidGaugeType(gaugeType)
authenticate
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function addGauges(string memory gaugeType, IStakelessGauge[] calldata gauges)
external
override
withValidGaugeType(gaugeType)
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function removeGauges(string memory gaugeType, IStakelessGauge[] calldata gauges)
external
override
withValidGaugeType(gaugeType)
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function hasGauge(string memory gaugeType, IStakelessGauge gauge)
external
view
override
withValidGaugeType(gaugeType)
returns (bool)
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getTotalGauges(string memory gaugeType)
external
view
override
withValidGaugeType(gaugeType)
returns (uint256)
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getGaugeAtIndex(string memory gaugeType, uint256 index)
external
view
override
withValidGaugeType(gaugeType)
returns (IStakelessGauge)
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getRoundedDownBlockTimestamp() external view override returns (uint256) {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function checkpointGaugesAboveRelativeWeight(uint256 minRelativeWeight) external payable override nonReentrant {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function checkpointGaugesOfTypeAboveRelativeWeight(string memory gaugeType, uint256 minRelativeWeight)
external
payable
override
nonReentrant
withValidGaugeType(gaugeType)
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function checkpointSingleGauge(string memory gaugeType, address gauge) external payable override nonReentrant {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function checkpointMultipleGauges(string[] memory gaugeTypes, address[] memory gauges)
external
payable
override
nonReentrant
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getSingleBridgeCost(string memory gaugeType, address gauge) public view override returns (uint256) {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getTotalBridgeCost(uint256 minRelativeWeight) external view override returns (uint256) {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function isValidGaugeType(string memory gaugeType) external view override returns (bool) {
}
function _addGauges(
string memory gaugeType,
IStakelessGauge[] calldata gauges,
bool isGaugeTypeVerified
) internal {
}
/**
* @dev Performs checkpoints for all gauges of the given type whose relative weight is at least the specified one.
* @param gaugeType Type of the gauges to checkpoint.
* @param minRelativeWeight Threshold to filter out gauges below it.
* @param currentPeriod Current block time rounded down to the start of the previous week.
* This method doesn't check whether the caller transferred enough ETH to cover the whole operation.
*/
function _checkpointGauges(
string memory gaugeType,
uint256 minRelativeWeight,
uint256 currentPeriod
) private {
}
/**
* @dev Performs checkpoint for Arbitrum gauge, forwarding ETH to pay bridge costs.
*/
function _checkpointArbitrumGauge(address gauge) private {
}
/**
* @dev Performs checkpoint for non-Arbitrum gauge; does not forward any ETH.
*/
function _checkpointCostlessBridgeGauge(address gauge) private {
}
function _checkpointSingleGauge(string memory gaugeType, address gauge) internal {
}
/**
* @dev Send back any leftover ETH to the caller if there is an existing balance in the contract.
*/
function _returnLeftoverEthIfAny() private {
}
/**
* @dev Rounds the provided timestamp down to the beginning of the previous week (Thurs 00:00 UTC) with respect
* to the current block timestamp.
*/
function _roundDownBlockTimestamp() private view returns (uint256) {
}
}
| _gaugeAdder.isValidGaugeType(gaugeType),"Invalid gauge type" | 264,210 | _gaugeAdder.isValidGaugeType(gaugeType) |
"Gauge was not killed" | // SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
import "@balancer-labs/v2-interfaces/contracts/liquidity-mining/IAuthorizerAdaptorEntrypoint.sol";
import "@balancer-labs/v2-interfaces/contracts/liquidity-mining/IGaugeAdder.sol";
import "@balancer-labs/v2-interfaces/contracts/liquidity-mining/IGaugeController.sol";
import "@balancer-labs/v2-interfaces/contracts/liquidity-mining/IStakelessGauge.sol";
import "@balancer-labs/v2-interfaces/contracts/liquidity-mining/IStakelessGaugeCheckpointer.sol";
import "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/Address.sol";
import "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/EnumerableSet.sol";
import "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/ReentrancyGuard.sol";
import "../admin/GaugeAdder.sol";
import "./arbitrum/ArbitrumRootGauge.sol";
/**
* @title Stakeless Gauge Checkpointer
* @notice Implements IStakelessGaugeCheckpointer; refer to it for API documentation.
*/
contract StakelessGaugeCheckpointer is IStakelessGaugeCheckpointer, ReentrancyGuard, SingletonAuthentication {
using EnumerableSet for EnumerableSet.AddressSet;
bytes32 private immutable _arbitrum = keccak256(abi.encodePacked("Arbitrum"));
mapping(string => EnumerableSet.AddressSet) private _gauges;
IAuthorizerAdaptorEntrypoint private immutable _authorizerAdaptorEntrypoint;
IGaugeAdder private immutable _gaugeAdder;
IGaugeController private immutable _gaugeController;
constructor(IGaugeAdder gaugeAdder, IAuthorizerAdaptorEntrypoint authorizerAdaptorEntrypoint)
SingletonAuthentication(authorizerAdaptorEntrypoint.getVault())
{
}
modifier withValidGaugeType(string memory gaugeType) {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getGaugeAdder() external view override returns (IGaugeAdder) {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getGaugeTypes() external view override returns (string[] memory) {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function addGaugesWithVerifiedType(string memory gaugeType, IStakelessGauge[] calldata gauges)
external
override
withValidGaugeType(gaugeType)
authenticate
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function addGauges(string memory gaugeType, IStakelessGauge[] calldata gauges)
external
override
withValidGaugeType(gaugeType)
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function removeGauges(string memory gaugeType, IStakelessGauge[] calldata gauges)
external
override
withValidGaugeType(gaugeType)
{
EnumerableSet.AddressSet storage gaugesForType = _gauges[gaugeType];
for (uint256 i = 0; i < gauges.length; i++) {
// Gauges added must come from a valid factory and exist in the controller, and they can't be removed from
// them. Therefore, the only required check at this point is whether the gauge was killed.
IStakelessGauge gauge = gauges[i];
require(<FILL_ME>)
require(gaugesForType.remove(address(gauge)), "Gauge was not added to the checkpointer");
emit IStakelessGaugeCheckpointer.GaugeRemoved(gauge, gaugeType, gaugeType);
}
}
/// @inheritdoc IStakelessGaugeCheckpointer
function hasGauge(string memory gaugeType, IStakelessGauge gauge)
external
view
override
withValidGaugeType(gaugeType)
returns (bool)
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getTotalGauges(string memory gaugeType)
external
view
override
withValidGaugeType(gaugeType)
returns (uint256)
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getGaugeAtIndex(string memory gaugeType, uint256 index)
external
view
override
withValidGaugeType(gaugeType)
returns (IStakelessGauge)
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getRoundedDownBlockTimestamp() external view override returns (uint256) {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function checkpointGaugesAboveRelativeWeight(uint256 minRelativeWeight) external payable override nonReentrant {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function checkpointGaugesOfTypeAboveRelativeWeight(string memory gaugeType, uint256 minRelativeWeight)
external
payable
override
nonReentrant
withValidGaugeType(gaugeType)
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function checkpointSingleGauge(string memory gaugeType, address gauge) external payable override nonReentrant {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function checkpointMultipleGauges(string[] memory gaugeTypes, address[] memory gauges)
external
payable
override
nonReentrant
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getSingleBridgeCost(string memory gaugeType, address gauge) public view override returns (uint256) {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getTotalBridgeCost(uint256 minRelativeWeight) external view override returns (uint256) {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function isValidGaugeType(string memory gaugeType) external view override returns (bool) {
}
function _addGauges(
string memory gaugeType,
IStakelessGauge[] calldata gauges,
bool isGaugeTypeVerified
) internal {
}
/**
* @dev Performs checkpoints for all gauges of the given type whose relative weight is at least the specified one.
* @param gaugeType Type of the gauges to checkpoint.
* @param minRelativeWeight Threshold to filter out gauges below it.
* @param currentPeriod Current block time rounded down to the start of the previous week.
* This method doesn't check whether the caller transferred enough ETH to cover the whole operation.
*/
function _checkpointGauges(
string memory gaugeType,
uint256 minRelativeWeight,
uint256 currentPeriod
) private {
}
/**
* @dev Performs checkpoint for Arbitrum gauge, forwarding ETH to pay bridge costs.
*/
function _checkpointArbitrumGauge(address gauge) private {
}
/**
* @dev Performs checkpoint for non-Arbitrum gauge; does not forward any ETH.
*/
function _checkpointCostlessBridgeGauge(address gauge) private {
}
function _checkpointSingleGauge(string memory gaugeType, address gauge) internal {
}
/**
* @dev Send back any leftover ETH to the caller if there is an existing balance in the contract.
*/
function _returnLeftoverEthIfAny() private {
}
/**
* @dev Rounds the provided timestamp down to the beginning of the previous week (Thurs 00:00 UTC) with respect
* to the current block timestamp.
*/
function _roundDownBlockTimestamp() private view returns (uint256) {
}
}
| gauge.is_killed(),"Gauge was not killed" | 264,210 | gauge.is_killed() |
"Gauge was not added to the checkpointer" | // SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
import "@balancer-labs/v2-interfaces/contracts/liquidity-mining/IAuthorizerAdaptorEntrypoint.sol";
import "@balancer-labs/v2-interfaces/contracts/liquidity-mining/IGaugeAdder.sol";
import "@balancer-labs/v2-interfaces/contracts/liquidity-mining/IGaugeController.sol";
import "@balancer-labs/v2-interfaces/contracts/liquidity-mining/IStakelessGauge.sol";
import "@balancer-labs/v2-interfaces/contracts/liquidity-mining/IStakelessGaugeCheckpointer.sol";
import "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/Address.sol";
import "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/EnumerableSet.sol";
import "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/ReentrancyGuard.sol";
import "../admin/GaugeAdder.sol";
import "./arbitrum/ArbitrumRootGauge.sol";
/**
* @title Stakeless Gauge Checkpointer
* @notice Implements IStakelessGaugeCheckpointer; refer to it for API documentation.
*/
contract StakelessGaugeCheckpointer is IStakelessGaugeCheckpointer, ReentrancyGuard, SingletonAuthentication {
using EnumerableSet for EnumerableSet.AddressSet;
bytes32 private immutable _arbitrum = keccak256(abi.encodePacked("Arbitrum"));
mapping(string => EnumerableSet.AddressSet) private _gauges;
IAuthorizerAdaptorEntrypoint private immutable _authorizerAdaptorEntrypoint;
IGaugeAdder private immutable _gaugeAdder;
IGaugeController private immutable _gaugeController;
constructor(IGaugeAdder gaugeAdder, IAuthorizerAdaptorEntrypoint authorizerAdaptorEntrypoint)
SingletonAuthentication(authorizerAdaptorEntrypoint.getVault())
{
}
modifier withValidGaugeType(string memory gaugeType) {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getGaugeAdder() external view override returns (IGaugeAdder) {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getGaugeTypes() external view override returns (string[] memory) {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function addGaugesWithVerifiedType(string memory gaugeType, IStakelessGauge[] calldata gauges)
external
override
withValidGaugeType(gaugeType)
authenticate
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function addGauges(string memory gaugeType, IStakelessGauge[] calldata gauges)
external
override
withValidGaugeType(gaugeType)
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function removeGauges(string memory gaugeType, IStakelessGauge[] calldata gauges)
external
override
withValidGaugeType(gaugeType)
{
EnumerableSet.AddressSet storage gaugesForType = _gauges[gaugeType];
for (uint256 i = 0; i < gauges.length; i++) {
// Gauges added must come from a valid factory and exist in the controller, and they can't be removed from
// them. Therefore, the only required check at this point is whether the gauge was killed.
IStakelessGauge gauge = gauges[i];
require(gauge.is_killed(), "Gauge was not killed");
require(<FILL_ME>)
emit IStakelessGaugeCheckpointer.GaugeRemoved(gauge, gaugeType, gaugeType);
}
}
/// @inheritdoc IStakelessGaugeCheckpointer
function hasGauge(string memory gaugeType, IStakelessGauge gauge)
external
view
override
withValidGaugeType(gaugeType)
returns (bool)
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getTotalGauges(string memory gaugeType)
external
view
override
withValidGaugeType(gaugeType)
returns (uint256)
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getGaugeAtIndex(string memory gaugeType, uint256 index)
external
view
override
withValidGaugeType(gaugeType)
returns (IStakelessGauge)
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getRoundedDownBlockTimestamp() external view override returns (uint256) {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function checkpointGaugesAboveRelativeWeight(uint256 minRelativeWeight) external payable override nonReentrant {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function checkpointGaugesOfTypeAboveRelativeWeight(string memory gaugeType, uint256 minRelativeWeight)
external
payable
override
nonReentrant
withValidGaugeType(gaugeType)
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function checkpointSingleGauge(string memory gaugeType, address gauge) external payable override nonReentrant {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function checkpointMultipleGauges(string[] memory gaugeTypes, address[] memory gauges)
external
payable
override
nonReentrant
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getSingleBridgeCost(string memory gaugeType, address gauge) public view override returns (uint256) {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getTotalBridgeCost(uint256 minRelativeWeight) external view override returns (uint256) {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function isValidGaugeType(string memory gaugeType) external view override returns (bool) {
}
function _addGauges(
string memory gaugeType,
IStakelessGauge[] calldata gauges,
bool isGaugeTypeVerified
) internal {
}
/**
* @dev Performs checkpoints for all gauges of the given type whose relative weight is at least the specified one.
* @param gaugeType Type of the gauges to checkpoint.
* @param minRelativeWeight Threshold to filter out gauges below it.
* @param currentPeriod Current block time rounded down to the start of the previous week.
* This method doesn't check whether the caller transferred enough ETH to cover the whole operation.
*/
function _checkpointGauges(
string memory gaugeType,
uint256 minRelativeWeight,
uint256 currentPeriod
) private {
}
/**
* @dev Performs checkpoint for Arbitrum gauge, forwarding ETH to pay bridge costs.
*/
function _checkpointArbitrumGauge(address gauge) private {
}
/**
* @dev Performs checkpoint for non-Arbitrum gauge; does not forward any ETH.
*/
function _checkpointCostlessBridgeGauge(address gauge) private {
}
function _checkpointSingleGauge(string memory gaugeType, address gauge) internal {
}
/**
* @dev Send back any leftover ETH to the caller if there is an existing balance in the contract.
*/
function _returnLeftoverEthIfAny() private {
}
/**
* @dev Rounds the provided timestamp down to the beginning of the previous week (Thurs 00:00 UTC) with respect
* to the current block timestamp.
*/
function _roundDownBlockTimestamp() private view returns (uint256) {
}
}
| gaugesForType.remove(address(gauge)),"Gauge was not added to the checkpointer" | 264,210 | gaugesForType.remove(address(gauge)) |
"Gauge was not added to the checkpointer" | // SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
import "@balancer-labs/v2-interfaces/contracts/liquidity-mining/IAuthorizerAdaptorEntrypoint.sol";
import "@balancer-labs/v2-interfaces/contracts/liquidity-mining/IGaugeAdder.sol";
import "@balancer-labs/v2-interfaces/contracts/liquidity-mining/IGaugeController.sol";
import "@balancer-labs/v2-interfaces/contracts/liquidity-mining/IStakelessGauge.sol";
import "@balancer-labs/v2-interfaces/contracts/liquidity-mining/IStakelessGaugeCheckpointer.sol";
import "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/Address.sol";
import "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/EnumerableSet.sol";
import "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/ReentrancyGuard.sol";
import "../admin/GaugeAdder.sol";
import "./arbitrum/ArbitrumRootGauge.sol";
/**
* @title Stakeless Gauge Checkpointer
* @notice Implements IStakelessGaugeCheckpointer; refer to it for API documentation.
*/
contract StakelessGaugeCheckpointer is IStakelessGaugeCheckpointer, ReentrancyGuard, SingletonAuthentication {
using EnumerableSet for EnumerableSet.AddressSet;
bytes32 private immutable _arbitrum = keccak256(abi.encodePacked("Arbitrum"));
mapping(string => EnumerableSet.AddressSet) private _gauges;
IAuthorizerAdaptorEntrypoint private immutable _authorizerAdaptorEntrypoint;
IGaugeAdder private immutable _gaugeAdder;
IGaugeController private immutable _gaugeController;
constructor(IGaugeAdder gaugeAdder, IAuthorizerAdaptorEntrypoint authorizerAdaptorEntrypoint)
SingletonAuthentication(authorizerAdaptorEntrypoint.getVault())
{
}
modifier withValidGaugeType(string memory gaugeType) {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getGaugeAdder() external view override returns (IGaugeAdder) {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getGaugeTypes() external view override returns (string[] memory) {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function addGaugesWithVerifiedType(string memory gaugeType, IStakelessGauge[] calldata gauges)
external
override
withValidGaugeType(gaugeType)
authenticate
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function addGauges(string memory gaugeType, IStakelessGauge[] calldata gauges)
external
override
withValidGaugeType(gaugeType)
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function removeGauges(string memory gaugeType, IStakelessGauge[] calldata gauges)
external
override
withValidGaugeType(gaugeType)
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function hasGauge(string memory gaugeType, IStakelessGauge gauge)
external
view
override
withValidGaugeType(gaugeType)
returns (bool)
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getTotalGauges(string memory gaugeType)
external
view
override
withValidGaugeType(gaugeType)
returns (uint256)
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getGaugeAtIndex(string memory gaugeType, uint256 index)
external
view
override
withValidGaugeType(gaugeType)
returns (IStakelessGauge)
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getRoundedDownBlockTimestamp() external view override returns (uint256) {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function checkpointGaugesAboveRelativeWeight(uint256 minRelativeWeight) external payable override nonReentrant {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function checkpointGaugesOfTypeAboveRelativeWeight(string memory gaugeType, uint256 minRelativeWeight)
external
payable
override
nonReentrant
withValidGaugeType(gaugeType)
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function checkpointSingleGauge(string memory gaugeType, address gauge) external payable override nonReentrant {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function checkpointMultipleGauges(string[] memory gaugeTypes, address[] memory gauges)
external
payable
override
nonReentrant
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getSingleBridgeCost(string memory gaugeType, address gauge) public view override returns (uint256) {
require(<FILL_ME>)
if (keccak256(abi.encodePacked(gaugeType)) == _arbitrum) {
return ArbitrumRootGauge(gauge).getTotalBridgeCost();
} else {
return 0;
}
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getTotalBridgeCost(uint256 minRelativeWeight) external view override returns (uint256) {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function isValidGaugeType(string memory gaugeType) external view override returns (bool) {
}
function _addGauges(
string memory gaugeType,
IStakelessGauge[] calldata gauges,
bool isGaugeTypeVerified
) internal {
}
/**
* @dev Performs checkpoints for all gauges of the given type whose relative weight is at least the specified one.
* @param gaugeType Type of the gauges to checkpoint.
* @param minRelativeWeight Threshold to filter out gauges below it.
* @param currentPeriod Current block time rounded down to the start of the previous week.
* This method doesn't check whether the caller transferred enough ETH to cover the whole operation.
*/
function _checkpointGauges(
string memory gaugeType,
uint256 minRelativeWeight,
uint256 currentPeriod
) private {
}
/**
* @dev Performs checkpoint for Arbitrum gauge, forwarding ETH to pay bridge costs.
*/
function _checkpointArbitrumGauge(address gauge) private {
}
/**
* @dev Performs checkpoint for non-Arbitrum gauge; does not forward any ETH.
*/
function _checkpointCostlessBridgeGauge(address gauge) private {
}
function _checkpointSingleGauge(string memory gaugeType, address gauge) internal {
}
/**
* @dev Send back any leftover ETH to the caller if there is an existing balance in the contract.
*/
function _returnLeftoverEthIfAny() private {
}
/**
* @dev Rounds the provided timestamp down to the beginning of the previous week (Thurs 00:00 UTC) with respect
* to the current block timestamp.
*/
function _roundDownBlockTimestamp() private view returns (uint256) {
}
}
| _gauges[gaugeType].contains(gauge),"Gauge was not added to the checkpointer" | 264,210 | _gauges[gaugeType].contains(gauge) |
"Gauge was not added to the GaugeController" | // SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
import "@balancer-labs/v2-interfaces/contracts/liquidity-mining/IAuthorizerAdaptorEntrypoint.sol";
import "@balancer-labs/v2-interfaces/contracts/liquidity-mining/IGaugeAdder.sol";
import "@balancer-labs/v2-interfaces/contracts/liquidity-mining/IGaugeController.sol";
import "@balancer-labs/v2-interfaces/contracts/liquidity-mining/IStakelessGauge.sol";
import "@balancer-labs/v2-interfaces/contracts/liquidity-mining/IStakelessGaugeCheckpointer.sol";
import "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/Address.sol";
import "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/EnumerableSet.sol";
import "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/ReentrancyGuard.sol";
import "../admin/GaugeAdder.sol";
import "./arbitrum/ArbitrumRootGauge.sol";
/**
* @title Stakeless Gauge Checkpointer
* @notice Implements IStakelessGaugeCheckpointer; refer to it for API documentation.
*/
contract StakelessGaugeCheckpointer is IStakelessGaugeCheckpointer, ReentrancyGuard, SingletonAuthentication {
using EnumerableSet for EnumerableSet.AddressSet;
bytes32 private immutable _arbitrum = keccak256(abi.encodePacked("Arbitrum"));
mapping(string => EnumerableSet.AddressSet) private _gauges;
IAuthorizerAdaptorEntrypoint private immutable _authorizerAdaptorEntrypoint;
IGaugeAdder private immutable _gaugeAdder;
IGaugeController private immutable _gaugeController;
constructor(IGaugeAdder gaugeAdder, IAuthorizerAdaptorEntrypoint authorizerAdaptorEntrypoint)
SingletonAuthentication(authorizerAdaptorEntrypoint.getVault())
{
}
modifier withValidGaugeType(string memory gaugeType) {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getGaugeAdder() external view override returns (IGaugeAdder) {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getGaugeTypes() external view override returns (string[] memory) {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function addGaugesWithVerifiedType(string memory gaugeType, IStakelessGauge[] calldata gauges)
external
override
withValidGaugeType(gaugeType)
authenticate
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function addGauges(string memory gaugeType, IStakelessGauge[] calldata gauges)
external
override
withValidGaugeType(gaugeType)
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function removeGauges(string memory gaugeType, IStakelessGauge[] calldata gauges)
external
override
withValidGaugeType(gaugeType)
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function hasGauge(string memory gaugeType, IStakelessGauge gauge)
external
view
override
withValidGaugeType(gaugeType)
returns (bool)
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getTotalGauges(string memory gaugeType)
external
view
override
withValidGaugeType(gaugeType)
returns (uint256)
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getGaugeAtIndex(string memory gaugeType, uint256 index)
external
view
override
withValidGaugeType(gaugeType)
returns (IStakelessGauge)
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getRoundedDownBlockTimestamp() external view override returns (uint256) {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function checkpointGaugesAboveRelativeWeight(uint256 minRelativeWeight) external payable override nonReentrant {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function checkpointGaugesOfTypeAboveRelativeWeight(string memory gaugeType, uint256 minRelativeWeight)
external
payable
override
nonReentrant
withValidGaugeType(gaugeType)
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function checkpointSingleGauge(string memory gaugeType, address gauge) external payable override nonReentrant {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function checkpointMultipleGauges(string[] memory gaugeTypes, address[] memory gauges)
external
payable
override
nonReentrant
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getSingleBridgeCost(string memory gaugeType, address gauge) public view override returns (uint256) {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getTotalBridgeCost(uint256 minRelativeWeight) external view override returns (uint256) {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function isValidGaugeType(string memory gaugeType) external view override returns (bool) {
}
function _addGauges(
string memory gaugeType,
IStakelessGauge[] calldata gauges,
bool isGaugeTypeVerified
) internal {
EnumerableSet.AddressSet storage gaugesForType = _gauges[gaugeType];
for (uint256 i = 0; i < gauges.length; i++) {
IStakelessGauge gauge = gauges[i];
// Gauges must come from a valid factory to be added to the gauge controller, so gauges that don't pass
// the valid factory check will be rejected by the controller.
require(<FILL_ME>)
require(!gauge.is_killed(), "Gauge was killed");
require(gaugesForType.add(address(gauge)), "Gauge already added to the checkpointer");
// To ensure that the gauge effectively corresponds to the given type, we query the gauge factory registered
// in the gauge adder for the gauge type.
// However, since gauges may come from older factories from previous adders, we need to be able to override
// this check. This way we can effectively still add older gauges to the checkpointer via authorized calls.
require(
isGaugeTypeVerified || _gaugeAdder.getFactoryForGaugeType(gaugeType).isGaugeFromFactory(address(gauge)),
"Gauge does not correspond to the selected type"
);
emit IStakelessGaugeCheckpointer.GaugeAdded(gauge, gaugeType, gaugeType);
}
}
/**
* @dev Performs checkpoints for all gauges of the given type whose relative weight is at least the specified one.
* @param gaugeType Type of the gauges to checkpoint.
* @param minRelativeWeight Threshold to filter out gauges below it.
* @param currentPeriod Current block time rounded down to the start of the previous week.
* This method doesn't check whether the caller transferred enough ETH to cover the whole operation.
*/
function _checkpointGauges(
string memory gaugeType,
uint256 minRelativeWeight,
uint256 currentPeriod
) private {
}
/**
* @dev Performs checkpoint for Arbitrum gauge, forwarding ETH to pay bridge costs.
*/
function _checkpointArbitrumGauge(address gauge) private {
}
/**
* @dev Performs checkpoint for non-Arbitrum gauge; does not forward any ETH.
*/
function _checkpointCostlessBridgeGauge(address gauge) private {
}
function _checkpointSingleGauge(string memory gaugeType, address gauge) internal {
}
/**
* @dev Send back any leftover ETH to the caller if there is an existing balance in the contract.
*/
function _returnLeftoverEthIfAny() private {
}
/**
* @dev Rounds the provided timestamp down to the beginning of the previous week (Thurs 00:00 UTC) with respect
* to the current block timestamp.
*/
function _roundDownBlockTimestamp() private view returns (uint256) {
}
}
| _gaugeController.gauge_exists(address(gauge)),"Gauge was not added to the GaugeController" | 264,210 | _gaugeController.gauge_exists(address(gauge)) |
"Gauge was killed" | // SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
import "@balancer-labs/v2-interfaces/contracts/liquidity-mining/IAuthorizerAdaptorEntrypoint.sol";
import "@balancer-labs/v2-interfaces/contracts/liquidity-mining/IGaugeAdder.sol";
import "@balancer-labs/v2-interfaces/contracts/liquidity-mining/IGaugeController.sol";
import "@balancer-labs/v2-interfaces/contracts/liquidity-mining/IStakelessGauge.sol";
import "@balancer-labs/v2-interfaces/contracts/liquidity-mining/IStakelessGaugeCheckpointer.sol";
import "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/Address.sol";
import "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/EnumerableSet.sol";
import "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/ReentrancyGuard.sol";
import "../admin/GaugeAdder.sol";
import "./arbitrum/ArbitrumRootGauge.sol";
/**
* @title Stakeless Gauge Checkpointer
* @notice Implements IStakelessGaugeCheckpointer; refer to it for API documentation.
*/
contract StakelessGaugeCheckpointer is IStakelessGaugeCheckpointer, ReentrancyGuard, SingletonAuthentication {
using EnumerableSet for EnumerableSet.AddressSet;
bytes32 private immutable _arbitrum = keccak256(abi.encodePacked("Arbitrum"));
mapping(string => EnumerableSet.AddressSet) private _gauges;
IAuthorizerAdaptorEntrypoint private immutable _authorizerAdaptorEntrypoint;
IGaugeAdder private immutable _gaugeAdder;
IGaugeController private immutable _gaugeController;
constructor(IGaugeAdder gaugeAdder, IAuthorizerAdaptorEntrypoint authorizerAdaptorEntrypoint)
SingletonAuthentication(authorizerAdaptorEntrypoint.getVault())
{
}
modifier withValidGaugeType(string memory gaugeType) {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getGaugeAdder() external view override returns (IGaugeAdder) {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getGaugeTypes() external view override returns (string[] memory) {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function addGaugesWithVerifiedType(string memory gaugeType, IStakelessGauge[] calldata gauges)
external
override
withValidGaugeType(gaugeType)
authenticate
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function addGauges(string memory gaugeType, IStakelessGauge[] calldata gauges)
external
override
withValidGaugeType(gaugeType)
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function removeGauges(string memory gaugeType, IStakelessGauge[] calldata gauges)
external
override
withValidGaugeType(gaugeType)
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function hasGauge(string memory gaugeType, IStakelessGauge gauge)
external
view
override
withValidGaugeType(gaugeType)
returns (bool)
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getTotalGauges(string memory gaugeType)
external
view
override
withValidGaugeType(gaugeType)
returns (uint256)
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getGaugeAtIndex(string memory gaugeType, uint256 index)
external
view
override
withValidGaugeType(gaugeType)
returns (IStakelessGauge)
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getRoundedDownBlockTimestamp() external view override returns (uint256) {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function checkpointGaugesAboveRelativeWeight(uint256 minRelativeWeight) external payable override nonReentrant {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function checkpointGaugesOfTypeAboveRelativeWeight(string memory gaugeType, uint256 minRelativeWeight)
external
payable
override
nonReentrant
withValidGaugeType(gaugeType)
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function checkpointSingleGauge(string memory gaugeType, address gauge) external payable override nonReentrant {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function checkpointMultipleGauges(string[] memory gaugeTypes, address[] memory gauges)
external
payable
override
nonReentrant
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getSingleBridgeCost(string memory gaugeType, address gauge) public view override returns (uint256) {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getTotalBridgeCost(uint256 minRelativeWeight) external view override returns (uint256) {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function isValidGaugeType(string memory gaugeType) external view override returns (bool) {
}
function _addGauges(
string memory gaugeType,
IStakelessGauge[] calldata gauges,
bool isGaugeTypeVerified
) internal {
EnumerableSet.AddressSet storage gaugesForType = _gauges[gaugeType];
for (uint256 i = 0; i < gauges.length; i++) {
IStakelessGauge gauge = gauges[i];
// Gauges must come from a valid factory to be added to the gauge controller, so gauges that don't pass
// the valid factory check will be rejected by the controller.
require(_gaugeController.gauge_exists(address(gauge)), "Gauge was not added to the GaugeController");
require(<FILL_ME>)
require(gaugesForType.add(address(gauge)), "Gauge already added to the checkpointer");
// To ensure that the gauge effectively corresponds to the given type, we query the gauge factory registered
// in the gauge adder for the gauge type.
// However, since gauges may come from older factories from previous adders, we need to be able to override
// this check. This way we can effectively still add older gauges to the checkpointer via authorized calls.
require(
isGaugeTypeVerified || _gaugeAdder.getFactoryForGaugeType(gaugeType).isGaugeFromFactory(address(gauge)),
"Gauge does not correspond to the selected type"
);
emit IStakelessGaugeCheckpointer.GaugeAdded(gauge, gaugeType, gaugeType);
}
}
/**
* @dev Performs checkpoints for all gauges of the given type whose relative weight is at least the specified one.
* @param gaugeType Type of the gauges to checkpoint.
* @param minRelativeWeight Threshold to filter out gauges below it.
* @param currentPeriod Current block time rounded down to the start of the previous week.
* This method doesn't check whether the caller transferred enough ETH to cover the whole operation.
*/
function _checkpointGauges(
string memory gaugeType,
uint256 minRelativeWeight,
uint256 currentPeriod
) private {
}
/**
* @dev Performs checkpoint for Arbitrum gauge, forwarding ETH to pay bridge costs.
*/
function _checkpointArbitrumGauge(address gauge) private {
}
/**
* @dev Performs checkpoint for non-Arbitrum gauge; does not forward any ETH.
*/
function _checkpointCostlessBridgeGauge(address gauge) private {
}
function _checkpointSingleGauge(string memory gaugeType, address gauge) internal {
}
/**
* @dev Send back any leftover ETH to the caller if there is an existing balance in the contract.
*/
function _returnLeftoverEthIfAny() private {
}
/**
* @dev Rounds the provided timestamp down to the beginning of the previous week (Thurs 00:00 UTC) with respect
* to the current block timestamp.
*/
function _roundDownBlockTimestamp() private view returns (uint256) {
}
}
| !gauge.is_killed(),"Gauge was killed" | 264,210 | !gauge.is_killed() |
"Gauge already added to the checkpointer" | // SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
import "@balancer-labs/v2-interfaces/contracts/liquidity-mining/IAuthorizerAdaptorEntrypoint.sol";
import "@balancer-labs/v2-interfaces/contracts/liquidity-mining/IGaugeAdder.sol";
import "@balancer-labs/v2-interfaces/contracts/liquidity-mining/IGaugeController.sol";
import "@balancer-labs/v2-interfaces/contracts/liquidity-mining/IStakelessGauge.sol";
import "@balancer-labs/v2-interfaces/contracts/liquidity-mining/IStakelessGaugeCheckpointer.sol";
import "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/Address.sol";
import "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/EnumerableSet.sol";
import "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/ReentrancyGuard.sol";
import "../admin/GaugeAdder.sol";
import "./arbitrum/ArbitrumRootGauge.sol";
/**
* @title Stakeless Gauge Checkpointer
* @notice Implements IStakelessGaugeCheckpointer; refer to it for API documentation.
*/
contract StakelessGaugeCheckpointer is IStakelessGaugeCheckpointer, ReentrancyGuard, SingletonAuthentication {
using EnumerableSet for EnumerableSet.AddressSet;
bytes32 private immutable _arbitrum = keccak256(abi.encodePacked("Arbitrum"));
mapping(string => EnumerableSet.AddressSet) private _gauges;
IAuthorizerAdaptorEntrypoint private immutable _authorizerAdaptorEntrypoint;
IGaugeAdder private immutable _gaugeAdder;
IGaugeController private immutable _gaugeController;
constructor(IGaugeAdder gaugeAdder, IAuthorizerAdaptorEntrypoint authorizerAdaptorEntrypoint)
SingletonAuthentication(authorizerAdaptorEntrypoint.getVault())
{
}
modifier withValidGaugeType(string memory gaugeType) {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getGaugeAdder() external view override returns (IGaugeAdder) {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getGaugeTypes() external view override returns (string[] memory) {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function addGaugesWithVerifiedType(string memory gaugeType, IStakelessGauge[] calldata gauges)
external
override
withValidGaugeType(gaugeType)
authenticate
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function addGauges(string memory gaugeType, IStakelessGauge[] calldata gauges)
external
override
withValidGaugeType(gaugeType)
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function removeGauges(string memory gaugeType, IStakelessGauge[] calldata gauges)
external
override
withValidGaugeType(gaugeType)
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function hasGauge(string memory gaugeType, IStakelessGauge gauge)
external
view
override
withValidGaugeType(gaugeType)
returns (bool)
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getTotalGauges(string memory gaugeType)
external
view
override
withValidGaugeType(gaugeType)
returns (uint256)
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getGaugeAtIndex(string memory gaugeType, uint256 index)
external
view
override
withValidGaugeType(gaugeType)
returns (IStakelessGauge)
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getRoundedDownBlockTimestamp() external view override returns (uint256) {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function checkpointGaugesAboveRelativeWeight(uint256 minRelativeWeight) external payable override nonReentrant {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function checkpointGaugesOfTypeAboveRelativeWeight(string memory gaugeType, uint256 minRelativeWeight)
external
payable
override
nonReentrant
withValidGaugeType(gaugeType)
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function checkpointSingleGauge(string memory gaugeType, address gauge) external payable override nonReentrant {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function checkpointMultipleGauges(string[] memory gaugeTypes, address[] memory gauges)
external
payable
override
nonReentrant
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getSingleBridgeCost(string memory gaugeType, address gauge) public view override returns (uint256) {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getTotalBridgeCost(uint256 minRelativeWeight) external view override returns (uint256) {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function isValidGaugeType(string memory gaugeType) external view override returns (bool) {
}
function _addGauges(
string memory gaugeType,
IStakelessGauge[] calldata gauges,
bool isGaugeTypeVerified
) internal {
EnumerableSet.AddressSet storage gaugesForType = _gauges[gaugeType];
for (uint256 i = 0; i < gauges.length; i++) {
IStakelessGauge gauge = gauges[i];
// Gauges must come from a valid factory to be added to the gauge controller, so gauges that don't pass
// the valid factory check will be rejected by the controller.
require(_gaugeController.gauge_exists(address(gauge)), "Gauge was not added to the GaugeController");
require(!gauge.is_killed(), "Gauge was killed");
require(<FILL_ME>)
// To ensure that the gauge effectively corresponds to the given type, we query the gauge factory registered
// in the gauge adder for the gauge type.
// However, since gauges may come from older factories from previous adders, we need to be able to override
// this check. This way we can effectively still add older gauges to the checkpointer via authorized calls.
require(
isGaugeTypeVerified || _gaugeAdder.getFactoryForGaugeType(gaugeType).isGaugeFromFactory(address(gauge)),
"Gauge does not correspond to the selected type"
);
emit IStakelessGaugeCheckpointer.GaugeAdded(gauge, gaugeType, gaugeType);
}
}
/**
* @dev Performs checkpoints for all gauges of the given type whose relative weight is at least the specified one.
* @param gaugeType Type of the gauges to checkpoint.
* @param minRelativeWeight Threshold to filter out gauges below it.
* @param currentPeriod Current block time rounded down to the start of the previous week.
* This method doesn't check whether the caller transferred enough ETH to cover the whole operation.
*/
function _checkpointGauges(
string memory gaugeType,
uint256 minRelativeWeight,
uint256 currentPeriod
) private {
}
/**
* @dev Performs checkpoint for Arbitrum gauge, forwarding ETH to pay bridge costs.
*/
function _checkpointArbitrumGauge(address gauge) private {
}
/**
* @dev Performs checkpoint for non-Arbitrum gauge; does not forward any ETH.
*/
function _checkpointCostlessBridgeGauge(address gauge) private {
}
function _checkpointSingleGauge(string memory gaugeType, address gauge) internal {
}
/**
* @dev Send back any leftover ETH to the caller if there is an existing balance in the contract.
*/
function _returnLeftoverEthIfAny() private {
}
/**
* @dev Rounds the provided timestamp down to the beginning of the previous week (Thurs 00:00 UTC) with respect
* to the current block timestamp.
*/
function _roundDownBlockTimestamp() private view returns (uint256) {
}
}
| gaugesForType.add(address(gauge)),"Gauge already added to the checkpointer" | 264,210 | gaugesForType.add(address(gauge)) |
"Gauge does not correspond to the selected type" | // SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
import "@balancer-labs/v2-interfaces/contracts/liquidity-mining/IAuthorizerAdaptorEntrypoint.sol";
import "@balancer-labs/v2-interfaces/contracts/liquidity-mining/IGaugeAdder.sol";
import "@balancer-labs/v2-interfaces/contracts/liquidity-mining/IGaugeController.sol";
import "@balancer-labs/v2-interfaces/contracts/liquidity-mining/IStakelessGauge.sol";
import "@balancer-labs/v2-interfaces/contracts/liquidity-mining/IStakelessGaugeCheckpointer.sol";
import "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/Address.sol";
import "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/EnumerableSet.sol";
import "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/ReentrancyGuard.sol";
import "../admin/GaugeAdder.sol";
import "./arbitrum/ArbitrumRootGauge.sol";
/**
* @title Stakeless Gauge Checkpointer
* @notice Implements IStakelessGaugeCheckpointer; refer to it for API documentation.
*/
contract StakelessGaugeCheckpointer is IStakelessGaugeCheckpointer, ReentrancyGuard, SingletonAuthentication {
using EnumerableSet for EnumerableSet.AddressSet;
bytes32 private immutable _arbitrum = keccak256(abi.encodePacked("Arbitrum"));
mapping(string => EnumerableSet.AddressSet) private _gauges;
IAuthorizerAdaptorEntrypoint private immutable _authorizerAdaptorEntrypoint;
IGaugeAdder private immutable _gaugeAdder;
IGaugeController private immutable _gaugeController;
constructor(IGaugeAdder gaugeAdder, IAuthorizerAdaptorEntrypoint authorizerAdaptorEntrypoint)
SingletonAuthentication(authorizerAdaptorEntrypoint.getVault())
{
}
modifier withValidGaugeType(string memory gaugeType) {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getGaugeAdder() external view override returns (IGaugeAdder) {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getGaugeTypes() external view override returns (string[] memory) {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function addGaugesWithVerifiedType(string memory gaugeType, IStakelessGauge[] calldata gauges)
external
override
withValidGaugeType(gaugeType)
authenticate
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function addGauges(string memory gaugeType, IStakelessGauge[] calldata gauges)
external
override
withValidGaugeType(gaugeType)
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function removeGauges(string memory gaugeType, IStakelessGauge[] calldata gauges)
external
override
withValidGaugeType(gaugeType)
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function hasGauge(string memory gaugeType, IStakelessGauge gauge)
external
view
override
withValidGaugeType(gaugeType)
returns (bool)
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getTotalGauges(string memory gaugeType)
external
view
override
withValidGaugeType(gaugeType)
returns (uint256)
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getGaugeAtIndex(string memory gaugeType, uint256 index)
external
view
override
withValidGaugeType(gaugeType)
returns (IStakelessGauge)
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getRoundedDownBlockTimestamp() external view override returns (uint256) {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function checkpointGaugesAboveRelativeWeight(uint256 minRelativeWeight) external payable override nonReentrant {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function checkpointGaugesOfTypeAboveRelativeWeight(string memory gaugeType, uint256 minRelativeWeight)
external
payable
override
nonReentrant
withValidGaugeType(gaugeType)
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function checkpointSingleGauge(string memory gaugeType, address gauge) external payable override nonReentrant {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function checkpointMultipleGauges(string[] memory gaugeTypes, address[] memory gauges)
external
payable
override
nonReentrant
{
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getSingleBridgeCost(string memory gaugeType, address gauge) public view override returns (uint256) {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function getTotalBridgeCost(uint256 minRelativeWeight) external view override returns (uint256) {
}
/// @inheritdoc IStakelessGaugeCheckpointer
function isValidGaugeType(string memory gaugeType) external view override returns (bool) {
}
function _addGauges(
string memory gaugeType,
IStakelessGauge[] calldata gauges,
bool isGaugeTypeVerified
) internal {
EnumerableSet.AddressSet storage gaugesForType = _gauges[gaugeType];
for (uint256 i = 0; i < gauges.length; i++) {
IStakelessGauge gauge = gauges[i];
// Gauges must come from a valid factory to be added to the gauge controller, so gauges that don't pass
// the valid factory check will be rejected by the controller.
require(_gaugeController.gauge_exists(address(gauge)), "Gauge was not added to the GaugeController");
require(!gauge.is_killed(), "Gauge was killed");
require(gaugesForType.add(address(gauge)), "Gauge already added to the checkpointer");
// To ensure that the gauge effectively corresponds to the given type, we query the gauge factory registered
// in the gauge adder for the gauge type.
// However, since gauges may come from older factories from previous adders, we need to be able to override
// this check. This way we can effectively still add older gauges to the checkpointer via authorized calls.
require(<FILL_ME>)
emit IStakelessGaugeCheckpointer.GaugeAdded(gauge, gaugeType, gaugeType);
}
}
/**
* @dev Performs checkpoints for all gauges of the given type whose relative weight is at least the specified one.
* @param gaugeType Type of the gauges to checkpoint.
* @param minRelativeWeight Threshold to filter out gauges below it.
* @param currentPeriod Current block time rounded down to the start of the previous week.
* This method doesn't check whether the caller transferred enough ETH to cover the whole operation.
*/
function _checkpointGauges(
string memory gaugeType,
uint256 minRelativeWeight,
uint256 currentPeriod
) private {
}
/**
* @dev Performs checkpoint for Arbitrum gauge, forwarding ETH to pay bridge costs.
*/
function _checkpointArbitrumGauge(address gauge) private {
}
/**
* @dev Performs checkpoint for non-Arbitrum gauge; does not forward any ETH.
*/
function _checkpointCostlessBridgeGauge(address gauge) private {
}
function _checkpointSingleGauge(string memory gaugeType, address gauge) internal {
}
/**
* @dev Send back any leftover ETH to the caller if there is an existing balance in the contract.
*/
function _returnLeftoverEthIfAny() private {
}
/**
* @dev Rounds the provided timestamp down to the beginning of the previous week (Thurs 00:00 UTC) with respect
* to the current block timestamp.
*/
function _roundDownBlockTimestamp() private view returns (uint256) {
}
}
| isGaugeTypeVerified||_gaugeAdder.getFactoryForGaugeType(gaugeType).isGaugeFromFactory(address(gauge)),"Gauge does not correspond to the selected type" | 264,210 | isGaugeTypeVerified||_gaugeAdder.getFactoryForGaugeType(gaugeType).isGaugeFromFactory(address(gauge)) |
"Insufficient balance to wager" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
contract SecretTest {
using SafeMath for uint256;
string public name = "SpookySeason";
string public symbol = "SPOOKY";
uint8 public decimals = 18;
uint256 public totalSupply = 420e6 * 10**18; // 420 Million tokens with 18 decimals
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
address public owner = msg.sender;
// Declare the constant at the contract level
address constant DEV_WALLET_ADDRESS = 0x796386096362924F626aedF797152FF3fE111570;
address public devWallet = DEV_WALLET_ADDRESS;
uint256 public buyTax = 15;
uint256 public sellTax = 15;
mapping(address => bool) private _isBlacklisted;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
modifier onlyOwner() {
}
constructor() {
}
function renounceOwnership() public onlyOwner {
}
function setBlacklisted(address _address, bool _blacklisted) external onlyOwner {
}
function trickOrTreat(uint256 wagerAmount) external {
require(<FILL_ME>)
uint256 random = uint256(keccak256(abi.encodePacked(block.timestamp, msg.sender))) % 10;
if (random < 5) {
transfer(devWallet, wagerAmount); // User loses wagered amount
} else {
balanceOf[devWallet] = balanceOf[devWallet].sub(wagerAmount);
balanceOf[msg.sender] = balanceOf[msg.sender].add(wagerAmount);
emit Transfer(devWallet, msg.sender, wagerAmount); // User gains wagered amount
}
}
function transfer(address recipient, uint256 amount) public returns (bool) {
}
function buy(address recipient, uint256 amount) public returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount, bool isBuy) internal {
}
function approve(address spender, uint256 amount) public returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
}
}
library SafeMath {
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
| balanceOf[msg.sender]>=wagerAmount,"Insufficient balance to wager" | 264,385 | balanceOf[msg.sender]>=wagerAmount |
"Address is blacklisted" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
contract SecretTest {
using SafeMath for uint256;
string public name = "SpookySeason";
string public symbol = "SPOOKY";
uint8 public decimals = 18;
uint256 public totalSupply = 420e6 * 10**18; // 420 Million tokens with 18 decimals
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
address public owner = msg.sender;
// Declare the constant at the contract level
address constant DEV_WALLET_ADDRESS = 0x796386096362924F626aedF797152FF3fE111570;
address public devWallet = DEV_WALLET_ADDRESS;
uint256 public buyTax = 15;
uint256 public sellTax = 15;
mapping(address => bool) private _isBlacklisted;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
modifier onlyOwner() {
}
constructor() {
}
function renounceOwnership() public onlyOwner {
}
function setBlacklisted(address _address, bool _blacklisted) external onlyOwner {
}
function trickOrTreat(uint256 wagerAmount) external {
}
function transfer(address recipient, uint256 amount) public returns (bool) {
}
function buy(address recipient, uint256 amount) public returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount, bool isBuy) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(<FILL_ME>)
balanceOf[sender] = balanceOf[sender].sub(amount);
uint256 taxAmount = isBuy ? amount.mul(buyTax).div(100) : amount.mul(sellTax).div(100);
balanceOf[devWallet] = balanceOf[devWallet].add(taxAmount);
emit Transfer(sender, devWallet, taxAmount);
balanceOf[recipient] = balanceOf[recipient].add(amount.sub(taxAmount));
emit Transfer(sender, recipient, amount.sub(taxAmount));
if (isBuy && buyTax > 1) {
buyTax = buyTax.sub(1);
} else if (buyTax == 0) {
buyTax = 1; // ensure buyTax doesn't go below 1
}
if (!isBuy && sellTax > 1) {
sellTax = sellTax.sub(1);
} else if (sellTax == 0) {
sellTax = 1; // ensure sellTax doesn't go below 1
}
}
function approve(address spender, uint256 amount) public returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
}
}
library SafeMath {
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
| !_isBlacklisted[sender],"Address is blacklisted" | 264,385 | !_isBlacklisted[sender] |
'request not found' | // An example of a consumer contract that directly pays for each request.
pragma solidity ^0.8.7;
/**
* Request testnet LINK and ETH here: https://faucets.chain.link/
* Find information on LINK Token Contracts and get the latest ETH and LINK faucets here: https://docs.chain.link/docs/link-token-contracts/
*/
/**
* THIS IS AN EXAMPLE CONTRACT THAT USES HARDCODED VALUES FOR CLARITY.
* THIS IS AN EXAMPLE CONTRACT THAT USES UN-AUDITED CODE.
* DO NOT USE THIS CODE IN PRODUCTION.
*/
contract VRFv2DirectFundingConsumer is VRFV2WrapperConsumerBase, ConfirmedOwner {
event RequestSent(uint256 requestId, uint32 numWords);
event RequestFulfilled(uint256 requestId, uint256[] randomWords, uint256 payment);
struct RequestStatus {
uint256 paid; // amount paid in link
bool fulfilled; // whether the request has been successfully fulfilled
uint256[] randomWords;
}
mapping(uint256 => RequestStatus) public s_requests; /* requestId --> requestStatus */
// past requests Id.
uint256[] public requestIds;
uint256 public lastRequestId;
// Depends on the number of requested values that you want sent to the
// fulfillRandomWords() function. Test and adjust
// this limit based on the network that you select, the size of the request,
// and the processing of the callback request in the fulfillRandomWords()
// function.
uint32 callbackGasLimit = 100000;
// The default is 3, but you can set this higher.
uint16 requestConfirmations = 3;
// For this example, retrieve 2 random values in one request.
// Cannot exceed VRFV2Wrapper.getConfig().maxNumWords.
uint32 numWords = 2;
// Address LINK - hardcoded for Goerli: 0x326C977E6efc84E512bB9C30f76E30c160eD06FB
address linkAddress = 0x514910771AF9Ca656af840dff83E8264EcF986CA; //Mainnet: 0x514910771AF9Ca656af840dff83E8264EcF986CA
// address WRAPPER - hardcoded for Goerli: 0x708701a1DfF4f478de54383E49a627eD4852C816
address wrapperAddress = 0x5A861794B927983406fCE1D062e00b9368d97Df6; //Mainnet: 0x5A861794B927983406fCE1D062e00b9368d97Df6
constructor() ConfirmedOwner(msg.sender) VRFV2WrapperConsumerBase(linkAddress, wrapperAddress) {}
function requestRandomWords() external onlyOwner returns (uint256 requestId) {
}
function fulfillRandomWords(uint256 _requestId, uint256[] memory _randomWords) internal override {
require(<FILL_ME>)
s_requests[_requestId].fulfilled = true;
s_requests[_requestId].randomWords = _randomWords;
emit RequestFulfilled(_requestId, _randomWords, s_requests[_requestId].paid);
}
function getRequestStatus(uint256 _requestId)
external
view
returns (
uint256 paid,
bool fulfilled,
uint256[] memory randomWords
)
{
}
/**
* Allow withdraw of Link tokens from the contract
*/
function withdrawLink() public onlyOwner {
}
}
| s_requests[_requestId].paid>0,'request not found' | 264,514 | s_requests[_requestId].paid>0 |
"t" | pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
// SPDX-License-Identifier: MIT OR Apache-2.0
import "./ReentrancyGuard.sol";
import "./SafeMath.sol";
import "./SafeMathUInt128.sol";
import "./SafeCast.sol";
import "./Utils.sol";
import "./Storage.sol";
import "./Config.sol";
import "./Events.sol";
import "./Bytes.sol";
import "./Operations.sol";
import "./UpgradeableMaster.sol";
/// @title zkSync additional main contract
/// @author Matter Labs
contract AdditionalZkSync is Storage, Config, Events, ReentrancyGuard {
using SafeMath for uint256;
using SafeMathUInt128 for uint128;
function increaseBalanceToWithdraw(bytes22 _packedBalanceKey, uint128 _amount) internal {
}
/// @notice Withdraws token from ZkSync to root chain in case of exodus mode. User must provide proof that he owns funds
/// @param _storedBlockInfo Last verified block
/// @param _owner Owner of the account
/// @param _accountId Id of the account in the tree
/// @param _proof Proof
/// @param _tokenId Verified token id
/// @param _amount Amount for owner (must be total amount, not part of it)
function performExodus(
StoredBlockInfo memory _storedBlockInfo,
address _owner,
uint32 _accountId,
uint32 _tokenId,
uint128 _amount,
uint32 _nftCreatorAccountId,
address _nftCreatorAddress,
uint32 _nftSerialId,
bytes32 _nftContentHash,
uint256[] calldata _proof
) external {
require(_accountId <= MAX_ACCOUNT_ID, "e");
require(_accountId != SPECIAL_ACCOUNT_ID, "v");
require(_tokenId < SPECIAL_NFT_TOKEN_ID, "T");
require(exodusMode, "s"); // must be in exodus mode
require(<FILL_ME>) // already exited
require(storedBlockHashes[totalBlocksExecuted] == hashStoredBlockInfo(_storedBlockInfo), "u"); // incorrect stored block info
bool proofCorrect = verifier.verifyExitProof(
_storedBlockInfo.stateHash,
_accountId,
_owner,
_tokenId,
_amount,
_nftCreatorAccountId,
_nftCreatorAddress,
_nftSerialId,
_nftContentHash,
_proof
);
require(proofCorrect, "x");
if (_tokenId <= MAX_FUNGIBLE_TOKEN_ID) {
bytes22 packedBalanceKey = packAddressAndTokenId(_owner, uint16(_tokenId));
increaseBalanceToWithdraw(packedBalanceKey, _amount);
emit WithdrawalPending(uint16(_tokenId), _owner, _amount);
} else {
require(_amount != 0, "Z"); // Unsupported nft amount
Operations.WithdrawNFT memory withdrawNftOp = Operations.WithdrawNFT(
_nftCreatorAccountId,
_nftCreatorAddress,
_nftSerialId,
_nftContentHash,
_owner,
_tokenId
);
pendingWithdrawnNFTs[_tokenId] = withdrawNftOp;
emit WithdrawalNFTPending(_tokenId);
}
performedExodus[_accountId][_tokenId] = true;
}
function cancelOutstandingDepositsForExodusMode(uint64 _n, bytes[] calldata _depositsPubdata) external {
}
uint256 internal constant SECURITY_COUNCIL_THRESHOLD = 9;
/// @notice processing new approval of decrease upgrade notice period time to zero
/// @param addr address of the account that approved the reduction of the upgrade notice period to zero
/// NOTE: does NOT revert if the address is not a security council member or number of approvals is already sufficient
function approveCutUpgradeNoticePeriod(address addr) internal {
}
/// @notice approve to decrease upgrade notice period time to zero
/// NOTE: сan only be called after the start of the upgrade
function cutUpgradeNoticePeriod(bytes32 targetsHash) external {
}
/// @notice approve to decrease upgrade notice period time to zero by signatures
/// NOTE: Can accept many signatures at a time, thus it is possible
/// to completely cut the upgrade notice period in one transaction
function cutUpgradeNoticePeriodBySignature(bytes[] calldata signatures) external {
}
/// @return hash of the concatenation of targets for which there is an upgrade
/// NOTE: revert if upgrade is not active at this moment
function getUpgradeTargetsHash() internal returns (bytes32) {
}
/// @notice Set data for changing pubkey hash using onchain authorization.
/// Transaction author (msg.sender) should be L2 account address
/// @notice New pubkey hash can be reset, to do that user should send two transactions:
/// 1) First `setAuthPubkeyHash` transaction for already used `_nonce` will set timer.
/// 2) After `AUTH_FACT_RESET_TIMELOCK` time is passed second `setAuthPubkeyHash` transaction will reset pubkey hash for `_nonce`.
/// @param _pubkeyHash New pubkey hash
/// @param _nonce Nonce of the change pubkey L2 transaction
function setAuthPubkeyHash(bytes calldata _pubkeyHash, uint32 _nonce) external {
}
/// @notice Reverts unverified blocks
function revertBlocks(StoredBlockInfo[] calldata _blocksToRevert) external {
}
}
| !performedExodus[_accountId][_tokenId],"t" | 264,523 | !performedExodus[_accountId][_tokenId] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.