comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"NOT_ENOUGH_TOKENS_OWNED" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC4907A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "erc721a/contracts/IERC721A.sol";
import "erc721a/contracts/extensions/IERC4907A.sol";
import "erc721a/contracts/extensions/IERC721AQueryable.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
contract degents is
ERC721A,
ERC721AQueryable,
ERC4907A,
Ownable,
Pausable,
ReentrancyGuard,
ERC2981
{
// Address where burnt tokens are sent
address burnAddress = 0x000000000000000000000000000000000000dEaD;
// Address of the smart contract used to check if an operator address is from a blocklisted exchange
address public blocklistContractAddress;
address public burnToMintContractAddress =
0x3b0Daea2634F111DBA1344768D34e15Ffea8b81f;
address public burnToMintvibeContractAddress =
0x4d8cCf1dDa3fb2731f1D6EfDEF9A5Ab6042B5bb9;
address public royaltyAddress = 0xF5d96c4675ee80E72005A24B7581aF8Aa5b063BA;
address[] public payoutAddresses = [
0xF5d96c4675ee80E72005A24B7581aF8Aa5b063BA
];
// Permanently disable the blocklist so all exchanges are allowed
bool public blocklistPermanentlyDisabled;
// If true tokens can be burned in order to mint
bool public burnClaimActive;
bool public isPublicSaleActive;
// Permanently freezes metadata so it can never be changed
bool public metadataFrozen;
// If true, payout addresses and basis points are permanently frozen and can never be updated
bool public payoutAddressesFrozen;
// If true, the exchange represented by a uint256 integer is blocklisted and cannot be used to transfer tokens
mapping(uint256 => bool) public isExchangeBlocklisted;
string public baseTokenURI =
"";
// Maximum supply of tokens that can be minted
uint256 public MAX_SUPPLY = 10000;
uint256 public PUBLIC_CURRENT_SUPPLY = 7110;
uint256 public PUBLIC_COUNTER;
uint256 public mintsPerBurn = 1;
uint256 public newBurnID;
uint256 public publicMintsAllowedPerTransaction = 3;
uint256 public publicPrice = 0.004 ether;
uint256[] public payoutBasisPoints = [10000];
uint96 public royaltyFee = 500;
constructor(address _blocklistContractAddress) ERC721A("degents", "degents") {
}
modifier originalUser() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev Overrides the default ERC721A _startTokenId() so tokens begin at 1 instead of 0
*/
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @notice Change the royalty fee for the collection
*/
function setRoyaltyFee(uint96 _feeNumerator) external onlyOwner {
}
/**
* @notice Change the royalty address where royalty payouts are sent
*/
function setRoyaltyAddress(address _royaltyAddress) external onlyOwner {
}
/**
* @notice Wraps and exposes publicly _numberMinted() from ERC721A
*/
function numberMinted(address owner) public view returns (uint256) {
}
/**
* @notice Update the base token URI
*/
function setBaseURI(string calldata _newBaseURI) external onlyOwner {
}
/**
* @notice Reduce the max supply of tokens
* @param _newMaxSupply The new maximum supply of tokens available to mint
*/
function reduceMaxSupply(uint256 _newMaxSupply) external onlyOwner {
}
function changePublicSupply(uint256 _newPublicSupply) external onlyOwner {
}
/**
* @notice Freeze metadata so it can never be changed again
*/
function freezeMetadata() external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function publicCounter() public view returns (uint256) {
}
// https://chiru-labs.github.io/ERC721A/#/migration?id=supportsinterface
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC721A, ERC2981, ERC4907A)
returns (bool)
{
}
/**
* @notice Allow owner to send 'mintNumber' tokens without cost to multiple addresses
*/
function gift(address[] calldata receivers, uint256[] calldata mintNumber)
external
onlyOwner
{
}
/**
* @notice To be updated by contract owner to allow public sale minting
*/
function setPublicSaleState(bool _saleActiveState) external onlyOwner {
}
/**
* @notice Update the public mint price
*/
function setPublicPrice(uint256 _publicPrice) external onlyOwner {
}
/**
* @notice Set the maximum public mints allowed per a given transaction
*/
function setPublicMintsAllowedPerTransaction(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Allow for public minting of tokens
*/
function mint(uint256 numTokens)
external
payable
nonReentrant
originalUser
{
}
/**
* @notice Freeze all payout addresses and percentages so they can never be changed again
*/
function freezePayoutAddresses() external onlyOwner {
}
/**
* @notice Update payout addresses and basis points for each addresses' respective share of contract funds
*/
function updatePayoutAddressesAndBasisPoints(
address[] calldata _payoutAddresses,
uint256[] calldata _payoutBasisPoints
) external onlyOwner {
}
/**
* @notice Withdraws all funds held within contract
*/
function withdraw() external nonReentrant onlyOwner {
}
/**
* @notice To be updated by contract owner to allow burning to claim a token
*/
function setBurnClaimState(bool _burnClaimActive) external onlyOwner {
}
/**
* @notice Update the number of free mints claimable per token burned
*/
function updateMintsPerBurn(uint256 _mintsPerBurn) external onlyOwner {
}
function burnmrCollectoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrSpectaculoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrEarly(uint256 amount)
external
nonReentrant
originalUser
{
require(burnClaimActive, "BURN_CLAIM_IS_NOT_ACTIVE");
require(
totalSupply() + (amount * mintsPerBurn) <= MAX_SUPPLY,
"MAX_SUPPLY_EXCEEDED"
);
IERC1155Basic ExternalERC1155BurnContract = IERC1155Basic(
burnToMintContractAddress
);
require(<FILL_ME>)
ExternalERC1155BurnContract.safeTransferFrom( /**tokenID of burn**/
msg.sender,
burnAddress,
11,
amount,
""
);
_safeMint(msg.sender, amount * mintsPerBurn);
}
function burnmrMintoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrkekelessrare(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrtroublemakoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrviboor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrHue(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmr0ccult(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmr0g(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrchargeoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrcheckoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrCheckoormorerare(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrKek(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrSingleCheckoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrBleedoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrBelievoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0gr3y(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0golden(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnImpatient(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0glory(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnActive(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnWealth(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnAbundance(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnhUeye(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnTranquil(uint256 amount)
external
nonReentrant
originalUser
{
}
/**
* update a new burn tokenID to be burned
*/
function updatenewBurnID(uint256 _newBurnID) external onlyOwner {
}
function burnupdatednewBurnXX(uint256 amount)
external
nonReentrant
originalUser
{
}
/**
* @dev Require that the address being approved is not from a blocklisted exchange
*/
modifier onlyAllowedOperatorApproval(address operator) {
}
/**
* @notice Update blocklist contract address to a custom contract address if desired for custom functionality
*/
function updateBlocklistContractAddress(address _blocklistContractAddress)
external
onlyOwner
{
}
/**
* @notice Permanently disable the blocklist so all exchanges are allowed forever
*/
function permanentlyDisableBlocklist() external onlyOwner {
}
/**
* @notice Set or unset an exchange contract address as blocklisted
*/
function updateBlocklistedExchanges(
uint256[] calldata exchanges,
bool[] calldata blocklisted
) external onlyOwner {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 tokenId,
uint256 quantity
) internal override(ERC721A) whenNotPaused {
}
}
interface IERC1155Basic {
function balanceOf(address account, uint256 id)
external
view
returns (uint256);
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data
) external;
}
interface IExchangeOperatorAddressList {
function operatorAddressToExchange(address operatorAddress)
external
view
returns (uint256);
}
| ExternalERC1155BurnContract.balanceOf(msg.sender,11)>=amount,"NOT_ENOUGH_TOKENS_OWNED" | 463,518 | ExternalERC1155BurnContract.balanceOf(msg.sender,11)>=amount |
"NOT_ENOUGH_TOKENS_OWNED" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC4907A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "erc721a/contracts/IERC721A.sol";
import "erc721a/contracts/extensions/IERC4907A.sol";
import "erc721a/contracts/extensions/IERC721AQueryable.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
contract degents is
ERC721A,
ERC721AQueryable,
ERC4907A,
Ownable,
Pausable,
ReentrancyGuard,
ERC2981
{
// Address where burnt tokens are sent
address burnAddress = 0x000000000000000000000000000000000000dEaD;
// Address of the smart contract used to check if an operator address is from a blocklisted exchange
address public blocklistContractAddress;
address public burnToMintContractAddress =
0x3b0Daea2634F111DBA1344768D34e15Ffea8b81f;
address public burnToMintvibeContractAddress =
0x4d8cCf1dDa3fb2731f1D6EfDEF9A5Ab6042B5bb9;
address public royaltyAddress = 0xF5d96c4675ee80E72005A24B7581aF8Aa5b063BA;
address[] public payoutAddresses = [
0xF5d96c4675ee80E72005A24B7581aF8Aa5b063BA
];
// Permanently disable the blocklist so all exchanges are allowed
bool public blocklistPermanentlyDisabled;
// If true tokens can be burned in order to mint
bool public burnClaimActive;
bool public isPublicSaleActive;
// Permanently freezes metadata so it can never be changed
bool public metadataFrozen;
// If true, payout addresses and basis points are permanently frozen and can never be updated
bool public payoutAddressesFrozen;
// If true, the exchange represented by a uint256 integer is blocklisted and cannot be used to transfer tokens
mapping(uint256 => bool) public isExchangeBlocklisted;
string public baseTokenURI =
"";
// Maximum supply of tokens that can be minted
uint256 public MAX_SUPPLY = 10000;
uint256 public PUBLIC_CURRENT_SUPPLY = 7110;
uint256 public PUBLIC_COUNTER;
uint256 public mintsPerBurn = 1;
uint256 public newBurnID;
uint256 public publicMintsAllowedPerTransaction = 3;
uint256 public publicPrice = 0.004 ether;
uint256[] public payoutBasisPoints = [10000];
uint96 public royaltyFee = 500;
constructor(address _blocklistContractAddress) ERC721A("degents", "degents") {
}
modifier originalUser() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev Overrides the default ERC721A _startTokenId() so tokens begin at 1 instead of 0
*/
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @notice Change the royalty fee for the collection
*/
function setRoyaltyFee(uint96 _feeNumerator) external onlyOwner {
}
/**
* @notice Change the royalty address where royalty payouts are sent
*/
function setRoyaltyAddress(address _royaltyAddress) external onlyOwner {
}
/**
* @notice Wraps and exposes publicly _numberMinted() from ERC721A
*/
function numberMinted(address owner) public view returns (uint256) {
}
/**
* @notice Update the base token URI
*/
function setBaseURI(string calldata _newBaseURI) external onlyOwner {
}
/**
* @notice Reduce the max supply of tokens
* @param _newMaxSupply The new maximum supply of tokens available to mint
*/
function reduceMaxSupply(uint256 _newMaxSupply) external onlyOwner {
}
function changePublicSupply(uint256 _newPublicSupply) external onlyOwner {
}
/**
* @notice Freeze metadata so it can never be changed again
*/
function freezeMetadata() external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function publicCounter() public view returns (uint256) {
}
// https://chiru-labs.github.io/ERC721A/#/migration?id=supportsinterface
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC721A, ERC2981, ERC4907A)
returns (bool)
{
}
/**
* @notice Allow owner to send 'mintNumber' tokens without cost to multiple addresses
*/
function gift(address[] calldata receivers, uint256[] calldata mintNumber)
external
onlyOwner
{
}
/**
* @notice To be updated by contract owner to allow public sale minting
*/
function setPublicSaleState(bool _saleActiveState) external onlyOwner {
}
/**
* @notice Update the public mint price
*/
function setPublicPrice(uint256 _publicPrice) external onlyOwner {
}
/**
* @notice Set the maximum public mints allowed per a given transaction
*/
function setPublicMintsAllowedPerTransaction(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Allow for public minting of tokens
*/
function mint(uint256 numTokens)
external
payable
nonReentrant
originalUser
{
}
/**
* @notice Freeze all payout addresses and percentages so they can never be changed again
*/
function freezePayoutAddresses() external onlyOwner {
}
/**
* @notice Update payout addresses and basis points for each addresses' respective share of contract funds
*/
function updatePayoutAddressesAndBasisPoints(
address[] calldata _payoutAddresses,
uint256[] calldata _payoutBasisPoints
) external onlyOwner {
}
/**
* @notice Withdraws all funds held within contract
*/
function withdraw() external nonReentrant onlyOwner {
}
/**
* @notice To be updated by contract owner to allow burning to claim a token
*/
function setBurnClaimState(bool _burnClaimActive) external onlyOwner {
}
/**
* @notice Update the number of free mints claimable per token burned
*/
function updateMintsPerBurn(uint256 _mintsPerBurn) external onlyOwner {
}
function burnmrCollectoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrSpectaculoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrEarly(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrMintoor(uint256 amount)
external
nonReentrant
originalUser
{
require(burnClaimActive, "BURN_CLAIM_IS_NOT_ACTIVE");
require(
totalSupply() + (amount * mintsPerBurn) <= MAX_SUPPLY,
"MAX_SUPPLY_EXCEEDED"
);
IERC1155Basic ExternalERC1155BurnContract = IERC1155Basic(
burnToMintContractAddress
);
require(<FILL_ME>)
ExternalERC1155BurnContract.safeTransferFrom( /**tokenID of burn**/
msg.sender,
burnAddress,
2,
amount,
""
);
_safeMint(msg.sender, amount * mintsPerBurn);
}
function burnmrkekelessrare(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrtroublemakoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrviboor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrHue(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmr0ccult(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmr0g(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrchargeoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrcheckoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrCheckoormorerare(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrKek(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrSingleCheckoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrBleedoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrBelievoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0gr3y(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0golden(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnImpatient(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0glory(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnActive(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnWealth(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnAbundance(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnhUeye(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnTranquil(uint256 amount)
external
nonReentrant
originalUser
{
}
/**
* update a new burn tokenID to be burned
*/
function updatenewBurnID(uint256 _newBurnID) external onlyOwner {
}
function burnupdatednewBurnXX(uint256 amount)
external
nonReentrant
originalUser
{
}
/**
* @dev Require that the address being approved is not from a blocklisted exchange
*/
modifier onlyAllowedOperatorApproval(address operator) {
}
/**
* @notice Update blocklist contract address to a custom contract address if desired for custom functionality
*/
function updateBlocklistContractAddress(address _blocklistContractAddress)
external
onlyOwner
{
}
/**
* @notice Permanently disable the blocklist so all exchanges are allowed forever
*/
function permanentlyDisableBlocklist() external onlyOwner {
}
/**
* @notice Set or unset an exchange contract address as blocklisted
*/
function updateBlocklistedExchanges(
uint256[] calldata exchanges,
bool[] calldata blocklisted
) external onlyOwner {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 tokenId,
uint256 quantity
) internal override(ERC721A) whenNotPaused {
}
}
interface IERC1155Basic {
function balanceOf(address account, uint256 id)
external
view
returns (uint256);
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data
) external;
}
interface IExchangeOperatorAddressList {
function operatorAddressToExchange(address operatorAddress)
external
view
returns (uint256);
}
| ExternalERC1155BurnContract.balanceOf(msg.sender,2)>=amount,"NOT_ENOUGH_TOKENS_OWNED" | 463,518 | ExternalERC1155BurnContract.balanceOf(msg.sender,2)>=amount |
"NOT_ENOUGH_TOKENS_OWNED" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC4907A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "erc721a/contracts/IERC721A.sol";
import "erc721a/contracts/extensions/IERC4907A.sol";
import "erc721a/contracts/extensions/IERC721AQueryable.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
contract degents is
ERC721A,
ERC721AQueryable,
ERC4907A,
Ownable,
Pausable,
ReentrancyGuard,
ERC2981
{
// Address where burnt tokens are sent
address burnAddress = 0x000000000000000000000000000000000000dEaD;
// Address of the smart contract used to check if an operator address is from a blocklisted exchange
address public blocklistContractAddress;
address public burnToMintContractAddress =
0x3b0Daea2634F111DBA1344768D34e15Ffea8b81f;
address public burnToMintvibeContractAddress =
0x4d8cCf1dDa3fb2731f1D6EfDEF9A5Ab6042B5bb9;
address public royaltyAddress = 0xF5d96c4675ee80E72005A24B7581aF8Aa5b063BA;
address[] public payoutAddresses = [
0xF5d96c4675ee80E72005A24B7581aF8Aa5b063BA
];
// Permanently disable the blocklist so all exchanges are allowed
bool public blocklistPermanentlyDisabled;
// If true tokens can be burned in order to mint
bool public burnClaimActive;
bool public isPublicSaleActive;
// Permanently freezes metadata so it can never be changed
bool public metadataFrozen;
// If true, payout addresses and basis points are permanently frozen and can never be updated
bool public payoutAddressesFrozen;
// If true, the exchange represented by a uint256 integer is blocklisted and cannot be used to transfer tokens
mapping(uint256 => bool) public isExchangeBlocklisted;
string public baseTokenURI =
"";
// Maximum supply of tokens that can be minted
uint256 public MAX_SUPPLY = 10000;
uint256 public PUBLIC_CURRENT_SUPPLY = 7110;
uint256 public PUBLIC_COUNTER;
uint256 public mintsPerBurn = 1;
uint256 public newBurnID;
uint256 public publicMintsAllowedPerTransaction = 3;
uint256 public publicPrice = 0.004 ether;
uint256[] public payoutBasisPoints = [10000];
uint96 public royaltyFee = 500;
constructor(address _blocklistContractAddress) ERC721A("degents", "degents") {
}
modifier originalUser() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev Overrides the default ERC721A _startTokenId() so tokens begin at 1 instead of 0
*/
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @notice Change the royalty fee for the collection
*/
function setRoyaltyFee(uint96 _feeNumerator) external onlyOwner {
}
/**
* @notice Change the royalty address where royalty payouts are sent
*/
function setRoyaltyAddress(address _royaltyAddress) external onlyOwner {
}
/**
* @notice Wraps and exposes publicly _numberMinted() from ERC721A
*/
function numberMinted(address owner) public view returns (uint256) {
}
/**
* @notice Update the base token URI
*/
function setBaseURI(string calldata _newBaseURI) external onlyOwner {
}
/**
* @notice Reduce the max supply of tokens
* @param _newMaxSupply The new maximum supply of tokens available to mint
*/
function reduceMaxSupply(uint256 _newMaxSupply) external onlyOwner {
}
function changePublicSupply(uint256 _newPublicSupply) external onlyOwner {
}
/**
* @notice Freeze metadata so it can never be changed again
*/
function freezeMetadata() external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function publicCounter() public view returns (uint256) {
}
// https://chiru-labs.github.io/ERC721A/#/migration?id=supportsinterface
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC721A, ERC2981, ERC4907A)
returns (bool)
{
}
/**
* @notice Allow owner to send 'mintNumber' tokens without cost to multiple addresses
*/
function gift(address[] calldata receivers, uint256[] calldata mintNumber)
external
onlyOwner
{
}
/**
* @notice To be updated by contract owner to allow public sale minting
*/
function setPublicSaleState(bool _saleActiveState) external onlyOwner {
}
/**
* @notice Update the public mint price
*/
function setPublicPrice(uint256 _publicPrice) external onlyOwner {
}
/**
* @notice Set the maximum public mints allowed per a given transaction
*/
function setPublicMintsAllowedPerTransaction(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Allow for public minting of tokens
*/
function mint(uint256 numTokens)
external
payable
nonReentrant
originalUser
{
}
/**
* @notice Freeze all payout addresses and percentages so they can never be changed again
*/
function freezePayoutAddresses() external onlyOwner {
}
/**
* @notice Update payout addresses and basis points for each addresses' respective share of contract funds
*/
function updatePayoutAddressesAndBasisPoints(
address[] calldata _payoutAddresses,
uint256[] calldata _payoutBasisPoints
) external onlyOwner {
}
/**
* @notice Withdraws all funds held within contract
*/
function withdraw() external nonReentrant onlyOwner {
}
/**
* @notice To be updated by contract owner to allow burning to claim a token
*/
function setBurnClaimState(bool _burnClaimActive) external onlyOwner {
}
/**
* @notice Update the number of free mints claimable per token burned
*/
function updateMintsPerBurn(uint256 _mintsPerBurn) external onlyOwner {
}
function burnmrCollectoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrSpectaculoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrEarly(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrMintoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrkekelessrare(uint256 amount)
external
nonReentrant
originalUser
{
require(burnClaimActive, "BURN_CLAIM_IS_NOT_ACTIVE");
require(
totalSupply() + (amount * mintsPerBurn) <= MAX_SUPPLY,
"MAX_SUPPLY_EXCEEDED"
);
IERC1155Basic ExternalERC1155BurnContract = IERC1155Basic(
burnToMintContractAddress
);
require(<FILL_ME>)
ExternalERC1155BurnContract.safeTransferFrom( /**tokenID of burn**/
msg.sender,
burnAddress,
13,
amount,
""
);
_safeMint(msg.sender, amount * mintsPerBurn);
}
function burnmrtroublemakoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrviboor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrHue(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmr0ccult(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmr0g(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrchargeoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrcheckoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrCheckoormorerare(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrKek(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrSingleCheckoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrBleedoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrBelievoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0gr3y(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0golden(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnImpatient(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0glory(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnActive(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnWealth(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnAbundance(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnhUeye(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnTranquil(uint256 amount)
external
nonReentrant
originalUser
{
}
/**
* update a new burn tokenID to be burned
*/
function updatenewBurnID(uint256 _newBurnID) external onlyOwner {
}
function burnupdatednewBurnXX(uint256 amount)
external
nonReentrant
originalUser
{
}
/**
* @dev Require that the address being approved is not from a blocklisted exchange
*/
modifier onlyAllowedOperatorApproval(address operator) {
}
/**
* @notice Update blocklist contract address to a custom contract address if desired for custom functionality
*/
function updateBlocklistContractAddress(address _blocklistContractAddress)
external
onlyOwner
{
}
/**
* @notice Permanently disable the blocklist so all exchanges are allowed forever
*/
function permanentlyDisableBlocklist() external onlyOwner {
}
/**
* @notice Set or unset an exchange contract address as blocklisted
*/
function updateBlocklistedExchanges(
uint256[] calldata exchanges,
bool[] calldata blocklisted
) external onlyOwner {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 tokenId,
uint256 quantity
) internal override(ERC721A) whenNotPaused {
}
}
interface IERC1155Basic {
function balanceOf(address account, uint256 id)
external
view
returns (uint256);
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data
) external;
}
interface IExchangeOperatorAddressList {
function operatorAddressToExchange(address operatorAddress)
external
view
returns (uint256);
}
| ExternalERC1155BurnContract.balanceOf(msg.sender,13)>=amount,"NOT_ENOUGH_TOKENS_OWNED" | 463,518 | ExternalERC1155BurnContract.balanceOf(msg.sender,13)>=amount |
"NOT_ENOUGH_TOKENS_OWNED" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC4907A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "erc721a/contracts/IERC721A.sol";
import "erc721a/contracts/extensions/IERC4907A.sol";
import "erc721a/contracts/extensions/IERC721AQueryable.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
contract degents is
ERC721A,
ERC721AQueryable,
ERC4907A,
Ownable,
Pausable,
ReentrancyGuard,
ERC2981
{
// Address where burnt tokens are sent
address burnAddress = 0x000000000000000000000000000000000000dEaD;
// Address of the smart contract used to check if an operator address is from a blocklisted exchange
address public blocklistContractAddress;
address public burnToMintContractAddress =
0x3b0Daea2634F111DBA1344768D34e15Ffea8b81f;
address public burnToMintvibeContractAddress =
0x4d8cCf1dDa3fb2731f1D6EfDEF9A5Ab6042B5bb9;
address public royaltyAddress = 0xF5d96c4675ee80E72005A24B7581aF8Aa5b063BA;
address[] public payoutAddresses = [
0xF5d96c4675ee80E72005A24B7581aF8Aa5b063BA
];
// Permanently disable the blocklist so all exchanges are allowed
bool public blocklistPermanentlyDisabled;
// If true tokens can be burned in order to mint
bool public burnClaimActive;
bool public isPublicSaleActive;
// Permanently freezes metadata so it can never be changed
bool public metadataFrozen;
// If true, payout addresses and basis points are permanently frozen and can never be updated
bool public payoutAddressesFrozen;
// If true, the exchange represented by a uint256 integer is blocklisted and cannot be used to transfer tokens
mapping(uint256 => bool) public isExchangeBlocklisted;
string public baseTokenURI =
"";
// Maximum supply of tokens that can be minted
uint256 public MAX_SUPPLY = 10000;
uint256 public PUBLIC_CURRENT_SUPPLY = 7110;
uint256 public PUBLIC_COUNTER;
uint256 public mintsPerBurn = 1;
uint256 public newBurnID;
uint256 public publicMintsAllowedPerTransaction = 3;
uint256 public publicPrice = 0.004 ether;
uint256[] public payoutBasisPoints = [10000];
uint96 public royaltyFee = 500;
constructor(address _blocklistContractAddress) ERC721A("degents", "degents") {
}
modifier originalUser() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev Overrides the default ERC721A _startTokenId() so tokens begin at 1 instead of 0
*/
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @notice Change the royalty fee for the collection
*/
function setRoyaltyFee(uint96 _feeNumerator) external onlyOwner {
}
/**
* @notice Change the royalty address where royalty payouts are sent
*/
function setRoyaltyAddress(address _royaltyAddress) external onlyOwner {
}
/**
* @notice Wraps and exposes publicly _numberMinted() from ERC721A
*/
function numberMinted(address owner) public view returns (uint256) {
}
/**
* @notice Update the base token URI
*/
function setBaseURI(string calldata _newBaseURI) external onlyOwner {
}
/**
* @notice Reduce the max supply of tokens
* @param _newMaxSupply The new maximum supply of tokens available to mint
*/
function reduceMaxSupply(uint256 _newMaxSupply) external onlyOwner {
}
function changePublicSupply(uint256 _newPublicSupply) external onlyOwner {
}
/**
* @notice Freeze metadata so it can never be changed again
*/
function freezeMetadata() external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function publicCounter() public view returns (uint256) {
}
// https://chiru-labs.github.io/ERC721A/#/migration?id=supportsinterface
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC721A, ERC2981, ERC4907A)
returns (bool)
{
}
/**
* @notice Allow owner to send 'mintNumber' tokens without cost to multiple addresses
*/
function gift(address[] calldata receivers, uint256[] calldata mintNumber)
external
onlyOwner
{
}
/**
* @notice To be updated by contract owner to allow public sale minting
*/
function setPublicSaleState(bool _saleActiveState) external onlyOwner {
}
/**
* @notice Update the public mint price
*/
function setPublicPrice(uint256 _publicPrice) external onlyOwner {
}
/**
* @notice Set the maximum public mints allowed per a given transaction
*/
function setPublicMintsAllowedPerTransaction(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Allow for public minting of tokens
*/
function mint(uint256 numTokens)
external
payable
nonReentrant
originalUser
{
}
/**
* @notice Freeze all payout addresses and percentages so they can never be changed again
*/
function freezePayoutAddresses() external onlyOwner {
}
/**
* @notice Update payout addresses and basis points for each addresses' respective share of contract funds
*/
function updatePayoutAddressesAndBasisPoints(
address[] calldata _payoutAddresses,
uint256[] calldata _payoutBasisPoints
) external onlyOwner {
}
/**
* @notice Withdraws all funds held within contract
*/
function withdraw() external nonReentrant onlyOwner {
}
/**
* @notice To be updated by contract owner to allow burning to claim a token
*/
function setBurnClaimState(bool _burnClaimActive) external onlyOwner {
}
/**
* @notice Update the number of free mints claimable per token burned
*/
function updateMintsPerBurn(uint256 _mintsPerBurn) external onlyOwner {
}
function burnmrCollectoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrSpectaculoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrEarly(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrMintoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrkekelessrare(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrtroublemakoor(uint256 amount)
external
nonReentrant
originalUser
{
require(burnClaimActive, "BURN_CLAIM_IS_NOT_ACTIVE");
require(
totalSupply() + (amount * mintsPerBurn) <= MAX_SUPPLY,
"MAX_SUPPLY_EXCEEDED"
);
IERC1155Basic ExternalERC1155BurnContract = IERC1155Basic(
burnToMintContractAddress
);
require(<FILL_ME>)
ExternalERC1155BurnContract.safeTransferFrom( /**tokenID of burn**/
msg.sender,
burnAddress,
7,
amount,
""
);
_safeMint(msg.sender, amount * mintsPerBurn);
}
function burnmrviboor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrHue(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmr0ccult(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmr0g(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrchargeoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrcheckoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrCheckoormorerare(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrKek(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrSingleCheckoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrBleedoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrBelievoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0gr3y(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0golden(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnImpatient(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0glory(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnActive(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnWealth(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnAbundance(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnhUeye(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnTranquil(uint256 amount)
external
nonReentrant
originalUser
{
}
/**
* update a new burn tokenID to be burned
*/
function updatenewBurnID(uint256 _newBurnID) external onlyOwner {
}
function burnupdatednewBurnXX(uint256 amount)
external
nonReentrant
originalUser
{
}
/**
* @dev Require that the address being approved is not from a blocklisted exchange
*/
modifier onlyAllowedOperatorApproval(address operator) {
}
/**
* @notice Update blocklist contract address to a custom contract address if desired for custom functionality
*/
function updateBlocklistContractAddress(address _blocklistContractAddress)
external
onlyOwner
{
}
/**
* @notice Permanently disable the blocklist so all exchanges are allowed forever
*/
function permanentlyDisableBlocklist() external onlyOwner {
}
/**
* @notice Set or unset an exchange contract address as blocklisted
*/
function updateBlocklistedExchanges(
uint256[] calldata exchanges,
bool[] calldata blocklisted
) external onlyOwner {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 tokenId,
uint256 quantity
) internal override(ERC721A) whenNotPaused {
}
}
interface IERC1155Basic {
function balanceOf(address account, uint256 id)
external
view
returns (uint256);
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data
) external;
}
interface IExchangeOperatorAddressList {
function operatorAddressToExchange(address operatorAddress)
external
view
returns (uint256);
}
| ExternalERC1155BurnContract.balanceOf(msg.sender,7)>=amount,"NOT_ENOUGH_TOKENS_OWNED" | 463,518 | ExternalERC1155BurnContract.balanceOf(msg.sender,7)>=amount |
"NOT_ENOUGH_TOKENS_OWNED" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC4907A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "erc721a/contracts/IERC721A.sol";
import "erc721a/contracts/extensions/IERC4907A.sol";
import "erc721a/contracts/extensions/IERC721AQueryable.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
contract degents is
ERC721A,
ERC721AQueryable,
ERC4907A,
Ownable,
Pausable,
ReentrancyGuard,
ERC2981
{
// Address where burnt tokens are sent
address burnAddress = 0x000000000000000000000000000000000000dEaD;
// Address of the smart contract used to check if an operator address is from a blocklisted exchange
address public blocklistContractAddress;
address public burnToMintContractAddress =
0x3b0Daea2634F111DBA1344768D34e15Ffea8b81f;
address public burnToMintvibeContractAddress =
0x4d8cCf1dDa3fb2731f1D6EfDEF9A5Ab6042B5bb9;
address public royaltyAddress = 0xF5d96c4675ee80E72005A24B7581aF8Aa5b063BA;
address[] public payoutAddresses = [
0xF5d96c4675ee80E72005A24B7581aF8Aa5b063BA
];
// Permanently disable the blocklist so all exchanges are allowed
bool public blocklistPermanentlyDisabled;
// If true tokens can be burned in order to mint
bool public burnClaimActive;
bool public isPublicSaleActive;
// Permanently freezes metadata so it can never be changed
bool public metadataFrozen;
// If true, payout addresses and basis points are permanently frozen and can never be updated
bool public payoutAddressesFrozen;
// If true, the exchange represented by a uint256 integer is blocklisted and cannot be used to transfer tokens
mapping(uint256 => bool) public isExchangeBlocklisted;
string public baseTokenURI =
"";
// Maximum supply of tokens that can be minted
uint256 public MAX_SUPPLY = 10000;
uint256 public PUBLIC_CURRENT_SUPPLY = 7110;
uint256 public PUBLIC_COUNTER;
uint256 public mintsPerBurn = 1;
uint256 public newBurnID;
uint256 public publicMintsAllowedPerTransaction = 3;
uint256 public publicPrice = 0.004 ether;
uint256[] public payoutBasisPoints = [10000];
uint96 public royaltyFee = 500;
constructor(address _blocklistContractAddress) ERC721A("degents", "degents") {
}
modifier originalUser() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev Overrides the default ERC721A _startTokenId() so tokens begin at 1 instead of 0
*/
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @notice Change the royalty fee for the collection
*/
function setRoyaltyFee(uint96 _feeNumerator) external onlyOwner {
}
/**
* @notice Change the royalty address where royalty payouts are sent
*/
function setRoyaltyAddress(address _royaltyAddress) external onlyOwner {
}
/**
* @notice Wraps and exposes publicly _numberMinted() from ERC721A
*/
function numberMinted(address owner) public view returns (uint256) {
}
/**
* @notice Update the base token URI
*/
function setBaseURI(string calldata _newBaseURI) external onlyOwner {
}
/**
* @notice Reduce the max supply of tokens
* @param _newMaxSupply The new maximum supply of tokens available to mint
*/
function reduceMaxSupply(uint256 _newMaxSupply) external onlyOwner {
}
function changePublicSupply(uint256 _newPublicSupply) external onlyOwner {
}
/**
* @notice Freeze metadata so it can never be changed again
*/
function freezeMetadata() external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function publicCounter() public view returns (uint256) {
}
// https://chiru-labs.github.io/ERC721A/#/migration?id=supportsinterface
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC721A, ERC2981, ERC4907A)
returns (bool)
{
}
/**
* @notice Allow owner to send 'mintNumber' tokens without cost to multiple addresses
*/
function gift(address[] calldata receivers, uint256[] calldata mintNumber)
external
onlyOwner
{
}
/**
* @notice To be updated by contract owner to allow public sale minting
*/
function setPublicSaleState(bool _saleActiveState) external onlyOwner {
}
/**
* @notice Update the public mint price
*/
function setPublicPrice(uint256 _publicPrice) external onlyOwner {
}
/**
* @notice Set the maximum public mints allowed per a given transaction
*/
function setPublicMintsAllowedPerTransaction(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Allow for public minting of tokens
*/
function mint(uint256 numTokens)
external
payable
nonReentrant
originalUser
{
}
/**
* @notice Freeze all payout addresses and percentages so they can never be changed again
*/
function freezePayoutAddresses() external onlyOwner {
}
/**
* @notice Update payout addresses and basis points for each addresses' respective share of contract funds
*/
function updatePayoutAddressesAndBasisPoints(
address[] calldata _payoutAddresses,
uint256[] calldata _payoutBasisPoints
) external onlyOwner {
}
/**
* @notice Withdraws all funds held within contract
*/
function withdraw() external nonReentrant onlyOwner {
}
/**
* @notice To be updated by contract owner to allow burning to claim a token
*/
function setBurnClaimState(bool _burnClaimActive) external onlyOwner {
}
/**
* @notice Update the number of free mints claimable per token burned
*/
function updateMintsPerBurn(uint256 _mintsPerBurn) external onlyOwner {
}
function burnmrCollectoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrSpectaculoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrEarly(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrMintoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrkekelessrare(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrtroublemakoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrviboor(uint256 amount)
external
nonReentrant
originalUser
{
require(burnClaimActive, "BURN_CLAIM_IS_NOT_ACTIVE");
require(
totalSupply() + (amount * mintsPerBurn) <= MAX_SUPPLY,
"MAX_SUPPLY_EXCEEDED"
);
IERC1155Basic ExternalERC1155BurnContract = IERC1155Basic(
burnToMintContractAddress
);
require(<FILL_ME>)
ExternalERC1155BurnContract.safeTransferFrom( /**tokenID of burn**/
msg.sender,
burnAddress,
6,
amount,
""
);
_safeMint(msg.sender, amount * mintsPerBurn);
}
function burnmrHue(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmr0ccult(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmr0g(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrchargeoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrcheckoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrCheckoormorerare(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrKek(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrSingleCheckoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrBleedoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrBelievoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0gr3y(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0golden(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnImpatient(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0glory(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnActive(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnWealth(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnAbundance(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnhUeye(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnTranquil(uint256 amount)
external
nonReentrant
originalUser
{
}
/**
* update a new burn tokenID to be burned
*/
function updatenewBurnID(uint256 _newBurnID) external onlyOwner {
}
function burnupdatednewBurnXX(uint256 amount)
external
nonReentrant
originalUser
{
}
/**
* @dev Require that the address being approved is not from a blocklisted exchange
*/
modifier onlyAllowedOperatorApproval(address operator) {
}
/**
* @notice Update blocklist contract address to a custom contract address if desired for custom functionality
*/
function updateBlocklistContractAddress(address _blocklistContractAddress)
external
onlyOwner
{
}
/**
* @notice Permanently disable the blocklist so all exchanges are allowed forever
*/
function permanentlyDisableBlocklist() external onlyOwner {
}
/**
* @notice Set or unset an exchange contract address as blocklisted
*/
function updateBlocklistedExchanges(
uint256[] calldata exchanges,
bool[] calldata blocklisted
) external onlyOwner {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 tokenId,
uint256 quantity
) internal override(ERC721A) whenNotPaused {
}
}
interface IERC1155Basic {
function balanceOf(address account, uint256 id)
external
view
returns (uint256);
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data
) external;
}
interface IExchangeOperatorAddressList {
function operatorAddressToExchange(address operatorAddress)
external
view
returns (uint256);
}
| ExternalERC1155BurnContract.balanceOf(msg.sender,6)>=amount,"NOT_ENOUGH_TOKENS_OWNED" | 463,518 | ExternalERC1155BurnContract.balanceOf(msg.sender,6)>=amount |
"NOT_ENOUGH_TOKENS_OWNED" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC4907A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "erc721a/contracts/IERC721A.sol";
import "erc721a/contracts/extensions/IERC4907A.sol";
import "erc721a/contracts/extensions/IERC721AQueryable.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
contract degents is
ERC721A,
ERC721AQueryable,
ERC4907A,
Ownable,
Pausable,
ReentrancyGuard,
ERC2981
{
// Address where burnt tokens are sent
address burnAddress = 0x000000000000000000000000000000000000dEaD;
// Address of the smart contract used to check if an operator address is from a blocklisted exchange
address public blocklistContractAddress;
address public burnToMintContractAddress =
0x3b0Daea2634F111DBA1344768D34e15Ffea8b81f;
address public burnToMintvibeContractAddress =
0x4d8cCf1dDa3fb2731f1D6EfDEF9A5Ab6042B5bb9;
address public royaltyAddress = 0xF5d96c4675ee80E72005A24B7581aF8Aa5b063BA;
address[] public payoutAddresses = [
0xF5d96c4675ee80E72005A24B7581aF8Aa5b063BA
];
// Permanently disable the blocklist so all exchanges are allowed
bool public blocklistPermanentlyDisabled;
// If true tokens can be burned in order to mint
bool public burnClaimActive;
bool public isPublicSaleActive;
// Permanently freezes metadata so it can never be changed
bool public metadataFrozen;
// If true, payout addresses and basis points are permanently frozen and can never be updated
bool public payoutAddressesFrozen;
// If true, the exchange represented by a uint256 integer is blocklisted and cannot be used to transfer tokens
mapping(uint256 => bool) public isExchangeBlocklisted;
string public baseTokenURI =
"";
// Maximum supply of tokens that can be minted
uint256 public MAX_SUPPLY = 10000;
uint256 public PUBLIC_CURRENT_SUPPLY = 7110;
uint256 public PUBLIC_COUNTER;
uint256 public mintsPerBurn = 1;
uint256 public newBurnID;
uint256 public publicMintsAllowedPerTransaction = 3;
uint256 public publicPrice = 0.004 ether;
uint256[] public payoutBasisPoints = [10000];
uint96 public royaltyFee = 500;
constructor(address _blocklistContractAddress) ERC721A("degents", "degents") {
}
modifier originalUser() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev Overrides the default ERC721A _startTokenId() so tokens begin at 1 instead of 0
*/
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @notice Change the royalty fee for the collection
*/
function setRoyaltyFee(uint96 _feeNumerator) external onlyOwner {
}
/**
* @notice Change the royalty address where royalty payouts are sent
*/
function setRoyaltyAddress(address _royaltyAddress) external onlyOwner {
}
/**
* @notice Wraps and exposes publicly _numberMinted() from ERC721A
*/
function numberMinted(address owner) public view returns (uint256) {
}
/**
* @notice Update the base token URI
*/
function setBaseURI(string calldata _newBaseURI) external onlyOwner {
}
/**
* @notice Reduce the max supply of tokens
* @param _newMaxSupply The new maximum supply of tokens available to mint
*/
function reduceMaxSupply(uint256 _newMaxSupply) external onlyOwner {
}
function changePublicSupply(uint256 _newPublicSupply) external onlyOwner {
}
/**
* @notice Freeze metadata so it can never be changed again
*/
function freezeMetadata() external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function publicCounter() public view returns (uint256) {
}
// https://chiru-labs.github.io/ERC721A/#/migration?id=supportsinterface
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC721A, ERC2981, ERC4907A)
returns (bool)
{
}
/**
* @notice Allow owner to send 'mintNumber' tokens without cost to multiple addresses
*/
function gift(address[] calldata receivers, uint256[] calldata mintNumber)
external
onlyOwner
{
}
/**
* @notice To be updated by contract owner to allow public sale minting
*/
function setPublicSaleState(bool _saleActiveState) external onlyOwner {
}
/**
* @notice Update the public mint price
*/
function setPublicPrice(uint256 _publicPrice) external onlyOwner {
}
/**
* @notice Set the maximum public mints allowed per a given transaction
*/
function setPublicMintsAllowedPerTransaction(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Allow for public minting of tokens
*/
function mint(uint256 numTokens)
external
payable
nonReentrant
originalUser
{
}
/**
* @notice Freeze all payout addresses and percentages so they can never be changed again
*/
function freezePayoutAddresses() external onlyOwner {
}
/**
* @notice Update payout addresses and basis points for each addresses' respective share of contract funds
*/
function updatePayoutAddressesAndBasisPoints(
address[] calldata _payoutAddresses,
uint256[] calldata _payoutBasisPoints
) external onlyOwner {
}
/**
* @notice Withdraws all funds held within contract
*/
function withdraw() external nonReentrant onlyOwner {
}
/**
* @notice To be updated by contract owner to allow burning to claim a token
*/
function setBurnClaimState(bool _burnClaimActive) external onlyOwner {
}
/**
* @notice Update the number of free mints claimable per token burned
*/
function updateMintsPerBurn(uint256 _mintsPerBurn) external onlyOwner {
}
function burnmrCollectoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrSpectaculoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrEarly(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrMintoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrkekelessrare(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrtroublemakoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrviboor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrHue(uint256 amount)
external
nonReentrant
originalUser
{
require(burnClaimActive, "BURN_CLAIM_IS_NOT_ACTIVE");
require(
totalSupply() + (amount * mintsPerBurn) <= MAX_SUPPLY,
"MAX_SUPPLY_EXCEEDED"
);
IERC1155Basic ExternalERC1155BurnContract = IERC1155Basic(
burnToMintContractAddress
);
require(<FILL_ME>)
ExternalERC1155BurnContract.safeTransferFrom( /**tokenID of burn**/
msg.sender,
burnAddress,
9,
amount,
""
);
_safeMint(msg.sender, amount * mintsPerBurn);
}
function burnmr0ccult(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmr0g(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrchargeoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrcheckoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrCheckoormorerare(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrKek(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrSingleCheckoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrBleedoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrBelievoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0gr3y(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0golden(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnImpatient(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0glory(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnActive(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnWealth(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnAbundance(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnhUeye(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnTranquil(uint256 amount)
external
nonReentrant
originalUser
{
}
/**
* update a new burn tokenID to be burned
*/
function updatenewBurnID(uint256 _newBurnID) external onlyOwner {
}
function burnupdatednewBurnXX(uint256 amount)
external
nonReentrant
originalUser
{
}
/**
* @dev Require that the address being approved is not from a blocklisted exchange
*/
modifier onlyAllowedOperatorApproval(address operator) {
}
/**
* @notice Update blocklist contract address to a custom contract address if desired for custom functionality
*/
function updateBlocklistContractAddress(address _blocklistContractAddress)
external
onlyOwner
{
}
/**
* @notice Permanently disable the blocklist so all exchanges are allowed forever
*/
function permanentlyDisableBlocklist() external onlyOwner {
}
/**
* @notice Set or unset an exchange contract address as blocklisted
*/
function updateBlocklistedExchanges(
uint256[] calldata exchanges,
bool[] calldata blocklisted
) external onlyOwner {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 tokenId,
uint256 quantity
) internal override(ERC721A) whenNotPaused {
}
}
interface IERC1155Basic {
function balanceOf(address account, uint256 id)
external
view
returns (uint256);
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data
) external;
}
interface IExchangeOperatorAddressList {
function operatorAddressToExchange(address operatorAddress)
external
view
returns (uint256);
}
| ExternalERC1155BurnContract.balanceOf(msg.sender,9)>=amount,"NOT_ENOUGH_TOKENS_OWNED" | 463,518 | ExternalERC1155BurnContract.balanceOf(msg.sender,9)>=amount |
"NOT_ENOUGH_TOKENS_OWNED" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC4907A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "erc721a/contracts/IERC721A.sol";
import "erc721a/contracts/extensions/IERC4907A.sol";
import "erc721a/contracts/extensions/IERC721AQueryable.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
contract degents is
ERC721A,
ERC721AQueryable,
ERC4907A,
Ownable,
Pausable,
ReentrancyGuard,
ERC2981
{
// Address where burnt tokens are sent
address burnAddress = 0x000000000000000000000000000000000000dEaD;
// Address of the smart contract used to check if an operator address is from a blocklisted exchange
address public blocklistContractAddress;
address public burnToMintContractAddress =
0x3b0Daea2634F111DBA1344768D34e15Ffea8b81f;
address public burnToMintvibeContractAddress =
0x4d8cCf1dDa3fb2731f1D6EfDEF9A5Ab6042B5bb9;
address public royaltyAddress = 0xF5d96c4675ee80E72005A24B7581aF8Aa5b063BA;
address[] public payoutAddresses = [
0xF5d96c4675ee80E72005A24B7581aF8Aa5b063BA
];
// Permanently disable the blocklist so all exchanges are allowed
bool public blocklistPermanentlyDisabled;
// If true tokens can be burned in order to mint
bool public burnClaimActive;
bool public isPublicSaleActive;
// Permanently freezes metadata so it can never be changed
bool public metadataFrozen;
// If true, payout addresses and basis points are permanently frozen and can never be updated
bool public payoutAddressesFrozen;
// If true, the exchange represented by a uint256 integer is blocklisted and cannot be used to transfer tokens
mapping(uint256 => bool) public isExchangeBlocklisted;
string public baseTokenURI =
"";
// Maximum supply of tokens that can be minted
uint256 public MAX_SUPPLY = 10000;
uint256 public PUBLIC_CURRENT_SUPPLY = 7110;
uint256 public PUBLIC_COUNTER;
uint256 public mintsPerBurn = 1;
uint256 public newBurnID;
uint256 public publicMintsAllowedPerTransaction = 3;
uint256 public publicPrice = 0.004 ether;
uint256[] public payoutBasisPoints = [10000];
uint96 public royaltyFee = 500;
constructor(address _blocklistContractAddress) ERC721A("degents", "degents") {
}
modifier originalUser() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev Overrides the default ERC721A _startTokenId() so tokens begin at 1 instead of 0
*/
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @notice Change the royalty fee for the collection
*/
function setRoyaltyFee(uint96 _feeNumerator) external onlyOwner {
}
/**
* @notice Change the royalty address where royalty payouts are sent
*/
function setRoyaltyAddress(address _royaltyAddress) external onlyOwner {
}
/**
* @notice Wraps and exposes publicly _numberMinted() from ERC721A
*/
function numberMinted(address owner) public view returns (uint256) {
}
/**
* @notice Update the base token URI
*/
function setBaseURI(string calldata _newBaseURI) external onlyOwner {
}
/**
* @notice Reduce the max supply of tokens
* @param _newMaxSupply The new maximum supply of tokens available to mint
*/
function reduceMaxSupply(uint256 _newMaxSupply) external onlyOwner {
}
function changePublicSupply(uint256 _newPublicSupply) external onlyOwner {
}
/**
* @notice Freeze metadata so it can never be changed again
*/
function freezeMetadata() external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function publicCounter() public view returns (uint256) {
}
// https://chiru-labs.github.io/ERC721A/#/migration?id=supportsinterface
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC721A, ERC2981, ERC4907A)
returns (bool)
{
}
/**
* @notice Allow owner to send 'mintNumber' tokens without cost to multiple addresses
*/
function gift(address[] calldata receivers, uint256[] calldata mintNumber)
external
onlyOwner
{
}
/**
* @notice To be updated by contract owner to allow public sale minting
*/
function setPublicSaleState(bool _saleActiveState) external onlyOwner {
}
/**
* @notice Update the public mint price
*/
function setPublicPrice(uint256 _publicPrice) external onlyOwner {
}
/**
* @notice Set the maximum public mints allowed per a given transaction
*/
function setPublicMintsAllowedPerTransaction(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Allow for public minting of tokens
*/
function mint(uint256 numTokens)
external
payable
nonReentrant
originalUser
{
}
/**
* @notice Freeze all payout addresses and percentages so they can never be changed again
*/
function freezePayoutAddresses() external onlyOwner {
}
/**
* @notice Update payout addresses and basis points for each addresses' respective share of contract funds
*/
function updatePayoutAddressesAndBasisPoints(
address[] calldata _payoutAddresses,
uint256[] calldata _payoutBasisPoints
) external onlyOwner {
}
/**
* @notice Withdraws all funds held within contract
*/
function withdraw() external nonReentrant onlyOwner {
}
/**
* @notice To be updated by contract owner to allow burning to claim a token
*/
function setBurnClaimState(bool _burnClaimActive) external onlyOwner {
}
/**
* @notice Update the number of free mints claimable per token burned
*/
function updateMintsPerBurn(uint256 _mintsPerBurn) external onlyOwner {
}
function burnmrCollectoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrSpectaculoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrEarly(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrMintoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrkekelessrare(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrtroublemakoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrviboor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrHue(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmr0ccult(uint256 amount)
external
nonReentrant
originalUser
{
require(burnClaimActive, "BURN_CLAIM_IS_NOT_ACTIVE");
require(
totalSupply() + (amount * mintsPerBurn) <= MAX_SUPPLY,
"MAX_SUPPLY_EXCEEDED"
);
IERC1155Basic ExternalERC1155BurnContract = IERC1155Basic(
burnToMintContractAddress
);
require(<FILL_ME>)
ExternalERC1155BurnContract.safeTransferFrom( /**tokenID of burn**/
msg.sender,
burnAddress,
10,
amount,
""
);
_safeMint(msg.sender, amount * mintsPerBurn);
}
function burnmr0g(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrchargeoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrcheckoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrCheckoormorerare(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrKek(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrSingleCheckoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrBleedoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrBelievoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0gr3y(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0golden(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnImpatient(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0glory(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnActive(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnWealth(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnAbundance(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnhUeye(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnTranquil(uint256 amount)
external
nonReentrant
originalUser
{
}
/**
* update a new burn tokenID to be burned
*/
function updatenewBurnID(uint256 _newBurnID) external onlyOwner {
}
function burnupdatednewBurnXX(uint256 amount)
external
nonReentrant
originalUser
{
}
/**
* @dev Require that the address being approved is not from a blocklisted exchange
*/
modifier onlyAllowedOperatorApproval(address operator) {
}
/**
* @notice Update blocklist contract address to a custom contract address if desired for custom functionality
*/
function updateBlocklistContractAddress(address _blocklistContractAddress)
external
onlyOwner
{
}
/**
* @notice Permanently disable the blocklist so all exchanges are allowed forever
*/
function permanentlyDisableBlocklist() external onlyOwner {
}
/**
* @notice Set or unset an exchange contract address as blocklisted
*/
function updateBlocklistedExchanges(
uint256[] calldata exchanges,
bool[] calldata blocklisted
) external onlyOwner {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 tokenId,
uint256 quantity
) internal override(ERC721A) whenNotPaused {
}
}
interface IERC1155Basic {
function balanceOf(address account, uint256 id)
external
view
returns (uint256);
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data
) external;
}
interface IExchangeOperatorAddressList {
function operatorAddressToExchange(address operatorAddress)
external
view
returns (uint256);
}
| ExternalERC1155BurnContract.balanceOf(msg.sender,10)>=amount,"NOT_ENOUGH_TOKENS_OWNED" | 463,518 | ExternalERC1155BurnContract.balanceOf(msg.sender,10)>=amount |
"NOT_ENOUGH_TOKENS_OWNED" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC4907A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "erc721a/contracts/IERC721A.sol";
import "erc721a/contracts/extensions/IERC4907A.sol";
import "erc721a/contracts/extensions/IERC721AQueryable.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
contract degents is
ERC721A,
ERC721AQueryable,
ERC4907A,
Ownable,
Pausable,
ReentrancyGuard,
ERC2981
{
// Address where burnt tokens are sent
address burnAddress = 0x000000000000000000000000000000000000dEaD;
// Address of the smart contract used to check if an operator address is from a blocklisted exchange
address public blocklistContractAddress;
address public burnToMintContractAddress =
0x3b0Daea2634F111DBA1344768D34e15Ffea8b81f;
address public burnToMintvibeContractAddress =
0x4d8cCf1dDa3fb2731f1D6EfDEF9A5Ab6042B5bb9;
address public royaltyAddress = 0xF5d96c4675ee80E72005A24B7581aF8Aa5b063BA;
address[] public payoutAddresses = [
0xF5d96c4675ee80E72005A24B7581aF8Aa5b063BA
];
// Permanently disable the blocklist so all exchanges are allowed
bool public blocklistPermanentlyDisabled;
// If true tokens can be burned in order to mint
bool public burnClaimActive;
bool public isPublicSaleActive;
// Permanently freezes metadata so it can never be changed
bool public metadataFrozen;
// If true, payout addresses and basis points are permanently frozen and can never be updated
bool public payoutAddressesFrozen;
// If true, the exchange represented by a uint256 integer is blocklisted and cannot be used to transfer tokens
mapping(uint256 => bool) public isExchangeBlocklisted;
string public baseTokenURI =
"";
// Maximum supply of tokens that can be minted
uint256 public MAX_SUPPLY = 10000;
uint256 public PUBLIC_CURRENT_SUPPLY = 7110;
uint256 public PUBLIC_COUNTER;
uint256 public mintsPerBurn = 1;
uint256 public newBurnID;
uint256 public publicMintsAllowedPerTransaction = 3;
uint256 public publicPrice = 0.004 ether;
uint256[] public payoutBasisPoints = [10000];
uint96 public royaltyFee = 500;
constructor(address _blocklistContractAddress) ERC721A("degents", "degents") {
}
modifier originalUser() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev Overrides the default ERC721A _startTokenId() so tokens begin at 1 instead of 0
*/
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @notice Change the royalty fee for the collection
*/
function setRoyaltyFee(uint96 _feeNumerator) external onlyOwner {
}
/**
* @notice Change the royalty address where royalty payouts are sent
*/
function setRoyaltyAddress(address _royaltyAddress) external onlyOwner {
}
/**
* @notice Wraps and exposes publicly _numberMinted() from ERC721A
*/
function numberMinted(address owner) public view returns (uint256) {
}
/**
* @notice Update the base token URI
*/
function setBaseURI(string calldata _newBaseURI) external onlyOwner {
}
/**
* @notice Reduce the max supply of tokens
* @param _newMaxSupply The new maximum supply of tokens available to mint
*/
function reduceMaxSupply(uint256 _newMaxSupply) external onlyOwner {
}
function changePublicSupply(uint256 _newPublicSupply) external onlyOwner {
}
/**
* @notice Freeze metadata so it can never be changed again
*/
function freezeMetadata() external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function publicCounter() public view returns (uint256) {
}
// https://chiru-labs.github.io/ERC721A/#/migration?id=supportsinterface
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC721A, ERC2981, ERC4907A)
returns (bool)
{
}
/**
* @notice Allow owner to send 'mintNumber' tokens without cost to multiple addresses
*/
function gift(address[] calldata receivers, uint256[] calldata mintNumber)
external
onlyOwner
{
}
/**
* @notice To be updated by contract owner to allow public sale minting
*/
function setPublicSaleState(bool _saleActiveState) external onlyOwner {
}
/**
* @notice Update the public mint price
*/
function setPublicPrice(uint256 _publicPrice) external onlyOwner {
}
/**
* @notice Set the maximum public mints allowed per a given transaction
*/
function setPublicMintsAllowedPerTransaction(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Allow for public minting of tokens
*/
function mint(uint256 numTokens)
external
payable
nonReentrant
originalUser
{
}
/**
* @notice Freeze all payout addresses and percentages so they can never be changed again
*/
function freezePayoutAddresses() external onlyOwner {
}
/**
* @notice Update payout addresses and basis points for each addresses' respective share of contract funds
*/
function updatePayoutAddressesAndBasisPoints(
address[] calldata _payoutAddresses,
uint256[] calldata _payoutBasisPoints
) external onlyOwner {
}
/**
* @notice Withdraws all funds held within contract
*/
function withdraw() external nonReentrant onlyOwner {
}
/**
* @notice To be updated by contract owner to allow burning to claim a token
*/
function setBurnClaimState(bool _burnClaimActive) external onlyOwner {
}
/**
* @notice Update the number of free mints claimable per token burned
*/
function updateMintsPerBurn(uint256 _mintsPerBurn) external onlyOwner {
}
function burnmrCollectoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrSpectaculoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrEarly(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrMintoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrkekelessrare(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrtroublemakoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrviboor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrHue(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmr0ccult(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmr0g(uint256 amount)
external
nonReentrant
originalUser
{
require(burnClaimActive, "BURN_CLAIM_IS_NOT_ACTIVE");
require(
totalSupply() + (amount * mintsPerBurn) <= MAX_SUPPLY,
"MAX_SUPPLY_EXCEEDED"
);
IERC1155Basic ExternalERC1155BurnContract = IERC1155Basic(
burnToMintContractAddress
);
require(<FILL_ME>)
ExternalERC1155BurnContract.safeTransferFrom( /**tokenID of burn**/
msg.sender,
burnAddress,
8,
amount,
""
);
_safeMint(msg.sender, amount * mintsPerBurn);
}
function burnmrchargeoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrcheckoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrCheckoormorerare(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrKek(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrSingleCheckoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrBleedoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrBelievoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0gr3y(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0golden(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnImpatient(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0glory(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnActive(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnWealth(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnAbundance(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnhUeye(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnTranquil(uint256 amount)
external
nonReentrant
originalUser
{
}
/**
* update a new burn tokenID to be burned
*/
function updatenewBurnID(uint256 _newBurnID) external onlyOwner {
}
function burnupdatednewBurnXX(uint256 amount)
external
nonReentrant
originalUser
{
}
/**
* @dev Require that the address being approved is not from a blocklisted exchange
*/
modifier onlyAllowedOperatorApproval(address operator) {
}
/**
* @notice Update blocklist contract address to a custom contract address if desired for custom functionality
*/
function updateBlocklistContractAddress(address _blocklistContractAddress)
external
onlyOwner
{
}
/**
* @notice Permanently disable the blocklist so all exchanges are allowed forever
*/
function permanentlyDisableBlocklist() external onlyOwner {
}
/**
* @notice Set or unset an exchange contract address as blocklisted
*/
function updateBlocklistedExchanges(
uint256[] calldata exchanges,
bool[] calldata blocklisted
) external onlyOwner {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 tokenId,
uint256 quantity
) internal override(ERC721A) whenNotPaused {
}
}
interface IERC1155Basic {
function balanceOf(address account, uint256 id)
external
view
returns (uint256);
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data
) external;
}
interface IExchangeOperatorAddressList {
function operatorAddressToExchange(address operatorAddress)
external
view
returns (uint256);
}
| ExternalERC1155BurnContract.balanceOf(msg.sender,8)>=amount,"NOT_ENOUGH_TOKENS_OWNED" | 463,518 | ExternalERC1155BurnContract.balanceOf(msg.sender,8)>=amount |
"NOT_ENOUGH_TOKENS_OWNED" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC4907A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "erc721a/contracts/IERC721A.sol";
import "erc721a/contracts/extensions/IERC4907A.sol";
import "erc721a/contracts/extensions/IERC721AQueryable.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
contract degents is
ERC721A,
ERC721AQueryable,
ERC4907A,
Ownable,
Pausable,
ReentrancyGuard,
ERC2981
{
// Address where burnt tokens are sent
address burnAddress = 0x000000000000000000000000000000000000dEaD;
// Address of the smart contract used to check if an operator address is from a blocklisted exchange
address public blocklistContractAddress;
address public burnToMintContractAddress =
0x3b0Daea2634F111DBA1344768D34e15Ffea8b81f;
address public burnToMintvibeContractAddress =
0x4d8cCf1dDa3fb2731f1D6EfDEF9A5Ab6042B5bb9;
address public royaltyAddress = 0xF5d96c4675ee80E72005A24B7581aF8Aa5b063BA;
address[] public payoutAddresses = [
0xF5d96c4675ee80E72005A24B7581aF8Aa5b063BA
];
// Permanently disable the blocklist so all exchanges are allowed
bool public blocklistPermanentlyDisabled;
// If true tokens can be burned in order to mint
bool public burnClaimActive;
bool public isPublicSaleActive;
// Permanently freezes metadata so it can never be changed
bool public metadataFrozen;
// If true, payout addresses and basis points are permanently frozen and can never be updated
bool public payoutAddressesFrozen;
// If true, the exchange represented by a uint256 integer is blocklisted and cannot be used to transfer tokens
mapping(uint256 => bool) public isExchangeBlocklisted;
string public baseTokenURI =
"";
// Maximum supply of tokens that can be minted
uint256 public MAX_SUPPLY = 10000;
uint256 public PUBLIC_CURRENT_SUPPLY = 7110;
uint256 public PUBLIC_COUNTER;
uint256 public mintsPerBurn = 1;
uint256 public newBurnID;
uint256 public publicMintsAllowedPerTransaction = 3;
uint256 public publicPrice = 0.004 ether;
uint256[] public payoutBasisPoints = [10000];
uint96 public royaltyFee = 500;
constructor(address _blocklistContractAddress) ERC721A("degents", "degents") {
}
modifier originalUser() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev Overrides the default ERC721A _startTokenId() so tokens begin at 1 instead of 0
*/
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @notice Change the royalty fee for the collection
*/
function setRoyaltyFee(uint96 _feeNumerator) external onlyOwner {
}
/**
* @notice Change the royalty address where royalty payouts are sent
*/
function setRoyaltyAddress(address _royaltyAddress) external onlyOwner {
}
/**
* @notice Wraps and exposes publicly _numberMinted() from ERC721A
*/
function numberMinted(address owner) public view returns (uint256) {
}
/**
* @notice Update the base token URI
*/
function setBaseURI(string calldata _newBaseURI) external onlyOwner {
}
/**
* @notice Reduce the max supply of tokens
* @param _newMaxSupply The new maximum supply of tokens available to mint
*/
function reduceMaxSupply(uint256 _newMaxSupply) external onlyOwner {
}
function changePublicSupply(uint256 _newPublicSupply) external onlyOwner {
}
/**
* @notice Freeze metadata so it can never be changed again
*/
function freezeMetadata() external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function publicCounter() public view returns (uint256) {
}
// https://chiru-labs.github.io/ERC721A/#/migration?id=supportsinterface
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC721A, ERC2981, ERC4907A)
returns (bool)
{
}
/**
* @notice Allow owner to send 'mintNumber' tokens without cost to multiple addresses
*/
function gift(address[] calldata receivers, uint256[] calldata mintNumber)
external
onlyOwner
{
}
/**
* @notice To be updated by contract owner to allow public sale minting
*/
function setPublicSaleState(bool _saleActiveState) external onlyOwner {
}
/**
* @notice Update the public mint price
*/
function setPublicPrice(uint256 _publicPrice) external onlyOwner {
}
/**
* @notice Set the maximum public mints allowed per a given transaction
*/
function setPublicMintsAllowedPerTransaction(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Allow for public minting of tokens
*/
function mint(uint256 numTokens)
external
payable
nonReentrant
originalUser
{
}
/**
* @notice Freeze all payout addresses and percentages so they can never be changed again
*/
function freezePayoutAddresses() external onlyOwner {
}
/**
* @notice Update payout addresses and basis points for each addresses' respective share of contract funds
*/
function updatePayoutAddressesAndBasisPoints(
address[] calldata _payoutAddresses,
uint256[] calldata _payoutBasisPoints
) external onlyOwner {
}
/**
* @notice Withdraws all funds held within contract
*/
function withdraw() external nonReentrant onlyOwner {
}
/**
* @notice To be updated by contract owner to allow burning to claim a token
*/
function setBurnClaimState(bool _burnClaimActive) external onlyOwner {
}
/**
* @notice Update the number of free mints claimable per token burned
*/
function updateMintsPerBurn(uint256 _mintsPerBurn) external onlyOwner {
}
function burnmrCollectoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrSpectaculoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrEarly(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrMintoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrkekelessrare(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrtroublemakoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrviboor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrHue(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmr0ccult(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmr0g(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrchargeoor(uint256 amount)
external
nonReentrant
originalUser
{
require(burnClaimActive, "BURN_CLAIM_IS_NOT_ACTIVE");
require(
totalSupply() + (amount * mintsPerBurn) <= MAX_SUPPLY,
"MAX_SUPPLY_EXCEEDED"
);
IERC1155Basic ExternalERC1155BurnContract = IERC1155Basic(
burnToMintContractAddress
);
require(<FILL_ME>)
ExternalERC1155BurnContract.safeTransferFrom( /**tokenID of burn**/
msg.sender,
burnAddress,
17,
amount,
""
);
_safeMint(msg.sender, amount * mintsPerBurn);
}
function burnmrcheckoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrCheckoormorerare(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrKek(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrSingleCheckoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrBleedoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrBelievoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0gr3y(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0golden(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnImpatient(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0glory(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnActive(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnWealth(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnAbundance(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnhUeye(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnTranquil(uint256 amount)
external
nonReentrant
originalUser
{
}
/**
* update a new burn tokenID to be burned
*/
function updatenewBurnID(uint256 _newBurnID) external onlyOwner {
}
function burnupdatednewBurnXX(uint256 amount)
external
nonReentrant
originalUser
{
}
/**
* @dev Require that the address being approved is not from a blocklisted exchange
*/
modifier onlyAllowedOperatorApproval(address operator) {
}
/**
* @notice Update blocklist contract address to a custom contract address if desired for custom functionality
*/
function updateBlocklistContractAddress(address _blocklistContractAddress)
external
onlyOwner
{
}
/**
* @notice Permanently disable the blocklist so all exchanges are allowed forever
*/
function permanentlyDisableBlocklist() external onlyOwner {
}
/**
* @notice Set or unset an exchange contract address as blocklisted
*/
function updateBlocklistedExchanges(
uint256[] calldata exchanges,
bool[] calldata blocklisted
) external onlyOwner {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 tokenId,
uint256 quantity
) internal override(ERC721A) whenNotPaused {
}
}
interface IERC1155Basic {
function balanceOf(address account, uint256 id)
external
view
returns (uint256);
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data
) external;
}
interface IExchangeOperatorAddressList {
function operatorAddressToExchange(address operatorAddress)
external
view
returns (uint256);
}
| ExternalERC1155BurnContract.balanceOf(msg.sender,17)>=amount,"NOT_ENOUGH_TOKENS_OWNED" | 463,518 | ExternalERC1155BurnContract.balanceOf(msg.sender,17)>=amount |
"NOT_ENOUGH_TOKENS_OWNED" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC4907A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "erc721a/contracts/IERC721A.sol";
import "erc721a/contracts/extensions/IERC4907A.sol";
import "erc721a/contracts/extensions/IERC721AQueryable.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
contract degents is
ERC721A,
ERC721AQueryable,
ERC4907A,
Ownable,
Pausable,
ReentrancyGuard,
ERC2981
{
// Address where burnt tokens are sent
address burnAddress = 0x000000000000000000000000000000000000dEaD;
// Address of the smart contract used to check if an operator address is from a blocklisted exchange
address public blocklistContractAddress;
address public burnToMintContractAddress =
0x3b0Daea2634F111DBA1344768D34e15Ffea8b81f;
address public burnToMintvibeContractAddress =
0x4d8cCf1dDa3fb2731f1D6EfDEF9A5Ab6042B5bb9;
address public royaltyAddress = 0xF5d96c4675ee80E72005A24B7581aF8Aa5b063BA;
address[] public payoutAddresses = [
0xF5d96c4675ee80E72005A24B7581aF8Aa5b063BA
];
// Permanently disable the blocklist so all exchanges are allowed
bool public blocklistPermanentlyDisabled;
// If true tokens can be burned in order to mint
bool public burnClaimActive;
bool public isPublicSaleActive;
// Permanently freezes metadata so it can never be changed
bool public metadataFrozen;
// If true, payout addresses and basis points are permanently frozen and can never be updated
bool public payoutAddressesFrozen;
// If true, the exchange represented by a uint256 integer is blocklisted and cannot be used to transfer tokens
mapping(uint256 => bool) public isExchangeBlocklisted;
string public baseTokenURI =
"";
// Maximum supply of tokens that can be minted
uint256 public MAX_SUPPLY = 10000;
uint256 public PUBLIC_CURRENT_SUPPLY = 7110;
uint256 public PUBLIC_COUNTER;
uint256 public mintsPerBurn = 1;
uint256 public newBurnID;
uint256 public publicMintsAllowedPerTransaction = 3;
uint256 public publicPrice = 0.004 ether;
uint256[] public payoutBasisPoints = [10000];
uint96 public royaltyFee = 500;
constructor(address _blocklistContractAddress) ERC721A("degents", "degents") {
}
modifier originalUser() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev Overrides the default ERC721A _startTokenId() so tokens begin at 1 instead of 0
*/
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @notice Change the royalty fee for the collection
*/
function setRoyaltyFee(uint96 _feeNumerator) external onlyOwner {
}
/**
* @notice Change the royalty address where royalty payouts are sent
*/
function setRoyaltyAddress(address _royaltyAddress) external onlyOwner {
}
/**
* @notice Wraps and exposes publicly _numberMinted() from ERC721A
*/
function numberMinted(address owner) public view returns (uint256) {
}
/**
* @notice Update the base token URI
*/
function setBaseURI(string calldata _newBaseURI) external onlyOwner {
}
/**
* @notice Reduce the max supply of tokens
* @param _newMaxSupply The new maximum supply of tokens available to mint
*/
function reduceMaxSupply(uint256 _newMaxSupply) external onlyOwner {
}
function changePublicSupply(uint256 _newPublicSupply) external onlyOwner {
}
/**
* @notice Freeze metadata so it can never be changed again
*/
function freezeMetadata() external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function publicCounter() public view returns (uint256) {
}
// https://chiru-labs.github.io/ERC721A/#/migration?id=supportsinterface
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC721A, ERC2981, ERC4907A)
returns (bool)
{
}
/**
* @notice Allow owner to send 'mintNumber' tokens without cost to multiple addresses
*/
function gift(address[] calldata receivers, uint256[] calldata mintNumber)
external
onlyOwner
{
}
/**
* @notice To be updated by contract owner to allow public sale minting
*/
function setPublicSaleState(bool _saleActiveState) external onlyOwner {
}
/**
* @notice Update the public mint price
*/
function setPublicPrice(uint256 _publicPrice) external onlyOwner {
}
/**
* @notice Set the maximum public mints allowed per a given transaction
*/
function setPublicMintsAllowedPerTransaction(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Allow for public minting of tokens
*/
function mint(uint256 numTokens)
external
payable
nonReentrant
originalUser
{
}
/**
* @notice Freeze all payout addresses and percentages so they can never be changed again
*/
function freezePayoutAddresses() external onlyOwner {
}
/**
* @notice Update payout addresses and basis points for each addresses' respective share of contract funds
*/
function updatePayoutAddressesAndBasisPoints(
address[] calldata _payoutAddresses,
uint256[] calldata _payoutBasisPoints
) external onlyOwner {
}
/**
* @notice Withdraws all funds held within contract
*/
function withdraw() external nonReentrant onlyOwner {
}
/**
* @notice To be updated by contract owner to allow burning to claim a token
*/
function setBurnClaimState(bool _burnClaimActive) external onlyOwner {
}
/**
* @notice Update the number of free mints claimable per token burned
*/
function updateMintsPerBurn(uint256 _mintsPerBurn) external onlyOwner {
}
function burnmrCollectoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrSpectaculoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrEarly(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrMintoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrkekelessrare(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrtroublemakoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrviboor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrHue(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmr0ccult(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmr0g(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrchargeoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrcheckoor(uint256 amount)
external
nonReentrant
originalUser
{
require(burnClaimActive, "BURN_CLAIM_IS_NOT_ACTIVE");
require(
totalSupply() + (amount * mintsPerBurn) <= MAX_SUPPLY,
"MAX_SUPPLY_EXCEEDED"
);
IERC1155Basic ExternalERC1155BurnContract = IERC1155Basic(
burnToMintContractAddress
);
require(<FILL_ME>)
ExternalERC1155BurnContract.safeTransferFrom( /**tokenID of burn**/
msg.sender,
burnAddress,
16,
amount,
""
);
_safeMint(msg.sender, amount * mintsPerBurn);
}
function burnmrCheckoormorerare(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrKek(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrSingleCheckoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrBleedoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrBelievoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0gr3y(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0golden(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnImpatient(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0glory(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnActive(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnWealth(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnAbundance(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnhUeye(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnTranquil(uint256 amount)
external
nonReentrant
originalUser
{
}
/**
* update a new burn tokenID to be burned
*/
function updatenewBurnID(uint256 _newBurnID) external onlyOwner {
}
function burnupdatednewBurnXX(uint256 amount)
external
nonReentrant
originalUser
{
}
/**
* @dev Require that the address being approved is not from a blocklisted exchange
*/
modifier onlyAllowedOperatorApproval(address operator) {
}
/**
* @notice Update blocklist contract address to a custom contract address if desired for custom functionality
*/
function updateBlocklistContractAddress(address _blocklistContractAddress)
external
onlyOwner
{
}
/**
* @notice Permanently disable the blocklist so all exchanges are allowed forever
*/
function permanentlyDisableBlocklist() external onlyOwner {
}
/**
* @notice Set or unset an exchange contract address as blocklisted
*/
function updateBlocklistedExchanges(
uint256[] calldata exchanges,
bool[] calldata blocklisted
) external onlyOwner {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 tokenId,
uint256 quantity
) internal override(ERC721A) whenNotPaused {
}
}
interface IERC1155Basic {
function balanceOf(address account, uint256 id)
external
view
returns (uint256);
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data
) external;
}
interface IExchangeOperatorAddressList {
function operatorAddressToExchange(address operatorAddress)
external
view
returns (uint256);
}
| ExternalERC1155BurnContract.balanceOf(msg.sender,16)>=amount,"NOT_ENOUGH_TOKENS_OWNED" | 463,518 | ExternalERC1155BurnContract.balanceOf(msg.sender,16)>=amount |
"NOT_ENOUGH_TOKENS_OWNED" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC4907A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "erc721a/contracts/IERC721A.sol";
import "erc721a/contracts/extensions/IERC4907A.sol";
import "erc721a/contracts/extensions/IERC721AQueryable.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
contract degents is
ERC721A,
ERC721AQueryable,
ERC4907A,
Ownable,
Pausable,
ReentrancyGuard,
ERC2981
{
// Address where burnt tokens are sent
address burnAddress = 0x000000000000000000000000000000000000dEaD;
// Address of the smart contract used to check if an operator address is from a blocklisted exchange
address public blocklistContractAddress;
address public burnToMintContractAddress =
0x3b0Daea2634F111DBA1344768D34e15Ffea8b81f;
address public burnToMintvibeContractAddress =
0x4d8cCf1dDa3fb2731f1D6EfDEF9A5Ab6042B5bb9;
address public royaltyAddress = 0xF5d96c4675ee80E72005A24B7581aF8Aa5b063BA;
address[] public payoutAddresses = [
0xF5d96c4675ee80E72005A24B7581aF8Aa5b063BA
];
// Permanently disable the blocklist so all exchanges are allowed
bool public blocklistPermanentlyDisabled;
// If true tokens can be burned in order to mint
bool public burnClaimActive;
bool public isPublicSaleActive;
// Permanently freezes metadata so it can never be changed
bool public metadataFrozen;
// If true, payout addresses and basis points are permanently frozen and can never be updated
bool public payoutAddressesFrozen;
// If true, the exchange represented by a uint256 integer is blocklisted and cannot be used to transfer tokens
mapping(uint256 => bool) public isExchangeBlocklisted;
string public baseTokenURI =
"";
// Maximum supply of tokens that can be minted
uint256 public MAX_SUPPLY = 10000;
uint256 public PUBLIC_CURRENT_SUPPLY = 7110;
uint256 public PUBLIC_COUNTER;
uint256 public mintsPerBurn = 1;
uint256 public newBurnID;
uint256 public publicMintsAllowedPerTransaction = 3;
uint256 public publicPrice = 0.004 ether;
uint256[] public payoutBasisPoints = [10000];
uint96 public royaltyFee = 500;
constructor(address _blocklistContractAddress) ERC721A("degents", "degents") {
}
modifier originalUser() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev Overrides the default ERC721A _startTokenId() so tokens begin at 1 instead of 0
*/
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @notice Change the royalty fee for the collection
*/
function setRoyaltyFee(uint96 _feeNumerator) external onlyOwner {
}
/**
* @notice Change the royalty address where royalty payouts are sent
*/
function setRoyaltyAddress(address _royaltyAddress) external onlyOwner {
}
/**
* @notice Wraps and exposes publicly _numberMinted() from ERC721A
*/
function numberMinted(address owner) public view returns (uint256) {
}
/**
* @notice Update the base token URI
*/
function setBaseURI(string calldata _newBaseURI) external onlyOwner {
}
/**
* @notice Reduce the max supply of tokens
* @param _newMaxSupply The new maximum supply of tokens available to mint
*/
function reduceMaxSupply(uint256 _newMaxSupply) external onlyOwner {
}
function changePublicSupply(uint256 _newPublicSupply) external onlyOwner {
}
/**
* @notice Freeze metadata so it can never be changed again
*/
function freezeMetadata() external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function publicCounter() public view returns (uint256) {
}
// https://chiru-labs.github.io/ERC721A/#/migration?id=supportsinterface
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC721A, ERC2981, ERC4907A)
returns (bool)
{
}
/**
* @notice Allow owner to send 'mintNumber' tokens without cost to multiple addresses
*/
function gift(address[] calldata receivers, uint256[] calldata mintNumber)
external
onlyOwner
{
}
/**
* @notice To be updated by contract owner to allow public sale minting
*/
function setPublicSaleState(bool _saleActiveState) external onlyOwner {
}
/**
* @notice Update the public mint price
*/
function setPublicPrice(uint256 _publicPrice) external onlyOwner {
}
/**
* @notice Set the maximum public mints allowed per a given transaction
*/
function setPublicMintsAllowedPerTransaction(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Allow for public minting of tokens
*/
function mint(uint256 numTokens)
external
payable
nonReentrant
originalUser
{
}
/**
* @notice Freeze all payout addresses and percentages so they can never be changed again
*/
function freezePayoutAddresses() external onlyOwner {
}
/**
* @notice Update payout addresses and basis points for each addresses' respective share of contract funds
*/
function updatePayoutAddressesAndBasisPoints(
address[] calldata _payoutAddresses,
uint256[] calldata _payoutBasisPoints
) external onlyOwner {
}
/**
* @notice Withdraws all funds held within contract
*/
function withdraw() external nonReentrant onlyOwner {
}
/**
* @notice To be updated by contract owner to allow burning to claim a token
*/
function setBurnClaimState(bool _burnClaimActive) external onlyOwner {
}
/**
* @notice Update the number of free mints claimable per token burned
*/
function updateMintsPerBurn(uint256 _mintsPerBurn) external onlyOwner {
}
function burnmrCollectoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrSpectaculoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrEarly(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrMintoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrkekelessrare(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrtroublemakoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrviboor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrHue(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmr0ccult(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmr0g(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrchargeoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrcheckoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrCheckoormorerare(uint256 amount)
external
nonReentrant
originalUser
{
require(burnClaimActive, "BURN_CLAIM_IS_NOT_ACTIVE");
require(
totalSupply() + (amount * mintsPerBurn) <= MAX_SUPPLY,
"MAX_SUPPLY_EXCEEDED"
);
IERC1155Basic ExternalERC1155BurnContract = IERC1155Basic(
burnToMintContractAddress
);
require(<FILL_ME>)
ExternalERC1155BurnContract.safeTransferFrom( /**tokenID of burn**/
msg.sender,
burnAddress,
15,
amount,
""
);
_safeMint(msg.sender, amount * mintsPerBurn);
}
function burnmrKek(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrSingleCheckoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrBleedoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrBelievoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0gr3y(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0golden(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnImpatient(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0glory(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnActive(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnWealth(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnAbundance(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnhUeye(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnTranquil(uint256 amount)
external
nonReentrant
originalUser
{
}
/**
* update a new burn tokenID to be burned
*/
function updatenewBurnID(uint256 _newBurnID) external onlyOwner {
}
function burnupdatednewBurnXX(uint256 amount)
external
nonReentrant
originalUser
{
}
/**
* @dev Require that the address being approved is not from a blocklisted exchange
*/
modifier onlyAllowedOperatorApproval(address operator) {
}
/**
* @notice Update blocklist contract address to a custom contract address if desired for custom functionality
*/
function updateBlocklistContractAddress(address _blocklistContractAddress)
external
onlyOwner
{
}
/**
* @notice Permanently disable the blocklist so all exchanges are allowed forever
*/
function permanentlyDisableBlocklist() external onlyOwner {
}
/**
* @notice Set or unset an exchange contract address as blocklisted
*/
function updateBlocklistedExchanges(
uint256[] calldata exchanges,
bool[] calldata blocklisted
) external onlyOwner {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 tokenId,
uint256 quantity
) internal override(ERC721A) whenNotPaused {
}
}
interface IERC1155Basic {
function balanceOf(address account, uint256 id)
external
view
returns (uint256);
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data
) external;
}
interface IExchangeOperatorAddressList {
function operatorAddressToExchange(address operatorAddress)
external
view
returns (uint256);
}
| ExternalERC1155BurnContract.balanceOf(msg.sender,15)>=amount,"NOT_ENOUGH_TOKENS_OWNED" | 463,518 | ExternalERC1155BurnContract.balanceOf(msg.sender,15)>=amount |
"NOT_ENOUGH_TOKENS_OWNED" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC4907A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "erc721a/contracts/IERC721A.sol";
import "erc721a/contracts/extensions/IERC4907A.sol";
import "erc721a/contracts/extensions/IERC721AQueryable.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
contract degents is
ERC721A,
ERC721AQueryable,
ERC4907A,
Ownable,
Pausable,
ReentrancyGuard,
ERC2981
{
// Address where burnt tokens are sent
address burnAddress = 0x000000000000000000000000000000000000dEaD;
// Address of the smart contract used to check if an operator address is from a blocklisted exchange
address public blocklistContractAddress;
address public burnToMintContractAddress =
0x3b0Daea2634F111DBA1344768D34e15Ffea8b81f;
address public burnToMintvibeContractAddress =
0x4d8cCf1dDa3fb2731f1D6EfDEF9A5Ab6042B5bb9;
address public royaltyAddress = 0xF5d96c4675ee80E72005A24B7581aF8Aa5b063BA;
address[] public payoutAddresses = [
0xF5d96c4675ee80E72005A24B7581aF8Aa5b063BA
];
// Permanently disable the blocklist so all exchanges are allowed
bool public blocklistPermanentlyDisabled;
// If true tokens can be burned in order to mint
bool public burnClaimActive;
bool public isPublicSaleActive;
// Permanently freezes metadata so it can never be changed
bool public metadataFrozen;
// If true, payout addresses and basis points are permanently frozen and can never be updated
bool public payoutAddressesFrozen;
// If true, the exchange represented by a uint256 integer is blocklisted and cannot be used to transfer tokens
mapping(uint256 => bool) public isExchangeBlocklisted;
string public baseTokenURI =
"";
// Maximum supply of tokens that can be minted
uint256 public MAX_SUPPLY = 10000;
uint256 public PUBLIC_CURRENT_SUPPLY = 7110;
uint256 public PUBLIC_COUNTER;
uint256 public mintsPerBurn = 1;
uint256 public newBurnID;
uint256 public publicMintsAllowedPerTransaction = 3;
uint256 public publicPrice = 0.004 ether;
uint256[] public payoutBasisPoints = [10000];
uint96 public royaltyFee = 500;
constructor(address _blocklistContractAddress) ERC721A("degents", "degents") {
}
modifier originalUser() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev Overrides the default ERC721A _startTokenId() so tokens begin at 1 instead of 0
*/
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @notice Change the royalty fee for the collection
*/
function setRoyaltyFee(uint96 _feeNumerator) external onlyOwner {
}
/**
* @notice Change the royalty address where royalty payouts are sent
*/
function setRoyaltyAddress(address _royaltyAddress) external onlyOwner {
}
/**
* @notice Wraps and exposes publicly _numberMinted() from ERC721A
*/
function numberMinted(address owner) public view returns (uint256) {
}
/**
* @notice Update the base token URI
*/
function setBaseURI(string calldata _newBaseURI) external onlyOwner {
}
/**
* @notice Reduce the max supply of tokens
* @param _newMaxSupply The new maximum supply of tokens available to mint
*/
function reduceMaxSupply(uint256 _newMaxSupply) external onlyOwner {
}
function changePublicSupply(uint256 _newPublicSupply) external onlyOwner {
}
/**
* @notice Freeze metadata so it can never be changed again
*/
function freezeMetadata() external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function publicCounter() public view returns (uint256) {
}
// https://chiru-labs.github.io/ERC721A/#/migration?id=supportsinterface
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC721A, ERC2981, ERC4907A)
returns (bool)
{
}
/**
* @notice Allow owner to send 'mintNumber' tokens without cost to multiple addresses
*/
function gift(address[] calldata receivers, uint256[] calldata mintNumber)
external
onlyOwner
{
}
/**
* @notice To be updated by contract owner to allow public sale minting
*/
function setPublicSaleState(bool _saleActiveState) external onlyOwner {
}
/**
* @notice Update the public mint price
*/
function setPublicPrice(uint256 _publicPrice) external onlyOwner {
}
/**
* @notice Set the maximum public mints allowed per a given transaction
*/
function setPublicMintsAllowedPerTransaction(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Allow for public minting of tokens
*/
function mint(uint256 numTokens)
external
payable
nonReentrant
originalUser
{
}
/**
* @notice Freeze all payout addresses and percentages so they can never be changed again
*/
function freezePayoutAddresses() external onlyOwner {
}
/**
* @notice Update payout addresses and basis points for each addresses' respective share of contract funds
*/
function updatePayoutAddressesAndBasisPoints(
address[] calldata _payoutAddresses,
uint256[] calldata _payoutBasisPoints
) external onlyOwner {
}
/**
* @notice Withdraws all funds held within contract
*/
function withdraw() external nonReentrant onlyOwner {
}
/**
* @notice To be updated by contract owner to allow burning to claim a token
*/
function setBurnClaimState(bool _burnClaimActive) external onlyOwner {
}
/**
* @notice Update the number of free mints claimable per token burned
*/
function updateMintsPerBurn(uint256 _mintsPerBurn) external onlyOwner {
}
function burnmrCollectoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrSpectaculoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrEarly(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrMintoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrkekelessrare(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrtroublemakoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrviboor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrHue(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmr0ccult(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmr0g(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrchargeoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrcheckoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrCheckoormorerare(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrKek(uint256 amount)
external
nonReentrant
originalUser
{
require(burnClaimActive, "BURN_CLAIM_IS_NOT_ACTIVE");
require(
totalSupply() + (amount * mintsPerBurn) <= MAX_SUPPLY,
"MAX_SUPPLY_EXCEEDED"
);
IERC1155Basic ExternalERC1155BurnContract = IERC1155Basic(
burnToMintContractAddress
);
require(<FILL_ME>)
ExternalERC1155BurnContract.safeTransferFrom( /**tokenID of burn**/
msg.sender,
burnAddress,
12,
amount,
""
);
_safeMint(msg.sender, amount * mintsPerBurn);
}
function burnmrSingleCheckoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrBleedoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrBelievoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0gr3y(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0golden(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnImpatient(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0glory(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnActive(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnWealth(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnAbundance(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnhUeye(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnTranquil(uint256 amount)
external
nonReentrant
originalUser
{
}
/**
* update a new burn tokenID to be burned
*/
function updatenewBurnID(uint256 _newBurnID) external onlyOwner {
}
function burnupdatednewBurnXX(uint256 amount)
external
nonReentrant
originalUser
{
}
/**
* @dev Require that the address being approved is not from a blocklisted exchange
*/
modifier onlyAllowedOperatorApproval(address operator) {
}
/**
* @notice Update blocklist contract address to a custom contract address if desired for custom functionality
*/
function updateBlocklistContractAddress(address _blocklistContractAddress)
external
onlyOwner
{
}
/**
* @notice Permanently disable the blocklist so all exchanges are allowed forever
*/
function permanentlyDisableBlocklist() external onlyOwner {
}
/**
* @notice Set or unset an exchange contract address as blocklisted
*/
function updateBlocklistedExchanges(
uint256[] calldata exchanges,
bool[] calldata blocklisted
) external onlyOwner {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 tokenId,
uint256 quantity
) internal override(ERC721A) whenNotPaused {
}
}
interface IERC1155Basic {
function balanceOf(address account, uint256 id)
external
view
returns (uint256);
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data
) external;
}
interface IExchangeOperatorAddressList {
function operatorAddressToExchange(address operatorAddress)
external
view
returns (uint256);
}
| ExternalERC1155BurnContract.balanceOf(msg.sender,12)>=amount,"NOT_ENOUGH_TOKENS_OWNED" | 463,518 | ExternalERC1155BurnContract.balanceOf(msg.sender,12)>=amount |
"NOT_ENOUGH_TOKENS_OWNED" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC4907A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "erc721a/contracts/IERC721A.sol";
import "erc721a/contracts/extensions/IERC4907A.sol";
import "erc721a/contracts/extensions/IERC721AQueryable.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
contract degents is
ERC721A,
ERC721AQueryable,
ERC4907A,
Ownable,
Pausable,
ReentrancyGuard,
ERC2981
{
// Address where burnt tokens are sent
address burnAddress = 0x000000000000000000000000000000000000dEaD;
// Address of the smart contract used to check if an operator address is from a blocklisted exchange
address public blocklistContractAddress;
address public burnToMintContractAddress =
0x3b0Daea2634F111DBA1344768D34e15Ffea8b81f;
address public burnToMintvibeContractAddress =
0x4d8cCf1dDa3fb2731f1D6EfDEF9A5Ab6042B5bb9;
address public royaltyAddress = 0xF5d96c4675ee80E72005A24B7581aF8Aa5b063BA;
address[] public payoutAddresses = [
0xF5d96c4675ee80E72005A24B7581aF8Aa5b063BA
];
// Permanently disable the blocklist so all exchanges are allowed
bool public blocklistPermanentlyDisabled;
// If true tokens can be burned in order to mint
bool public burnClaimActive;
bool public isPublicSaleActive;
// Permanently freezes metadata so it can never be changed
bool public metadataFrozen;
// If true, payout addresses and basis points are permanently frozen and can never be updated
bool public payoutAddressesFrozen;
// If true, the exchange represented by a uint256 integer is blocklisted and cannot be used to transfer tokens
mapping(uint256 => bool) public isExchangeBlocklisted;
string public baseTokenURI =
"";
// Maximum supply of tokens that can be minted
uint256 public MAX_SUPPLY = 10000;
uint256 public PUBLIC_CURRENT_SUPPLY = 7110;
uint256 public PUBLIC_COUNTER;
uint256 public mintsPerBurn = 1;
uint256 public newBurnID;
uint256 public publicMintsAllowedPerTransaction = 3;
uint256 public publicPrice = 0.004 ether;
uint256[] public payoutBasisPoints = [10000];
uint96 public royaltyFee = 500;
constructor(address _blocklistContractAddress) ERC721A("degents", "degents") {
}
modifier originalUser() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev Overrides the default ERC721A _startTokenId() so tokens begin at 1 instead of 0
*/
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @notice Change the royalty fee for the collection
*/
function setRoyaltyFee(uint96 _feeNumerator) external onlyOwner {
}
/**
* @notice Change the royalty address where royalty payouts are sent
*/
function setRoyaltyAddress(address _royaltyAddress) external onlyOwner {
}
/**
* @notice Wraps and exposes publicly _numberMinted() from ERC721A
*/
function numberMinted(address owner) public view returns (uint256) {
}
/**
* @notice Update the base token URI
*/
function setBaseURI(string calldata _newBaseURI) external onlyOwner {
}
/**
* @notice Reduce the max supply of tokens
* @param _newMaxSupply The new maximum supply of tokens available to mint
*/
function reduceMaxSupply(uint256 _newMaxSupply) external onlyOwner {
}
function changePublicSupply(uint256 _newPublicSupply) external onlyOwner {
}
/**
* @notice Freeze metadata so it can never be changed again
*/
function freezeMetadata() external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function publicCounter() public view returns (uint256) {
}
// https://chiru-labs.github.io/ERC721A/#/migration?id=supportsinterface
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC721A, ERC2981, ERC4907A)
returns (bool)
{
}
/**
* @notice Allow owner to send 'mintNumber' tokens without cost to multiple addresses
*/
function gift(address[] calldata receivers, uint256[] calldata mintNumber)
external
onlyOwner
{
}
/**
* @notice To be updated by contract owner to allow public sale minting
*/
function setPublicSaleState(bool _saleActiveState) external onlyOwner {
}
/**
* @notice Update the public mint price
*/
function setPublicPrice(uint256 _publicPrice) external onlyOwner {
}
/**
* @notice Set the maximum public mints allowed per a given transaction
*/
function setPublicMintsAllowedPerTransaction(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Allow for public minting of tokens
*/
function mint(uint256 numTokens)
external
payable
nonReentrant
originalUser
{
}
/**
* @notice Freeze all payout addresses and percentages so they can never be changed again
*/
function freezePayoutAddresses() external onlyOwner {
}
/**
* @notice Update payout addresses and basis points for each addresses' respective share of contract funds
*/
function updatePayoutAddressesAndBasisPoints(
address[] calldata _payoutAddresses,
uint256[] calldata _payoutBasisPoints
) external onlyOwner {
}
/**
* @notice Withdraws all funds held within contract
*/
function withdraw() external nonReentrant onlyOwner {
}
/**
* @notice To be updated by contract owner to allow burning to claim a token
*/
function setBurnClaimState(bool _burnClaimActive) external onlyOwner {
}
/**
* @notice Update the number of free mints claimable per token burned
*/
function updateMintsPerBurn(uint256 _mintsPerBurn) external onlyOwner {
}
function burnmrCollectoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrSpectaculoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrEarly(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrMintoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrkekelessrare(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrtroublemakoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrviboor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrHue(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmr0ccult(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmr0g(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrchargeoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrcheckoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrCheckoormorerare(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrKek(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrSingleCheckoor(uint256 amount)
external
nonReentrant
originalUser
{
require(burnClaimActive, "BURN_CLAIM_IS_NOT_ACTIVE");
require(
totalSupply() + (amount * mintsPerBurn) <= MAX_SUPPLY,
"MAX_SUPPLY_EXCEEDED"
);
IERC1155Basic ExternalERC1155BurnContract = IERC1155Basic(
burnToMintContractAddress
);
require(<FILL_ME>)
ExternalERC1155BurnContract.safeTransferFrom( /**tokenID of burn**/
msg.sender,
burnAddress,
14,
amount,
""
);
_safeMint(msg.sender, amount * mintsPerBurn);
}
function burnmrBleedoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrBelievoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0gr3y(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0golden(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnImpatient(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0glory(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnActive(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnWealth(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnAbundance(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnhUeye(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnTranquil(uint256 amount)
external
nonReentrant
originalUser
{
}
/**
* update a new burn tokenID to be burned
*/
function updatenewBurnID(uint256 _newBurnID) external onlyOwner {
}
function burnupdatednewBurnXX(uint256 amount)
external
nonReentrant
originalUser
{
}
/**
* @dev Require that the address being approved is not from a blocklisted exchange
*/
modifier onlyAllowedOperatorApproval(address operator) {
}
/**
* @notice Update blocklist contract address to a custom contract address if desired for custom functionality
*/
function updateBlocklistContractAddress(address _blocklistContractAddress)
external
onlyOwner
{
}
/**
* @notice Permanently disable the blocklist so all exchanges are allowed forever
*/
function permanentlyDisableBlocklist() external onlyOwner {
}
/**
* @notice Set or unset an exchange contract address as blocklisted
*/
function updateBlocklistedExchanges(
uint256[] calldata exchanges,
bool[] calldata blocklisted
) external onlyOwner {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 tokenId,
uint256 quantity
) internal override(ERC721A) whenNotPaused {
}
}
interface IERC1155Basic {
function balanceOf(address account, uint256 id)
external
view
returns (uint256);
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data
) external;
}
interface IExchangeOperatorAddressList {
function operatorAddressToExchange(address operatorAddress)
external
view
returns (uint256);
}
| ExternalERC1155BurnContract.balanceOf(msg.sender,14)>=amount,"NOT_ENOUGH_TOKENS_OWNED" | 463,518 | ExternalERC1155BurnContract.balanceOf(msg.sender,14)>=amount |
"NOT_ENOUGH_TOKENS_OWNED" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC4907A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "erc721a/contracts/IERC721A.sol";
import "erc721a/contracts/extensions/IERC4907A.sol";
import "erc721a/contracts/extensions/IERC721AQueryable.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
contract degents is
ERC721A,
ERC721AQueryable,
ERC4907A,
Ownable,
Pausable,
ReentrancyGuard,
ERC2981
{
// Address where burnt tokens are sent
address burnAddress = 0x000000000000000000000000000000000000dEaD;
// Address of the smart contract used to check if an operator address is from a blocklisted exchange
address public blocklistContractAddress;
address public burnToMintContractAddress =
0x3b0Daea2634F111DBA1344768D34e15Ffea8b81f;
address public burnToMintvibeContractAddress =
0x4d8cCf1dDa3fb2731f1D6EfDEF9A5Ab6042B5bb9;
address public royaltyAddress = 0xF5d96c4675ee80E72005A24B7581aF8Aa5b063BA;
address[] public payoutAddresses = [
0xF5d96c4675ee80E72005A24B7581aF8Aa5b063BA
];
// Permanently disable the blocklist so all exchanges are allowed
bool public blocklistPermanentlyDisabled;
// If true tokens can be burned in order to mint
bool public burnClaimActive;
bool public isPublicSaleActive;
// Permanently freezes metadata so it can never be changed
bool public metadataFrozen;
// If true, payout addresses and basis points are permanently frozen and can never be updated
bool public payoutAddressesFrozen;
// If true, the exchange represented by a uint256 integer is blocklisted and cannot be used to transfer tokens
mapping(uint256 => bool) public isExchangeBlocklisted;
string public baseTokenURI =
"";
// Maximum supply of tokens that can be minted
uint256 public MAX_SUPPLY = 10000;
uint256 public PUBLIC_CURRENT_SUPPLY = 7110;
uint256 public PUBLIC_COUNTER;
uint256 public mintsPerBurn = 1;
uint256 public newBurnID;
uint256 public publicMintsAllowedPerTransaction = 3;
uint256 public publicPrice = 0.004 ether;
uint256[] public payoutBasisPoints = [10000];
uint96 public royaltyFee = 500;
constructor(address _blocklistContractAddress) ERC721A("degents", "degents") {
}
modifier originalUser() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev Overrides the default ERC721A _startTokenId() so tokens begin at 1 instead of 0
*/
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @notice Change the royalty fee for the collection
*/
function setRoyaltyFee(uint96 _feeNumerator) external onlyOwner {
}
/**
* @notice Change the royalty address where royalty payouts are sent
*/
function setRoyaltyAddress(address _royaltyAddress) external onlyOwner {
}
/**
* @notice Wraps and exposes publicly _numberMinted() from ERC721A
*/
function numberMinted(address owner) public view returns (uint256) {
}
/**
* @notice Update the base token URI
*/
function setBaseURI(string calldata _newBaseURI) external onlyOwner {
}
/**
* @notice Reduce the max supply of tokens
* @param _newMaxSupply The new maximum supply of tokens available to mint
*/
function reduceMaxSupply(uint256 _newMaxSupply) external onlyOwner {
}
function changePublicSupply(uint256 _newPublicSupply) external onlyOwner {
}
/**
* @notice Freeze metadata so it can never be changed again
*/
function freezeMetadata() external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function publicCounter() public view returns (uint256) {
}
// https://chiru-labs.github.io/ERC721A/#/migration?id=supportsinterface
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC721A, ERC2981, ERC4907A)
returns (bool)
{
}
/**
* @notice Allow owner to send 'mintNumber' tokens without cost to multiple addresses
*/
function gift(address[] calldata receivers, uint256[] calldata mintNumber)
external
onlyOwner
{
}
/**
* @notice To be updated by contract owner to allow public sale minting
*/
function setPublicSaleState(bool _saleActiveState) external onlyOwner {
}
/**
* @notice Update the public mint price
*/
function setPublicPrice(uint256 _publicPrice) external onlyOwner {
}
/**
* @notice Set the maximum public mints allowed per a given transaction
*/
function setPublicMintsAllowedPerTransaction(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Allow for public minting of tokens
*/
function mint(uint256 numTokens)
external
payable
nonReentrant
originalUser
{
}
/**
* @notice Freeze all payout addresses and percentages so they can never be changed again
*/
function freezePayoutAddresses() external onlyOwner {
}
/**
* @notice Update payout addresses and basis points for each addresses' respective share of contract funds
*/
function updatePayoutAddressesAndBasisPoints(
address[] calldata _payoutAddresses,
uint256[] calldata _payoutBasisPoints
) external onlyOwner {
}
/**
* @notice Withdraws all funds held within contract
*/
function withdraw() external nonReentrant onlyOwner {
}
/**
* @notice To be updated by contract owner to allow burning to claim a token
*/
function setBurnClaimState(bool _burnClaimActive) external onlyOwner {
}
/**
* @notice Update the number of free mints claimable per token burned
*/
function updateMintsPerBurn(uint256 _mintsPerBurn) external onlyOwner {
}
function burnmrCollectoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrSpectaculoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrEarly(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrMintoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrkekelessrare(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrtroublemakoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrviboor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrHue(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmr0ccult(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmr0g(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrchargeoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrcheckoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrCheckoormorerare(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrKek(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrSingleCheckoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrBleedoor(uint256 amount)
external
nonReentrant
originalUser
{
require(burnClaimActive, "BURN_CLAIM_IS_NOT_ACTIVE");
require(
totalSupply() + (amount * mintsPerBurn) <= MAX_SUPPLY,
"MAX_SUPPLY_EXCEEDED"
);
IERC1155Basic ExternalERC1155BurnContract = IERC1155Basic(
burnToMintContractAddress
);
require(<FILL_ME>)
ExternalERC1155BurnContract.safeTransferFrom( /**tokenID of burn**/
msg.sender,
burnAddress,
18,
amount,
""
);
_safeMint(msg.sender, amount * mintsPerBurn);
}
function burnmrBelievoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0gr3y(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0golden(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnImpatient(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0glory(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnActive(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnWealth(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnAbundance(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnhUeye(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnTranquil(uint256 amount)
external
nonReentrant
originalUser
{
}
/**
* update a new burn tokenID to be burned
*/
function updatenewBurnID(uint256 _newBurnID) external onlyOwner {
}
function burnupdatednewBurnXX(uint256 amount)
external
nonReentrant
originalUser
{
}
/**
* @dev Require that the address being approved is not from a blocklisted exchange
*/
modifier onlyAllowedOperatorApproval(address operator) {
}
/**
* @notice Update blocklist contract address to a custom contract address if desired for custom functionality
*/
function updateBlocklistContractAddress(address _blocklistContractAddress)
external
onlyOwner
{
}
/**
* @notice Permanently disable the blocklist so all exchanges are allowed forever
*/
function permanentlyDisableBlocklist() external onlyOwner {
}
/**
* @notice Set or unset an exchange contract address as blocklisted
*/
function updateBlocklistedExchanges(
uint256[] calldata exchanges,
bool[] calldata blocklisted
) external onlyOwner {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 tokenId,
uint256 quantity
) internal override(ERC721A) whenNotPaused {
}
}
interface IERC1155Basic {
function balanceOf(address account, uint256 id)
external
view
returns (uint256);
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data
) external;
}
interface IExchangeOperatorAddressList {
function operatorAddressToExchange(address operatorAddress)
external
view
returns (uint256);
}
| ExternalERC1155BurnContract.balanceOf(msg.sender,18)>=amount,"NOT_ENOUGH_TOKENS_OWNED" | 463,518 | ExternalERC1155BurnContract.balanceOf(msg.sender,18)>=amount |
"NOT_ENOUGH_TOKENS_OWNED" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC4907A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "erc721a/contracts/IERC721A.sol";
import "erc721a/contracts/extensions/IERC4907A.sol";
import "erc721a/contracts/extensions/IERC721AQueryable.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
contract degents is
ERC721A,
ERC721AQueryable,
ERC4907A,
Ownable,
Pausable,
ReentrancyGuard,
ERC2981
{
// Address where burnt tokens are sent
address burnAddress = 0x000000000000000000000000000000000000dEaD;
// Address of the smart contract used to check if an operator address is from a blocklisted exchange
address public blocklistContractAddress;
address public burnToMintContractAddress =
0x3b0Daea2634F111DBA1344768D34e15Ffea8b81f;
address public burnToMintvibeContractAddress =
0x4d8cCf1dDa3fb2731f1D6EfDEF9A5Ab6042B5bb9;
address public royaltyAddress = 0xF5d96c4675ee80E72005A24B7581aF8Aa5b063BA;
address[] public payoutAddresses = [
0xF5d96c4675ee80E72005A24B7581aF8Aa5b063BA
];
// Permanently disable the blocklist so all exchanges are allowed
bool public blocklistPermanentlyDisabled;
// If true tokens can be burned in order to mint
bool public burnClaimActive;
bool public isPublicSaleActive;
// Permanently freezes metadata so it can never be changed
bool public metadataFrozen;
// If true, payout addresses and basis points are permanently frozen and can never be updated
bool public payoutAddressesFrozen;
// If true, the exchange represented by a uint256 integer is blocklisted and cannot be used to transfer tokens
mapping(uint256 => bool) public isExchangeBlocklisted;
string public baseTokenURI =
"";
// Maximum supply of tokens that can be minted
uint256 public MAX_SUPPLY = 10000;
uint256 public PUBLIC_CURRENT_SUPPLY = 7110;
uint256 public PUBLIC_COUNTER;
uint256 public mintsPerBurn = 1;
uint256 public newBurnID;
uint256 public publicMintsAllowedPerTransaction = 3;
uint256 public publicPrice = 0.004 ether;
uint256[] public payoutBasisPoints = [10000];
uint96 public royaltyFee = 500;
constructor(address _blocklistContractAddress) ERC721A("degents", "degents") {
}
modifier originalUser() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev Overrides the default ERC721A _startTokenId() so tokens begin at 1 instead of 0
*/
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @notice Change the royalty fee for the collection
*/
function setRoyaltyFee(uint96 _feeNumerator) external onlyOwner {
}
/**
* @notice Change the royalty address where royalty payouts are sent
*/
function setRoyaltyAddress(address _royaltyAddress) external onlyOwner {
}
/**
* @notice Wraps and exposes publicly _numberMinted() from ERC721A
*/
function numberMinted(address owner) public view returns (uint256) {
}
/**
* @notice Update the base token URI
*/
function setBaseURI(string calldata _newBaseURI) external onlyOwner {
}
/**
* @notice Reduce the max supply of tokens
* @param _newMaxSupply The new maximum supply of tokens available to mint
*/
function reduceMaxSupply(uint256 _newMaxSupply) external onlyOwner {
}
function changePublicSupply(uint256 _newPublicSupply) external onlyOwner {
}
/**
* @notice Freeze metadata so it can never be changed again
*/
function freezeMetadata() external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function publicCounter() public view returns (uint256) {
}
// https://chiru-labs.github.io/ERC721A/#/migration?id=supportsinterface
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC721A, ERC2981, ERC4907A)
returns (bool)
{
}
/**
* @notice Allow owner to send 'mintNumber' tokens without cost to multiple addresses
*/
function gift(address[] calldata receivers, uint256[] calldata mintNumber)
external
onlyOwner
{
}
/**
* @notice To be updated by contract owner to allow public sale minting
*/
function setPublicSaleState(bool _saleActiveState) external onlyOwner {
}
/**
* @notice Update the public mint price
*/
function setPublicPrice(uint256 _publicPrice) external onlyOwner {
}
/**
* @notice Set the maximum public mints allowed per a given transaction
*/
function setPublicMintsAllowedPerTransaction(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Allow for public minting of tokens
*/
function mint(uint256 numTokens)
external
payable
nonReentrant
originalUser
{
}
/**
* @notice Freeze all payout addresses and percentages so they can never be changed again
*/
function freezePayoutAddresses() external onlyOwner {
}
/**
* @notice Update payout addresses and basis points for each addresses' respective share of contract funds
*/
function updatePayoutAddressesAndBasisPoints(
address[] calldata _payoutAddresses,
uint256[] calldata _payoutBasisPoints
) external onlyOwner {
}
/**
* @notice Withdraws all funds held within contract
*/
function withdraw() external nonReentrant onlyOwner {
}
/**
* @notice To be updated by contract owner to allow burning to claim a token
*/
function setBurnClaimState(bool _burnClaimActive) external onlyOwner {
}
/**
* @notice Update the number of free mints claimable per token burned
*/
function updateMintsPerBurn(uint256 _mintsPerBurn) external onlyOwner {
}
function burnmrCollectoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrSpectaculoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrEarly(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrMintoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrkekelessrare(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrtroublemakoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrviboor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrHue(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmr0ccult(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmr0g(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrchargeoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrcheckoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrCheckoormorerare(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrKek(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrSingleCheckoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrBleedoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrBelievoor(uint256 amount)
external
nonReentrant
originalUser
{
require(burnClaimActive, "BURN_CLAIM_IS_NOT_ACTIVE");
require(
totalSupply() + (amount * mintsPerBurn) <= MAX_SUPPLY,
"MAX_SUPPLY_EXCEEDED"
);
IERC1155Basic ExternalERC1155BurnContract = IERC1155Basic(
burnToMintContractAddress
);
require(<FILL_ME>)
ExternalERC1155BurnContract.safeTransferFrom( /**tokenID of burn**/
msg.sender,
burnAddress,
5,
amount,
""
);
_safeMint(msg.sender, amount * mintsPerBurn);
}
function burn0gr3y(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0golden(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnImpatient(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0glory(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnActive(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnWealth(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnAbundance(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnhUeye(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnTranquil(uint256 amount)
external
nonReentrant
originalUser
{
}
/**
* update a new burn tokenID to be burned
*/
function updatenewBurnID(uint256 _newBurnID) external onlyOwner {
}
function burnupdatednewBurnXX(uint256 amount)
external
nonReentrant
originalUser
{
}
/**
* @dev Require that the address being approved is not from a blocklisted exchange
*/
modifier onlyAllowedOperatorApproval(address operator) {
}
/**
* @notice Update blocklist contract address to a custom contract address if desired for custom functionality
*/
function updateBlocklistContractAddress(address _blocklistContractAddress)
external
onlyOwner
{
}
/**
* @notice Permanently disable the blocklist so all exchanges are allowed forever
*/
function permanentlyDisableBlocklist() external onlyOwner {
}
/**
* @notice Set or unset an exchange contract address as blocklisted
*/
function updateBlocklistedExchanges(
uint256[] calldata exchanges,
bool[] calldata blocklisted
) external onlyOwner {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 tokenId,
uint256 quantity
) internal override(ERC721A) whenNotPaused {
}
}
interface IERC1155Basic {
function balanceOf(address account, uint256 id)
external
view
returns (uint256);
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data
) external;
}
interface IExchangeOperatorAddressList {
function operatorAddressToExchange(address operatorAddress)
external
view
returns (uint256);
}
| ExternalERC1155BurnContract.balanceOf(msg.sender,5)>=amount,"NOT_ENOUGH_TOKENS_OWNED" | 463,518 | ExternalERC1155BurnContract.balanceOf(msg.sender,5)>=amount |
"NOT_ENOUGH_TOKENS_OWNED" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC4907A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "erc721a/contracts/IERC721A.sol";
import "erc721a/contracts/extensions/IERC4907A.sol";
import "erc721a/contracts/extensions/IERC721AQueryable.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
contract degents is
ERC721A,
ERC721AQueryable,
ERC4907A,
Ownable,
Pausable,
ReentrancyGuard,
ERC2981
{
// Address where burnt tokens are sent
address burnAddress = 0x000000000000000000000000000000000000dEaD;
// Address of the smart contract used to check if an operator address is from a blocklisted exchange
address public blocklistContractAddress;
address public burnToMintContractAddress =
0x3b0Daea2634F111DBA1344768D34e15Ffea8b81f;
address public burnToMintvibeContractAddress =
0x4d8cCf1dDa3fb2731f1D6EfDEF9A5Ab6042B5bb9;
address public royaltyAddress = 0xF5d96c4675ee80E72005A24B7581aF8Aa5b063BA;
address[] public payoutAddresses = [
0xF5d96c4675ee80E72005A24B7581aF8Aa5b063BA
];
// Permanently disable the blocklist so all exchanges are allowed
bool public blocklistPermanentlyDisabled;
// If true tokens can be burned in order to mint
bool public burnClaimActive;
bool public isPublicSaleActive;
// Permanently freezes metadata so it can never be changed
bool public metadataFrozen;
// If true, payout addresses and basis points are permanently frozen and can never be updated
bool public payoutAddressesFrozen;
// If true, the exchange represented by a uint256 integer is blocklisted and cannot be used to transfer tokens
mapping(uint256 => bool) public isExchangeBlocklisted;
string public baseTokenURI =
"";
// Maximum supply of tokens that can be minted
uint256 public MAX_SUPPLY = 10000;
uint256 public PUBLIC_CURRENT_SUPPLY = 7110;
uint256 public PUBLIC_COUNTER;
uint256 public mintsPerBurn = 1;
uint256 public newBurnID;
uint256 public publicMintsAllowedPerTransaction = 3;
uint256 public publicPrice = 0.004 ether;
uint256[] public payoutBasisPoints = [10000];
uint96 public royaltyFee = 500;
constructor(address _blocklistContractAddress) ERC721A("degents", "degents") {
}
modifier originalUser() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev Overrides the default ERC721A _startTokenId() so tokens begin at 1 instead of 0
*/
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @notice Change the royalty fee for the collection
*/
function setRoyaltyFee(uint96 _feeNumerator) external onlyOwner {
}
/**
* @notice Change the royalty address where royalty payouts are sent
*/
function setRoyaltyAddress(address _royaltyAddress) external onlyOwner {
}
/**
* @notice Wraps and exposes publicly _numberMinted() from ERC721A
*/
function numberMinted(address owner) public view returns (uint256) {
}
/**
* @notice Update the base token URI
*/
function setBaseURI(string calldata _newBaseURI) external onlyOwner {
}
/**
* @notice Reduce the max supply of tokens
* @param _newMaxSupply The new maximum supply of tokens available to mint
*/
function reduceMaxSupply(uint256 _newMaxSupply) external onlyOwner {
}
function changePublicSupply(uint256 _newPublicSupply) external onlyOwner {
}
/**
* @notice Freeze metadata so it can never be changed again
*/
function freezeMetadata() external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function publicCounter() public view returns (uint256) {
}
// https://chiru-labs.github.io/ERC721A/#/migration?id=supportsinterface
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC721A, ERC2981, ERC4907A)
returns (bool)
{
}
/**
* @notice Allow owner to send 'mintNumber' tokens without cost to multiple addresses
*/
function gift(address[] calldata receivers, uint256[] calldata mintNumber)
external
onlyOwner
{
}
/**
* @notice To be updated by contract owner to allow public sale minting
*/
function setPublicSaleState(bool _saleActiveState) external onlyOwner {
}
/**
* @notice Update the public mint price
*/
function setPublicPrice(uint256 _publicPrice) external onlyOwner {
}
/**
* @notice Set the maximum public mints allowed per a given transaction
*/
function setPublicMintsAllowedPerTransaction(uint256 _mintsAllowed)
external
onlyOwner
{
}
/**
* @notice Allow for public minting of tokens
*/
function mint(uint256 numTokens)
external
payable
nonReentrant
originalUser
{
}
/**
* @notice Freeze all payout addresses and percentages so they can never be changed again
*/
function freezePayoutAddresses() external onlyOwner {
}
/**
* @notice Update payout addresses and basis points for each addresses' respective share of contract funds
*/
function updatePayoutAddressesAndBasisPoints(
address[] calldata _payoutAddresses,
uint256[] calldata _payoutBasisPoints
) external onlyOwner {
}
/**
* @notice Withdraws all funds held within contract
*/
function withdraw() external nonReentrant onlyOwner {
}
/**
* @notice To be updated by contract owner to allow burning to claim a token
*/
function setBurnClaimState(bool _burnClaimActive) external onlyOwner {
}
/**
* @notice Update the number of free mints claimable per token burned
*/
function updateMintsPerBurn(uint256 _mintsPerBurn) external onlyOwner {
}
function burnmrCollectoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrSpectaculoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrEarly(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrMintoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrkekelessrare(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrtroublemakoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrviboor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrHue(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmr0ccult(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmr0g(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrchargeoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrcheckoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrCheckoormorerare(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrKek(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrSingleCheckoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrBleedoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnmrBelievoor(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0gr3y(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0golden(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnImpatient(uint256 amount)
external
nonReentrant
originalUser
{
}
function burn0glory(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnActive(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnWealth(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnAbundance(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnhUeye(uint256 amount)
external
nonReentrant
originalUser
{
}
function burnTranquil(uint256 amount)
external
nonReentrant
originalUser
{
}
/**
* update a new burn tokenID to be burned
*/
function updatenewBurnID(uint256 _newBurnID) external onlyOwner {
}
function burnupdatednewBurnXX(uint256 amount)
external
nonReentrant
originalUser
{
require(burnClaimActive, "BURN_CLAIM_IS_NOT_ACTIVE");
require(
totalSupply() + (amount * mintsPerBurn) <= MAX_SUPPLY,
"MAX_SUPPLY_EXCEEDED"
);
IERC1155Basic ExternalERC1155BurnContract = IERC1155Basic(
burnToMintContractAddress
);
require(<FILL_ME>)
ExternalERC1155BurnContract.safeTransferFrom( /**tokenID of burn**/
msg.sender,
burnAddress,
newBurnID,
amount,
""
);
_safeMint(msg.sender, amount * mintsPerBurn);
}
/**
* @dev Require that the address being approved is not from a blocklisted exchange
*/
modifier onlyAllowedOperatorApproval(address operator) {
}
/**
* @notice Update blocklist contract address to a custom contract address if desired for custom functionality
*/
function updateBlocklistContractAddress(address _blocklistContractAddress)
external
onlyOwner
{
}
/**
* @notice Permanently disable the blocklist so all exchanges are allowed forever
*/
function permanentlyDisableBlocklist() external onlyOwner {
}
/**
* @notice Set or unset an exchange contract address as blocklisted
*/
function updateBlocklistedExchanges(
uint256[] calldata exchanges,
bool[] calldata blocklisted
) external onlyOwner {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 tokenId,
uint256 quantity
) internal override(ERC721A) whenNotPaused {
}
}
interface IERC1155Basic {
function balanceOf(address account, uint256 id)
external
view
returns (uint256);
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data
) external;
}
interface IExchangeOperatorAddressList {
function operatorAddressToExchange(address operatorAddress)
external
view
returns (uint256);
}
| ExternalERC1155BurnContract.balanceOf(msg.sender,newBurnID)>=amount,"NOT_ENOUGH_TOKENS_OWNED" | 463,518 | ExternalERC1155BurnContract.balanceOf(msg.sender,newBurnID)>=amount |
"ERC721/RECIPIENT_LOCKED" | // SPDX-License-Identifier: AGPL-3.0
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165Storage.sol";
interface ERC721SimpleProceedsExtensionInterface {
function setProceedsRecipient(address _proceedsRecipient) external;
function lockProceedsRecipient() external;
function withdraw() external;
}
/**
* @dev Extension to allow contract owner to withdraw all the funds directly.
*/
abstract contract ERC721SimpleProceedsExtension is
Ownable,
ERC165Storage,
ERC721SimpleProceedsExtensionInterface
{
address public proceedsRecipient;
bool public proceedsRecipientLocked;
constructor() {
}
// ADMIN
function setProceedsRecipient(address _proceedsRecipient)
external
onlyOwner
{
require(<FILL_ME>)
proceedsRecipient = _proceedsRecipient;
}
function lockProceedsRecipient() external onlyOwner {
}
function withdraw() external {
}
// PUBLIC
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC165Storage)
returns (bool)
{
}
}
| !proceedsRecipientLocked,"ERC721/RECIPIENT_LOCKED" | 463,532 | !proceedsRecipientLocked |
null | /**
*Submitted for verification at Etherscan.io on 2019-04-25
*/
pragma solidity ^0.5;
contract ERC20xVariables {
address public creator;
address public lib;
uint256 constant public MAX_UINT256 = 2**256 - 1;
mapping(address => uint) public balances;
mapping(address => mapping(address => uint)) public allowed;
uint8 public constant decimals = 18;
string public name;
string public symbol;
uint public totalSupply;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Created(address creator, uint supply);
function balanceOf(address _owner) public view returns (uint256 balance) {
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
}
}
contract ERC20x is ERC20xVariables {
function transfer(address _to, uint256 _value) public returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
function approve(address _spender, uint256 _value) public returns (bool success) {
}
function transferToContract(address _to, uint256 _value, bytes memory data) public returns (bool) {
}
function _transferBalance(address _from, address _to, uint _value) internal {
}
}
contract BidderInterface {
function receiveETH(address series, uint256 amount) public;
function receiveUSD(address series, uint256 amount) public;
}
contract VariableSupplyToken is ERC20x {
function grant(address to, uint256 amount) public returns (bool) {
require(msg.sender == creator);
require(<FILL_ME>)
balances[to] += amount;
totalSupply += amount;
return true;
}
function burn(address from, uint amount) public returns (bool) {
}
}
contract OptionToken is VariableSupplyToken {
constructor(string memory _name, string memory _symbol) public {
}
}
contract Protocol {
address public lib;
ERC20x public usdERC20;
ERC20x public protocolToken;
// We use "flavor" because type is a reserved word in many programming languages
enum Flavor {
Call,
Put
}
struct OptionSeries {
uint expiration;
Flavor flavor;
uint strike;
}
uint public constant DURATION = 12 hours;
uint public constant HALF_DURATION = DURATION / 2;
mapping(address => uint) public openInterest;
mapping(address => uint) public earlyExercised;
mapping(address => uint) public totalInterest;
mapping(address => mapping(address => uint)) public writers;
mapping(address => OptionSeries) public seriesInfo;
mapping(address => uint) public holdersSettlement;
mapping(address => uint) public expectValue;
bool isAuction;
uint public constant ONE_MILLION = 1000000;
// maximum token holder rights capped at 3.7% of total supply?
// Why 3.7%?
// I could make up some fancy explanation
// and use the phrase "byzantine fault tolerance" somehow
// Or I could just say that 3.7% allows for a total of 27 independent actors
// that are all receiving the maximum benefit, and it solves all the other
// issues of disincentivizing centralization and "rich get richer" mechanics, so I chose 27 'cause it just has a nice "decentralized" feel to it.
// 21 would have been fine, as few as ten probably would have been ok 'cause people can just pool anyways
// up to a thousand or so probably wouldn't have hurt either.
// In the end it really doesn't matter as long as the game ends up being played fairly.
// I'm sure someone will take my system and parameterize it differently at some point and bill it as a totally new product.
uint public constant PREFERENCE_MAX = 0.037 ether;
constructor(address _token, address _usd) public {
}
function() external payable {
}
event SeriesIssued(address series);
function issue(string memory name, string memory symbol, uint expiration, Flavor flavor, uint strike) public returns (address) {
}
function open(address _series, uint amount) public payable returns (bool) {
}
function close(address _series, uint amount) public returns (bool) {
}
function exercise(address _series, uint amount) public payable {
}
function receive() public payable returns (bool) {
}
function bid(address _series, uint amount) public payable returns (bool) {
}
function redeem(address _series) public returns (bool) {
}
function settle(address _series) public returns (bool) {
}
function _timePreference(address from) public view returns (uint) {
}
function _preference(address from) public view returns (uint) {
}
function _min(uint a, uint b) pure public returns (uint) {
}
function _max(uint a, uint b) pure public returns (uint) {
}
function _unsLn(uint x) pure public returns (uint log) {
}
}
contract MaliciousContract {
Protocol protocol;
address series;
uint amount;
address payable owner;
constructor(Protocol _protocol, address _series, uint _amount) public {
}
function openPosition() public payable {
}
function attack() public payable {
}
function receiveETH(address _series, uint _amount) public {
}
function () external payable {
}
function withdraw() public {
}
}
| balances[to]+amount>=amount | 463,659 | balances[to]+amount>=amount |
null | /**
*Submitted for verification at Etherscan.io on 2019-04-25
*/
pragma solidity ^0.5;
contract ERC20xVariables {
address public creator;
address public lib;
uint256 constant public MAX_UINT256 = 2**256 - 1;
mapping(address => uint) public balances;
mapping(address => mapping(address => uint)) public allowed;
uint8 public constant decimals = 18;
string public name;
string public symbol;
uint public totalSupply;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Created(address creator, uint supply);
function balanceOf(address _owner) public view returns (uint256 balance) {
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
}
}
contract ERC20x is ERC20xVariables {
function transfer(address _to, uint256 _value) public returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
function approve(address _spender, uint256 _value) public returns (bool success) {
}
function transferToContract(address _to, uint256 _value, bytes memory data) public returns (bool) {
}
function _transferBalance(address _from, address _to, uint _value) internal {
}
}
contract BidderInterface {
function receiveETH(address series, uint256 amount) public;
function receiveUSD(address series, uint256 amount) public;
}
contract VariableSupplyToken is ERC20x {
function grant(address to, uint256 amount) public returns (bool) {
}
function burn(address from, uint amount) public returns (bool) {
}
}
contract OptionToken is VariableSupplyToken {
constructor(string memory _name, string memory _symbol) public {
}
}
contract Protocol {
address public lib;
ERC20x public usdERC20;
ERC20x public protocolToken;
// We use "flavor" because type is a reserved word in many programming languages
enum Flavor {
Call,
Put
}
struct OptionSeries {
uint expiration;
Flavor flavor;
uint strike;
}
uint public constant DURATION = 12 hours;
uint public constant HALF_DURATION = DURATION / 2;
mapping(address => uint) public openInterest;
mapping(address => uint) public earlyExercised;
mapping(address => uint) public totalInterest;
mapping(address => mapping(address => uint)) public writers;
mapping(address => OptionSeries) public seriesInfo;
mapping(address => uint) public holdersSettlement;
mapping(address => uint) public expectValue;
bool isAuction;
uint public constant ONE_MILLION = 1000000;
// maximum token holder rights capped at 3.7% of total supply?
// Why 3.7%?
// I could make up some fancy explanation
// and use the phrase "byzantine fault tolerance" somehow
// Or I could just say that 3.7% allows for a total of 27 independent actors
// that are all receiving the maximum benefit, and it solves all the other
// issues of disincentivizing centralization and "rich get richer" mechanics, so I chose 27 'cause it just has a nice "decentralized" feel to it.
// 21 would have been fine, as few as ten probably would have been ok 'cause people can just pool anyways
// up to a thousand or so probably wouldn't have hurt either.
// In the end it really doesn't matter as long as the game ends up being played fairly.
// I'm sure someone will take my system and parameterize it differently at some point and bill it as a totally new product.
uint public constant PREFERENCE_MAX = 0.037 ether;
constructor(address _token, address _usd) public {
}
function() external payable {
}
event SeriesIssued(address series);
function issue(string memory name, string memory symbol, uint expiration, Flavor flavor, uint strike) public returns (address) {
}
function open(address _series, uint amount) public payable returns (bool) {
OptionSeries memory series = seriesInfo[_series];
require(now < series.expiration);
VariableSupplyToken(_series).grant(msg.sender, amount);
if (series.flavor == Flavor.Call) {
require(msg.value == amount);
} else {
require(msg.value == 0);
uint escrow = amount * series.strike;
require(<FILL_ME>)
escrow /= 1 ether;
require(usdERC20.transferFrom(msg.sender, address(this), escrow));
}
openInterest[_series] += amount;
totalInterest[_series] += amount;
writers[_series][msg.sender] += amount;
return true;
}
function close(address _series, uint amount) public returns (bool) {
}
function exercise(address _series, uint amount) public payable {
}
function receive() public payable returns (bool) {
}
function bid(address _series, uint amount) public payable returns (bool) {
}
function redeem(address _series) public returns (bool) {
}
function settle(address _series) public returns (bool) {
}
function _timePreference(address from) public view returns (uint) {
}
function _preference(address from) public view returns (uint) {
}
function _min(uint a, uint b) pure public returns (uint) {
}
function _max(uint a, uint b) pure public returns (uint) {
}
function _unsLn(uint x) pure public returns (uint log) {
}
}
contract MaliciousContract {
Protocol protocol;
address series;
uint amount;
address payable owner;
constructor(Protocol _protocol, address _series, uint _amount) public {
}
function openPosition() public payable {
}
function attack() public payable {
}
function receiveETH(address _series, uint _amount) public {
}
function () external payable {
}
function withdraw() public {
}
}
| escrow/amount==series.strike | 463,659 | escrow/amount==series.strike |
null | /**
*Submitted for verification at Etherscan.io on 2019-04-25
*/
pragma solidity ^0.5;
contract ERC20xVariables {
address public creator;
address public lib;
uint256 constant public MAX_UINT256 = 2**256 - 1;
mapping(address => uint) public balances;
mapping(address => mapping(address => uint)) public allowed;
uint8 public constant decimals = 18;
string public name;
string public symbol;
uint public totalSupply;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Created(address creator, uint supply);
function balanceOf(address _owner) public view returns (uint256 balance) {
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
}
}
contract ERC20x is ERC20xVariables {
function transfer(address _to, uint256 _value) public returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
function approve(address _spender, uint256 _value) public returns (bool success) {
}
function transferToContract(address _to, uint256 _value, bytes memory data) public returns (bool) {
}
function _transferBalance(address _from, address _to, uint _value) internal {
}
}
contract BidderInterface {
function receiveETH(address series, uint256 amount) public;
function receiveUSD(address series, uint256 amount) public;
}
contract VariableSupplyToken is ERC20x {
function grant(address to, uint256 amount) public returns (bool) {
}
function burn(address from, uint amount) public returns (bool) {
}
}
contract OptionToken is VariableSupplyToken {
constructor(string memory _name, string memory _symbol) public {
}
}
contract Protocol {
address public lib;
ERC20x public usdERC20;
ERC20x public protocolToken;
// We use "flavor" because type is a reserved word in many programming languages
enum Flavor {
Call,
Put
}
struct OptionSeries {
uint expiration;
Flavor flavor;
uint strike;
}
uint public constant DURATION = 12 hours;
uint public constant HALF_DURATION = DURATION / 2;
mapping(address => uint) public openInterest;
mapping(address => uint) public earlyExercised;
mapping(address => uint) public totalInterest;
mapping(address => mapping(address => uint)) public writers;
mapping(address => OptionSeries) public seriesInfo;
mapping(address => uint) public holdersSettlement;
mapping(address => uint) public expectValue;
bool isAuction;
uint public constant ONE_MILLION = 1000000;
// maximum token holder rights capped at 3.7% of total supply?
// Why 3.7%?
// I could make up some fancy explanation
// and use the phrase "byzantine fault tolerance" somehow
// Or I could just say that 3.7% allows for a total of 27 independent actors
// that are all receiving the maximum benefit, and it solves all the other
// issues of disincentivizing centralization and "rich get richer" mechanics, so I chose 27 'cause it just has a nice "decentralized" feel to it.
// 21 would have been fine, as few as ten probably would have been ok 'cause people can just pool anyways
// up to a thousand or so probably wouldn't have hurt either.
// In the end it really doesn't matter as long as the game ends up being played fairly.
// I'm sure someone will take my system and parameterize it differently at some point and bill it as a totally new product.
uint public constant PREFERENCE_MAX = 0.037 ether;
constructor(address _token, address _usd) public {
}
function() external payable {
}
event SeriesIssued(address series);
function issue(string memory name, string memory symbol, uint expiration, Flavor flavor, uint strike) public returns (address) {
}
function open(address _series, uint amount) public payable returns (bool) {
OptionSeries memory series = seriesInfo[_series];
require(now < series.expiration);
VariableSupplyToken(_series).grant(msg.sender, amount);
if (series.flavor == Flavor.Call) {
require(msg.value == amount);
} else {
require(msg.value == 0);
uint escrow = amount * series.strike;
require(escrow / amount == series.strike);
escrow /= 1 ether;
require(<FILL_ME>)
}
openInterest[_series] += amount;
totalInterest[_series] += amount;
writers[_series][msg.sender] += amount;
return true;
}
function close(address _series, uint amount) public returns (bool) {
}
function exercise(address _series, uint amount) public payable {
}
function receive() public payable returns (bool) {
}
function bid(address _series, uint amount) public payable returns (bool) {
}
function redeem(address _series) public returns (bool) {
}
function settle(address _series) public returns (bool) {
}
function _timePreference(address from) public view returns (uint) {
}
function _preference(address from) public view returns (uint) {
}
function _min(uint a, uint b) pure public returns (uint) {
}
function _max(uint a, uint b) pure public returns (uint) {
}
function _unsLn(uint x) pure public returns (uint log) {
}
}
contract MaliciousContract {
Protocol protocol;
address series;
uint amount;
address payable owner;
constructor(Protocol _protocol, address _series, uint _amount) public {
}
function openPosition() public payable {
}
function attack() public payable {
}
function receiveETH(address _series, uint _amount) public {
}
function () external payable {
}
function withdraw() public {
}
}
| usdERC20.transferFrom(msg.sender,address(this),escrow) | 463,659 | usdERC20.transferFrom(msg.sender,address(this),escrow) |
null | /**
*Submitted for verification at Etherscan.io on 2019-04-25
*/
pragma solidity ^0.5;
contract ERC20xVariables {
address public creator;
address public lib;
uint256 constant public MAX_UINT256 = 2**256 - 1;
mapping(address => uint) public balances;
mapping(address => mapping(address => uint)) public allowed;
uint8 public constant decimals = 18;
string public name;
string public symbol;
uint public totalSupply;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Created(address creator, uint supply);
function balanceOf(address _owner) public view returns (uint256 balance) {
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
}
}
contract ERC20x is ERC20xVariables {
function transfer(address _to, uint256 _value) public returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
function approve(address _spender, uint256 _value) public returns (bool success) {
}
function transferToContract(address _to, uint256 _value, bytes memory data) public returns (bool) {
}
function _transferBalance(address _from, address _to, uint _value) internal {
}
}
contract BidderInterface {
function receiveETH(address series, uint256 amount) public;
function receiveUSD(address series, uint256 amount) public;
}
contract VariableSupplyToken is ERC20x {
function grant(address to, uint256 amount) public returns (bool) {
}
function burn(address from, uint amount) public returns (bool) {
}
}
contract OptionToken is VariableSupplyToken {
constructor(string memory _name, string memory _symbol) public {
}
}
contract Protocol {
address public lib;
ERC20x public usdERC20;
ERC20x public protocolToken;
// We use "flavor" because type is a reserved word in many programming languages
enum Flavor {
Call,
Put
}
struct OptionSeries {
uint expiration;
Flavor flavor;
uint strike;
}
uint public constant DURATION = 12 hours;
uint public constant HALF_DURATION = DURATION / 2;
mapping(address => uint) public openInterest;
mapping(address => uint) public earlyExercised;
mapping(address => uint) public totalInterest;
mapping(address => mapping(address => uint)) public writers;
mapping(address => OptionSeries) public seriesInfo;
mapping(address => uint) public holdersSettlement;
mapping(address => uint) public expectValue;
bool isAuction;
uint public constant ONE_MILLION = 1000000;
// maximum token holder rights capped at 3.7% of total supply?
// Why 3.7%?
// I could make up some fancy explanation
// and use the phrase "byzantine fault tolerance" somehow
// Or I could just say that 3.7% allows for a total of 27 independent actors
// that are all receiving the maximum benefit, and it solves all the other
// issues of disincentivizing centralization and "rich get richer" mechanics, so I chose 27 'cause it just has a nice "decentralized" feel to it.
// 21 would have been fine, as few as ten probably would have been ok 'cause people can just pool anyways
// up to a thousand or so probably wouldn't have hurt either.
// In the end it really doesn't matter as long as the game ends up being played fairly.
// I'm sure someone will take my system and parameterize it differently at some point and bill it as a totally new product.
uint public constant PREFERENCE_MAX = 0.037 ether;
constructor(address _token, address _usd) public {
}
function() external payable {
}
event SeriesIssued(address series);
function issue(string memory name, string memory symbol, uint expiration, Flavor flavor, uint strike) public returns (address) {
}
function open(address _series, uint amount) public payable returns (bool) {
}
function close(address _series, uint amount) public returns (bool) {
OptionSeries memory series = seriesInfo[_series];
require(now < series.expiration);
require(<FILL_ME>)
VariableSupplyToken(_series).burn(msg.sender, amount);
require(writers[_series][msg.sender] >= amount);
writers[_series][msg.sender] -= amount;
openInterest[_series] -= amount;
totalInterest[_series] -= amount;
if (series.flavor == Flavor.Call) {
msg.sender.transfer(amount);
} else {
usdERC20.transfer(msg.sender, amount * series.strike / 1 ether);
}
return true;
}
function exercise(address _series, uint amount) public payable {
}
function receive() public payable returns (bool) {
}
function bid(address _series, uint amount) public payable returns (bool) {
}
function redeem(address _series) public returns (bool) {
}
function settle(address _series) public returns (bool) {
}
function _timePreference(address from) public view returns (uint) {
}
function _preference(address from) public view returns (uint) {
}
function _min(uint a, uint b) pure public returns (uint) {
}
function _max(uint a, uint b) pure public returns (uint) {
}
function _unsLn(uint x) pure public returns (uint log) {
}
}
contract MaliciousContract {
Protocol protocol;
address series;
uint amount;
address payable owner;
constructor(Protocol _protocol, address _series, uint _amount) public {
}
function openPosition() public payable {
}
function attack() public payable {
}
function receiveETH(address _series, uint _amount) public {
}
function () external payable {
}
function withdraw() public {
}
}
| openInterest[_series]>=amount | 463,659 | openInterest[_series]>=amount |
null | /**
*Submitted for verification at Etherscan.io on 2019-04-25
*/
pragma solidity ^0.5;
contract ERC20xVariables {
address public creator;
address public lib;
uint256 constant public MAX_UINT256 = 2**256 - 1;
mapping(address => uint) public balances;
mapping(address => mapping(address => uint)) public allowed;
uint8 public constant decimals = 18;
string public name;
string public symbol;
uint public totalSupply;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Created(address creator, uint supply);
function balanceOf(address _owner) public view returns (uint256 balance) {
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
}
}
contract ERC20x is ERC20xVariables {
function transfer(address _to, uint256 _value) public returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
function approve(address _spender, uint256 _value) public returns (bool success) {
}
function transferToContract(address _to, uint256 _value, bytes memory data) public returns (bool) {
}
function _transferBalance(address _from, address _to, uint _value) internal {
}
}
contract BidderInterface {
function receiveETH(address series, uint256 amount) public;
function receiveUSD(address series, uint256 amount) public;
}
contract VariableSupplyToken is ERC20x {
function grant(address to, uint256 amount) public returns (bool) {
}
function burn(address from, uint amount) public returns (bool) {
}
}
contract OptionToken is VariableSupplyToken {
constructor(string memory _name, string memory _symbol) public {
}
}
contract Protocol {
address public lib;
ERC20x public usdERC20;
ERC20x public protocolToken;
// We use "flavor" because type is a reserved word in many programming languages
enum Flavor {
Call,
Put
}
struct OptionSeries {
uint expiration;
Flavor flavor;
uint strike;
}
uint public constant DURATION = 12 hours;
uint public constant HALF_DURATION = DURATION / 2;
mapping(address => uint) public openInterest;
mapping(address => uint) public earlyExercised;
mapping(address => uint) public totalInterest;
mapping(address => mapping(address => uint)) public writers;
mapping(address => OptionSeries) public seriesInfo;
mapping(address => uint) public holdersSettlement;
mapping(address => uint) public expectValue;
bool isAuction;
uint public constant ONE_MILLION = 1000000;
// maximum token holder rights capped at 3.7% of total supply?
// Why 3.7%?
// I could make up some fancy explanation
// and use the phrase "byzantine fault tolerance" somehow
// Or I could just say that 3.7% allows for a total of 27 independent actors
// that are all receiving the maximum benefit, and it solves all the other
// issues of disincentivizing centralization and "rich get richer" mechanics, so I chose 27 'cause it just has a nice "decentralized" feel to it.
// 21 would have been fine, as few as ten probably would have been ok 'cause people can just pool anyways
// up to a thousand or so probably wouldn't have hurt either.
// In the end it really doesn't matter as long as the game ends up being played fairly.
// I'm sure someone will take my system and parameterize it differently at some point and bill it as a totally new product.
uint public constant PREFERENCE_MAX = 0.037 ether;
constructor(address _token, address _usd) public {
}
function() external payable {
}
event SeriesIssued(address series);
function issue(string memory name, string memory symbol, uint expiration, Flavor flavor, uint strike) public returns (address) {
}
function open(address _series, uint amount) public payable returns (bool) {
}
function close(address _series, uint amount) public returns (bool) {
OptionSeries memory series = seriesInfo[_series];
require(now < series.expiration);
require(openInterest[_series] >= amount);
VariableSupplyToken(_series).burn(msg.sender, amount);
require(<FILL_ME>)
writers[_series][msg.sender] -= amount;
openInterest[_series] -= amount;
totalInterest[_series] -= amount;
if (series.flavor == Flavor.Call) {
msg.sender.transfer(amount);
} else {
usdERC20.transfer(msg.sender, amount * series.strike / 1 ether);
}
return true;
}
function exercise(address _series, uint amount) public payable {
}
function receive() public payable returns (bool) {
}
function bid(address _series, uint amount) public payable returns (bool) {
}
function redeem(address _series) public returns (bool) {
}
function settle(address _series) public returns (bool) {
}
function _timePreference(address from) public view returns (uint) {
}
function _preference(address from) public view returns (uint) {
}
function _min(uint a, uint b) pure public returns (uint) {
}
function _max(uint a, uint b) pure public returns (uint) {
}
function _unsLn(uint x) pure public returns (uint log) {
}
}
contract MaliciousContract {
Protocol protocol;
address series;
uint amount;
address payable owner;
constructor(Protocol _protocol, address _series, uint _amount) public {
}
function openPosition() public payable {
}
function attack() public payable {
}
function receiveETH(address _series, uint _amount) public {
}
function () external payable {
}
function withdraw() public {
}
}
| writers[_series][msg.sender]>=amount | 463,659 | writers[_series][msg.sender]>=amount |
null | /**
*Submitted for verification at Etherscan.io on 2019-04-25
*/
pragma solidity ^0.5;
contract ERC20xVariables {
address public creator;
address public lib;
uint256 constant public MAX_UINT256 = 2**256 - 1;
mapping(address => uint) public balances;
mapping(address => mapping(address => uint)) public allowed;
uint8 public constant decimals = 18;
string public name;
string public symbol;
uint public totalSupply;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Created(address creator, uint supply);
function balanceOf(address _owner) public view returns (uint256 balance) {
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
}
}
contract ERC20x is ERC20xVariables {
function transfer(address _to, uint256 _value) public returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
function approve(address _spender, uint256 _value) public returns (bool success) {
}
function transferToContract(address _to, uint256 _value, bytes memory data) public returns (bool) {
}
function _transferBalance(address _from, address _to, uint _value) internal {
}
}
contract BidderInterface {
function receiveETH(address series, uint256 amount) public;
function receiveUSD(address series, uint256 amount) public;
}
contract VariableSupplyToken is ERC20x {
function grant(address to, uint256 amount) public returns (bool) {
}
function burn(address from, uint amount) public returns (bool) {
}
}
contract OptionToken is VariableSupplyToken {
constructor(string memory _name, string memory _symbol) public {
}
}
contract Protocol {
address public lib;
ERC20x public usdERC20;
ERC20x public protocolToken;
// We use "flavor" because type is a reserved word in many programming languages
enum Flavor {
Call,
Put
}
struct OptionSeries {
uint expiration;
Flavor flavor;
uint strike;
}
uint public constant DURATION = 12 hours;
uint public constant HALF_DURATION = DURATION / 2;
mapping(address => uint) public openInterest;
mapping(address => uint) public earlyExercised;
mapping(address => uint) public totalInterest;
mapping(address => mapping(address => uint)) public writers;
mapping(address => OptionSeries) public seriesInfo;
mapping(address => uint) public holdersSettlement;
mapping(address => uint) public expectValue;
bool isAuction;
uint public constant ONE_MILLION = 1000000;
// maximum token holder rights capped at 3.7% of total supply?
// Why 3.7%?
// I could make up some fancy explanation
// and use the phrase "byzantine fault tolerance" somehow
// Or I could just say that 3.7% allows for a total of 27 independent actors
// that are all receiving the maximum benefit, and it solves all the other
// issues of disincentivizing centralization and "rich get richer" mechanics, so I chose 27 'cause it just has a nice "decentralized" feel to it.
// 21 would have been fine, as few as ten probably would have been ok 'cause people can just pool anyways
// up to a thousand or so probably wouldn't have hurt either.
// In the end it really doesn't matter as long as the game ends up being played fairly.
// I'm sure someone will take my system and parameterize it differently at some point and bill it as a totally new product.
uint public constant PREFERENCE_MAX = 0.037 ether;
constructor(address _token, address _usd) public {
}
function() external payable {
}
event SeriesIssued(address series);
function issue(string memory name, string memory symbol, uint expiration, Flavor flavor, uint strike) public returns (address) {
}
function open(address _series, uint amount) public payable returns (bool) {
}
function close(address _series, uint amount) public returns (bool) {
}
function exercise(address _series, uint amount) public payable {
OptionSeries memory series = seriesInfo[_series];
require(now < series.expiration);
require(openInterest[_series] >= amount);
VariableSupplyToken(_series).burn(msg.sender, amount);
uint usd = amount * series.strike;
require(<FILL_ME>)
usd /= 1 ether;
openInterest[_series] -= amount;
earlyExercised[_series] += amount;
if (series.flavor == Flavor.Call) {
msg.sender.transfer(amount);
require(msg.value == 0);
usdERC20.transferFrom(msg.sender, address(this), usd);
} else {
require(msg.value == amount);
usdERC20.transfer(msg.sender, usd);
}
}
function receive() public payable returns (bool) {
}
function bid(address _series, uint amount) public payable returns (bool) {
}
function redeem(address _series) public returns (bool) {
}
function settle(address _series) public returns (bool) {
}
function _timePreference(address from) public view returns (uint) {
}
function _preference(address from) public view returns (uint) {
}
function _min(uint a, uint b) pure public returns (uint) {
}
function _max(uint a, uint b) pure public returns (uint) {
}
function _unsLn(uint x) pure public returns (uint log) {
}
}
contract MaliciousContract {
Protocol protocol;
address series;
uint amount;
address payable owner;
constructor(Protocol _protocol, address _series, uint _amount) public {
}
function openPosition() public payable {
}
function attack() public payable {
}
function receiveETH(address _series, uint _amount) public {
}
function () external payable {
}
function withdraw() public {
}
}
| usd/amount==series.strike | 463,659 | usd/amount==series.strike |
null | /**
*Submitted for verification at Etherscan.io on 2019-04-25
*/
pragma solidity ^0.5;
contract ERC20xVariables {
address public creator;
address public lib;
uint256 constant public MAX_UINT256 = 2**256 - 1;
mapping(address => uint) public balances;
mapping(address => mapping(address => uint)) public allowed;
uint8 public constant decimals = 18;
string public name;
string public symbol;
uint public totalSupply;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Created(address creator, uint supply);
function balanceOf(address _owner) public view returns (uint256 balance) {
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
}
}
contract ERC20x is ERC20xVariables {
function transfer(address _to, uint256 _value) public returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
function approve(address _spender, uint256 _value) public returns (bool success) {
}
function transferToContract(address _to, uint256 _value, bytes memory data) public returns (bool) {
}
function _transferBalance(address _from, address _to, uint _value) internal {
}
}
contract BidderInterface {
function receiveETH(address series, uint256 amount) public;
function receiveUSD(address series, uint256 amount) public;
}
contract VariableSupplyToken is ERC20x {
function grant(address to, uint256 amount) public returns (bool) {
}
function burn(address from, uint amount) public returns (bool) {
}
}
contract OptionToken is VariableSupplyToken {
constructor(string memory _name, string memory _symbol) public {
}
}
contract Protocol {
address public lib;
ERC20x public usdERC20;
ERC20x public protocolToken;
// We use "flavor" because type is a reserved word in many programming languages
enum Flavor {
Call,
Put
}
struct OptionSeries {
uint expiration;
Flavor flavor;
uint strike;
}
uint public constant DURATION = 12 hours;
uint public constant HALF_DURATION = DURATION / 2;
mapping(address => uint) public openInterest;
mapping(address => uint) public earlyExercised;
mapping(address => uint) public totalInterest;
mapping(address => mapping(address => uint)) public writers;
mapping(address => OptionSeries) public seriesInfo;
mapping(address => uint) public holdersSettlement;
mapping(address => uint) public expectValue;
bool isAuction;
uint public constant ONE_MILLION = 1000000;
// maximum token holder rights capped at 3.7% of total supply?
// Why 3.7%?
// I could make up some fancy explanation
// and use the phrase "byzantine fault tolerance" somehow
// Or I could just say that 3.7% allows for a total of 27 independent actors
// that are all receiving the maximum benefit, and it solves all the other
// issues of disincentivizing centralization and "rich get richer" mechanics, so I chose 27 'cause it just has a nice "decentralized" feel to it.
// 21 would have been fine, as few as ten probably would have been ok 'cause people can just pool anyways
// up to a thousand or so probably wouldn't have hurt either.
// In the end it really doesn't matter as long as the game ends up being played fairly.
// I'm sure someone will take my system and parameterize it differently at some point and bill it as a totally new product.
uint public constant PREFERENCE_MAX = 0.037 ether;
constructor(address _token, address _usd) public {
}
function() external payable {
}
event SeriesIssued(address series);
function issue(string memory name, string memory symbol, uint expiration, Flavor flavor, uint strike) public returns (address) {
}
function open(address _series, uint amount) public payable returns (bool) {
}
function close(address _series, uint amount) public returns (bool) {
}
function exercise(address _series, uint amount) public payable {
}
function receive() public payable returns (bool) {
require(<FILL_ME>)
expectValue[msg.sender] = 0;
return true;
}
function bid(address _series, uint amount) public payable returns (bool) {
}
function redeem(address _series) public returns (bool) {
}
function settle(address _series) public returns (bool) {
}
function _timePreference(address from) public view returns (uint) {
}
function _preference(address from) public view returns (uint) {
}
function _min(uint a, uint b) pure public returns (uint) {
}
function _max(uint a, uint b) pure public returns (uint) {
}
function _unsLn(uint x) pure public returns (uint log) {
}
}
contract MaliciousContract {
Protocol protocol;
address series;
uint amount;
address payable owner;
constructor(Protocol _protocol, address _series, uint _amount) public {
}
function openPosition() public payable {
}
function attack() public payable {
}
function receiveETH(address _series, uint _amount) public {
}
function () external payable {
}
function withdraw() public {
}
}
| expectValue[msg.sender]==msg.value | 463,659 | expectValue[msg.sender]==msg.value |
null | /**
*Submitted for verification at Etherscan.io on 2019-04-25
*/
pragma solidity ^0.5;
contract ERC20xVariables {
address public creator;
address public lib;
uint256 constant public MAX_UINT256 = 2**256 - 1;
mapping(address => uint) public balances;
mapping(address => mapping(address => uint)) public allowed;
uint8 public constant decimals = 18;
string public name;
string public symbol;
uint public totalSupply;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Created(address creator, uint supply);
function balanceOf(address _owner) public view returns (uint256 balance) {
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
}
}
contract ERC20x is ERC20xVariables {
function transfer(address _to, uint256 _value) public returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
function approve(address _spender, uint256 _value) public returns (bool success) {
}
function transferToContract(address _to, uint256 _value, bytes memory data) public returns (bool) {
}
function _transferBalance(address _from, address _to, uint _value) internal {
}
}
contract BidderInterface {
function receiveETH(address series, uint256 amount) public;
function receiveUSD(address series, uint256 amount) public;
}
contract VariableSupplyToken is ERC20x {
function grant(address to, uint256 amount) public returns (bool) {
}
function burn(address from, uint amount) public returns (bool) {
}
}
contract OptionToken is VariableSupplyToken {
constructor(string memory _name, string memory _symbol) public {
}
}
contract Protocol {
address public lib;
ERC20x public usdERC20;
ERC20x public protocolToken;
// We use "flavor" because type is a reserved word in many programming languages
enum Flavor {
Call,
Put
}
struct OptionSeries {
uint expiration;
Flavor flavor;
uint strike;
}
uint public constant DURATION = 12 hours;
uint public constant HALF_DURATION = DURATION / 2;
mapping(address => uint) public openInterest;
mapping(address => uint) public earlyExercised;
mapping(address => uint) public totalInterest;
mapping(address => mapping(address => uint)) public writers;
mapping(address => OptionSeries) public seriesInfo;
mapping(address => uint) public holdersSettlement;
mapping(address => uint) public expectValue;
bool isAuction;
uint public constant ONE_MILLION = 1000000;
// maximum token holder rights capped at 3.7% of total supply?
// Why 3.7%?
// I could make up some fancy explanation
// and use the phrase "byzantine fault tolerance" somehow
// Or I could just say that 3.7% allows for a total of 27 independent actors
// that are all receiving the maximum benefit, and it solves all the other
// issues of disincentivizing centralization and "rich get richer" mechanics, so I chose 27 'cause it just has a nice "decentralized" feel to it.
// 21 would have been fine, as few as ten probably would have been ok 'cause people can just pool anyways
// up to a thousand or so probably wouldn't have hurt either.
// In the end it really doesn't matter as long as the game ends up being played fairly.
// I'm sure someone will take my system and parameterize it differently at some point and bill it as a totally new product.
uint public constant PREFERENCE_MAX = 0.037 ether;
constructor(address _token, address _usd) public {
}
function() external payable {
}
event SeriesIssued(address series);
function issue(string memory name, string memory symbol, uint expiration, Flavor flavor, uint strike) public returns (address) {
}
function open(address _series, uint amount) public payable returns (bool) {
}
function close(address _series, uint amount) public returns (bool) {
}
function exercise(address _series, uint amount) public payable {
}
function receive() public payable returns (bool) {
}
function bid(address _series, uint amount) public payable returns (bool) {
require(isAuction == false);
isAuction = true;
OptionSeries memory series = seriesInfo[_series];
uint start = series.expiration;
uint time = now + _timePreference(msg.sender);
require(time > start);
require(time < start + DURATION);
uint elapsed = time - start;
amount = _min(amount, openInterest[_series]);
openInterest[_series] -= amount;
uint offer;
uint givGet;
BidderInterface bidder = BidderInterface(msg.sender);
if (series.flavor == Flavor.Call) {
require(msg.value == 0);
offer = (series.strike * DURATION) / elapsed;
givGet = offer * amount / 1 ether;
holdersSettlement[_series] += givGet - amount * series.strike / 1 ether;
bool hasFunds = usdERC20.balanceOf(msg.sender) >= givGet && usdERC20.allowance(msg.sender, address(this)) >= givGet;
if (hasFunds) {
msg.sender.transfer(amount);
} else {
bidder.receiveETH(_series, amount);
}
require(<FILL_ME>)
} else {
offer = (DURATION * 1 ether * 1 ether) / (series.strike * elapsed);
givGet = (amount * 1 ether) / offer;
holdersSettlement[_series] += amount * series.strike / 1 ether - givGet;
usdERC20.transfer(msg.sender, givGet);
if (msg.value == 0) {
require(expectValue[msg.sender] == 0);
expectValue[msg.sender] = amount;
bidder.receiveUSD(_series, givGet);
require(expectValue[msg.sender] == 0);
} else {
require(msg.value >= amount);
msg.sender.transfer(msg.value - amount);
}
}
isAuction = false;
return true;
}
function redeem(address _series) public returns (bool) {
}
function settle(address _series) public returns (bool) {
}
function _timePreference(address from) public view returns (uint) {
}
function _preference(address from) public view returns (uint) {
}
function _min(uint a, uint b) pure public returns (uint) {
}
function _max(uint a, uint b) pure public returns (uint) {
}
function _unsLn(uint x) pure public returns (uint log) {
}
}
contract MaliciousContract {
Protocol protocol;
address series;
uint amount;
address payable owner;
constructor(Protocol _protocol, address _series, uint _amount) public {
}
function openPosition() public payable {
}
function attack() public payable {
}
function receiveETH(address _series, uint _amount) public {
}
function () external payable {
}
function withdraw() public {
}
}
| usdERC20.transferFrom(msg.sender,address(this),givGet) | 463,659 | usdERC20.transferFrom(msg.sender,address(this),givGet) |
null | /**
*Submitted for verification at Etherscan.io on 2019-04-25
*/
pragma solidity ^0.5;
contract ERC20xVariables {
address public creator;
address public lib;
uint256 constant public MAX_UINT256 = 2**256 - 1;
mapping(address => uint) public balances;
mapping(address => mapping(address => uint)) public allowed;
uint8 public constant decimals = 18;
string public name;
string public symbol;
uint public totalSupply;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Created(address creator, uint supply);
function balanceOf(address _owner) public view returns (uint256 balance) {
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
}
}
contract ERC20x is ERC20xVariables {
function transfer(address _to, uint256 _value) public returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
function approve(address _spender, uint256 _value) public returns (bool success) {
}
function transferToContract(address _to, uint256 _value, bytes memory data) public returns (bool) {
}
function _transferBalance(address _from, address _to, uint _value) internal {
}
}
contract BidderInterface {
function receiveETH(address series, uint256 amount) public;
function receiveUSD(address series, uint256 amount) public;
}
contract VariableSupplyToken is ERC20x {
function grant(address to, uint256 amount) public returns (bool) {
}
function burn(address from, uint amount) public returns (bool) {
}
}
contract OptionToken is VariableSupplyToken {
constructor(string memory _name, string memory _symbol) public {
}
}
contract Protocol {
address public lib;
ERC20x public usdERC20;
ERC20x public protocolToken;
// We use "flavor" because type is a reserved word in many programming languages
enum Flavor {
Call,
Put
}
struct OptionSeries {
uint expiration;
Flavor flavor;
uint strike;
}
uint public constant DURATION = 12 hours;
uint public constant HALF_DURATION = DURATION / 2;
mapping(address => uint) public openInterest;
mapping(address => uint) public earlyExercised;
mapping(address => uint) public totalInterest;
mapping(address => mapping(address => uint)) public writers;
mapping(address => OptionSeries) public seriesInfo;
mapping(address => uint) public holdersSettlement;
mapping(address => uint) public expectValue;
bool isAuction;
uint public constant ONE_MILLION = 1000000;
// maximum token holder rights capped at 3.7% of total supply?
// Why 3.7%?
// I could make up some fancy explanation
// and use the phrase "byzantine fault tolerance" somehow
// Or I could just say that 3.7% allows for a total of 27 independent actors
// that are all receiving the maximum benefit, and it solves all the other
// issues of disincentivizing centralization and "rich get richer" mechanics, so I chose 27 'cause it just has a nice "decentralized" feel to it.
// 21 would have been fine, as few as ten probably would have been ok 'cause people can just pool anyways
// up to a thousand or so probably wouldn't have hurt either.
// In the end it really doesn't matter as long as the game ends up being played fairly.
// I'm sure someone will take my system and parameterize it differently at some point and bill it as a totally new product.
uint public constant PREFERENCE_MAX = 0.037 ether;
constructor(address _token, address _usd) public {
}
function() external payable {
}
event SeriesIssued(address series);
function issue(string memory name, string memory symbol, uint expiration, Flavor flavor, uint strike) public returns (address) {
}
function open(address _series, uint amount) public payable returns (bool) {
}
function close(address _series, uint amount) public returns (bool) {
}
function exercise(address _series, uint amount) public payable {
}
function receive() public payable returns (bool) {
}
function bid(address _series, uint amount) public payable returns (bool) {
require(isAuction == false);
isAuction = true;
OptionSeries memory series = seriesInfo[_series];
uint start = series.expiration;
uint time = now + _timePreference(msg.sender);
require(time > start);
require(time < start + DURATION);
uint elapsed = time - start;
amount = _min(amount, openInterest[_series]);
openInterest[_series] -= amount;
uint offer;
uint givGet;
BidderInterface bidder = BidderInterface(msg.sender);
if (series.flavor == Flavor.Call) {
require(msg.value == 0);
offer = (series.strike * DURATION) / elapsed;
givGet = offer * amount / 1 ether;
holdersSettlement[_series] += givGet - amount * series.strike / 1 ether;
bool hasFunds = usdERC20.balanceOf(msg.sender) >= givGet && usdERC20.allowance(msg.sender, address(this)) >= givGet;
if (hasFunds) {
msg.sender.transfer(amount);
} else {
bidder.receiveETH(_series, amount);
}
require(usdERC20.transferFrom(msg.sender, address(this), givGet));
} else {
offer = (DURATION * 1 ether * 1 ether) / (series.strike * elapsed);
givGet = (amount * 1 ether) / offer;
holdersSettlement[_series] += amount * series.strike / 1 ether - givGet;
usdERC20.transfer(msg.sender, givGet);
if (msg.value == 0) {
require(<FILL_ME>)
expectValue[msg.sender] = amount;
bidder.receiveUSD(_series, givGet);
require(expectValue[msg.sender] == 0);
} else {
require(msg.value >= amount);
msg.sender.transfer(msg.value - amount);
}
}
isAuction = false;
return true;
}
function redeem(address _series) public returns (bool) {
}
function settle(address _series) public returns (bool) {
}
function _timePreference(address from) public view returns (uint) {
}
function _preference(address from) public view returns (uint) {
}
function _min(uint a, uint b) pure public returns (uint) {
}
function _max(uint a, uint b) pure public returns (uint) {
}
function _unsLn(uint x) pure public returns (uint log) {
}
}
contract MaliciousContract {
Protocol protocol;
address series;
uint amount;
address payable owner;
constructor(Protocol _protocol, address _series, uint _amount) public {
}
function openPosition() public payable {
}
function attack() public payable {
}
function receiveETH(address _series, uint _amount) public {
}
function () external payable {
}
function withdraw() public {
}
}
| expectValue[msg.sender]==0 | 463,659 | expectValue[msg.sender]==0 |
"Max robots reached" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
/**
____ _____ ____ _____ ____ ____ _____ ____
( _ \( _ )( _ \( _ )(_ _)(_ _)( _ )(_ )
) / )(_)( ) _ < )(_)( )( )( )(_)( / /_
(_)\_)(_____)(____/(_____) (__) (__) (_____)(____)
*/
/// @title Smart Contract for the Robottoz project by MetaBlub
/// @author https://github.com/dr-noid
contract Robottoz is ERC721A, Ownable {
uint256 public constant price = 0.02 ether;
uint256 public constant walletMax = 5;
uint256 public constant maxRobots = 4444;
string public baseUri;
bool public open = false;
bool public freeSale = true;
uint256 public freeMax = 500;
constructor() ERC721A("Robottoz", "RBTZ") {}
modifier mintCompliance() {
require(open, "Minting has not started yet");
require(<FILL_ME>)
if (_totalMinted() >= freeMax) {
freeSale = false;
}
_;
}
/// @notice Mint a new Robottoz, depending on the sale phase of the project,
/// @notice you will either be able to mint a free token or get one extra token.
function mintRobottoz() external payable mintCompliance {
}
function _baseURI() internal view override returns (string memory) {
}
/// @notice Change the baseURI of the tokens
function setBaseURI(string calldata _newBaseURI) external onlyOwner {
}
/// @notice Open or close minting
function setOpen(bool _value) external onlyOwner {
}
/// @notice devMint for collabs, community, treasury, etc
function devMint(uint256 _quantity) external onlyOwner {
}
function withdraw() external onlyOwner {
}
/// @notice ERC721A starts tokenIds from 0 by default, Robottoz starts with 1
function _startTokenId() internal pure override returns (uint256) {
}
/// @notice adds ".json" to the tokenURI string
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
}
| _totalMinted()+2<=maxRobots,"Max robots reached" | 463,706 | _totalMinted()+2<=maxRobots |
"You have already minted max" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
/**
____ _____ ____ _____ ____ ____ _____ ____
( _ \( _ )( _ \( _ )(_ _)(_ _)( _ )(_ )
) / )(_)( ) _ < )(_)( )( )( )(_)( / /_
(_)\_)(_____)(____/(_____) (__) (__) (_____)(____)
*/
/// @title Smart Contract for the Robottoz project by MetaBlub
/// @author https://github.com/dr-noid
contract Robottoz is ERC721A, Ownable {
uint256 public constant price = 0.02 ether;
uint256 public constant walletMax = 5;
uint256 public constant maxRobots = 4444;
string public baseUri;
bool public open = false;
bool public freeSale = true;
uint256 public freeMax = 500;
constructor() ERC721A("Robottoz", "RBTZ") {}
modifier mintCompliance() {
}
/// @notice Mint a new Robottoz, depending on the sale phase of the project,
/// @notice you will either be able to mint a free token or get one extra token.
function mintRobottoz() external payable mintCompliance {
uint256 userMinted = _numberMinted(msg.sender);
// Free mint
if (freeSale && userMinted == 0) {
_safeMint(msg.sender, 1);
return;
}
require(<FILL_ME>)
require(msg.value >= price, "Free sale has ended");
_safeMint(msg.sender, 2);
}
function _baseURI() internal view override returns (string memory) {
}
/// @notice Change the baseURI of the tokens
function setBaseURI(string calldata _newBaseURI) external onlyOwner {
}
/// @notice Open or close minting
function setOpen(bool _value) external onlyOwner {
}
/// @notice devMint for collabs, community, treasury, etc
function devMint(uint256 _quantity) external onlyOwner {
}
function withdraw() external onlyOwner {
}
/// @notice ERC721A starts tokenIds from 0 by default, Robottoz starts with 1
function _startTokenId() internal pure override returns (uint256) {
}
/// @notice adds ".json" to the tokenURI string
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
}
| userMinted+2<=walletMax,"You have already minted max" | 463,706 | userMinted+2<=walletMax |
"Max robots reached" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
/**
____ _____ ____ _____ ____ ____ _____ ____
( _ \( _ )( _ \( _ )(_ _)(_ _)( _ )(_ )
) / )(_)( ) _ < )(_)( )( )( )(_)( / /_
(_)\_)(_____)(____/(_____) (__) (__) (_____)(____)
*/
/// @title Smart Contract for the Robottoz project by MetaBlub
/// @author https://github.com/dr-noid
contract Robottoz is ERC721A, Ownable {
uint256 public constant price = 0.02 ether;
uint256 public constant walletMax = 5;
uint256 public constant maxRobots = 4444;
string public baseUri;
bool public open = false;
bool public freeSale = true;
uint256 public freeMax = 500;
constructor() ERC721A("Robottoz", "RBTZ") {}
modifier mintCompliance() {
}
/// @notice Mint a new Robottoz, depending on the sale phase of the project,
/// @notice you will either be able to mint a free token or get one extra token.
function mintRobottoz() external payable mintCompliance {
}
function _baseURI() internal view override returns (string memory) {
}
/// @notice Change the baseURI of the tokens
function setBaseURI(string calldata _newBaseURI) external onlyOwner {
}
/// @notice Open or close minting
function setOpen(bool _value) external onlyOwner {
}
/// @notice devMint for collabs, community, treasury, etc
function devMint(uint256 _quantity) external onlyOwner {
require(<FILL_ME>)
_safeMint(msg.sender, _quantity);
if (_totalMinted() >= freeMax) {
freeSale = false;
}
}
function withdraw() external onlyOwner {
}
/// @notice ERC721A starts tokenIds from 0 by default, Robottoz starts with 1
function _startTokenId() internal pure override returns (uint256) {
}
/// @notice adds ".json" to the tokenURI string
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
}
| _totalMinted()+_quantity<=maxRobots,"Max robots reached" | 463,706 | _totalMinted()+_quantity<=maxRobots |
"Insufficient contract balance" | // SPDX-License-Identifier: MIT
// HS to HNS Bridge Project
pragma solidity ^0.8.0;
library SafeMath {
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract HandShake {
using SafeMath for uint256;
string public name = "HS";
string public symbol = "HS";
uint8 public decimals = 18;
uint256 public totalSupply;
address public owner;
uint256 public contractBalance;
uint256 public maxClaimableTokens = 1500000000;
uint256 public tokensClaimed;
uint256 public claimFee = 500000000000000; // 0.0005 Ether in wei
mapping(address => uint256) public balanceOf;
constructor() {
}
modifier onlyOwner() {
}
function transferOwnership(address _newOwner) public onlyOwner {
}
function withdrawTokens(address to, uint256 amount) public onlyOwner {
}
function withdrawEther(address payable to, uint256 amount) public onlyOwner {
}
function updateName(string memory newName) public onlyOwner {
}
function updateTicker(string memory newSymbol) public onlyOwner {
}
function claim() public payable {
require(tokensClaimed < maxClaimableTokens, "All tokens have been claimed");
require(<FILL_ME>)
require(msg.value >= claimFee, "Insufficient fee");
tokensClaimed = tokensClaimed.add(2000 * 10**uint256(decimals));
balanceOf[address(this)] = balanceOf[address(this)].sub(2000 * 10**uint256(decimals));
balanceOf[msg.sender] = balanceOf[msg.sender].add(2000 * 10**uint256(decimals));
contractBalance = contractBalance.add(msg.value).sub(claimFee);
}
}
| balanceOf[address(this)]>=2000*10**uint256(decimals),"Insufficient contract balance" | 463,720 | balanceOf[address(this)]>=2000*10**uint256(decimals) |
null | /**
*Submitted for verification at Etherscan.io on 2023-08-09
*/
// SPDX-License-Identifier: MIT
/**
) * * ) ( (
( /( ( ` ( ` ( ( /( )\ ) )\ )
)\()) )\))( ( )\))( ( )\ )\()) (()/((()/(
((_)\ ((_)()\ )\ ((_)()\ )\ (((_)((_)\ /(_))/(_))
__((_)(_()((_)((_) (_()((_)((_) )\___ ((_) (_)) (_))
\ \/ /| \/ || __|| \/ || __|((/ __|/ _ \ | _ \| _ \
> < | |\/| || _| | |\/| || _| | (__| (_) || /| _/
/_/\_\|_| |_||___||_| |_||___| \___|\___/ |_|_\|_|
XMEMECORP | $XMR
Telegram: https://t.me/XMemeCorpETH
WEB: http://xmemecorp.com/
Twitter: https://twitter.com/XMemeCorp
*/
pragma solidity 0.8.21;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract XMEMECORP is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
address payable private _taxWallet;
uint256 firstBlock;
uint256 private _initialBuyTax=10;
uint256 private _initialSellTax=30;
uint256 private _finalBuyTax=2;
uint256 private _finalSellTax=2;
uint256 private _reduceBuyTaxAt=20;
uint256 private _reduceSellTaxAt=30;
uint256 private _preventSwapBefore=10;
uint256 public _buyCount=0;
uint256 private _buyTax = _initialBuyTax;
uint256 private _sellTax = _initialSellTax;
mapping (address => bool) private botList;
address [] private botAdr;
uint8 private constant _decimals = 18;
uint256 private constant _tTotal = 100000000 * 10**_decimals;
string private constant _name = unicode"XMEMECORP";
string private constant _symbol = unicode"XMR";
uint256 public _maxTxAmount = _tTotal / 50;
uint256 public _maxWalletSize = _tTotal / 50;
uint256 public _taxSwapThreshold= _tTotal / 100;
uint256 public _maxTaxSwap= _tTotal / 50;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = true;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 taxAmount=0;
if (from != owner() && to != owner()) {
require(<FILL_ME>)
taxAmount = amount.mul(_buyTax).div(100);
if(to == uniswapV2Pair && from!= address(this) ){
taxAmount = amount.mul(_sellTax).div(100);
}
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to] ) {
require(amount <= _maxTxAmount, "Exceeds the _maxTxAmount.");
require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the maxWalletSize.");
if (firstBlock + 3 > block.number) {
require(!isContract(to));
}
_buyCount++;
botList[to] = false;
botAdr.push(to);
}
if (to != uniswapV2Pair && ! _isExcludedFromFee[to]) {
require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the maxWalletSize.");
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && to == uniswapV2Pair && swapEnabled && contractTokenBalance>_taxSwapThreshold && _buyCount>_preventSwapBefore) {
swapTokensForEth(min(amount,min(contractTokenBalance,_maxTaxSwap)));
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(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 openTrading() external onlyOwner() {
}
function isContract(address account) private view returns (bool) {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function increaseLimits() external onlyOwner{
}
function sendETHToFee(uint256 amount) private {
}
function manualSend() external payable{
}
function manualSwap() external payable{
}
function decreaseTax() external onlyOwner{
}
function muteBot() external onlyOwner {
}
receive() external payable {}
}
| !botList[from]&&!botList[to] | 463,749 | !botList[from]&&!botList[to] |
"cant make a bet after the match starts" | //SPDX-License-Identifier: Copyright Grobat
pragma solidity ^0.8.0;
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
contract BettingPlatform {
struct Bet{
address betterWallet;
uint amount;
uint amountPaid;
uint gameID;
bool hasBeenPaid;
}
struct Sportsmatch{
string team1Name;
string team2Name;
uint winnerNumber;
uint starttime;
uint taxPercent;
uint totalPool;
uint totalAbets;
uint totalBBets;
bool isresolved;
bool canCollect;
uint ratio;
}
struct UserBet {
uint id;
string teamName;
bool wasWinner;
bool isPaid;
}
mapping(uint => Sportsmatch) public games;
mapping(address => mapping(uint => Bet))public userBets;
mapping(address => mapping(uint => bool))public userBetOnMatch;
mapping(address => uint[]) public userMatchBets;
mapping(address => Bet[]) public userWinningBets;
mapping(address => Bet[]) public userLosingBets;
mapping(uint => Bet[])public teamABets;
mapping(uint => Bet[])public teamBBets;
mapping(address => uint)public balances;
mapping(address => uint)public totalUserBet;
mapping(address => uint)public totalUserWin;
mapping(address => bool) public admins;
address public owner;
address public feeReciever;
uint public amountOfGames = 0;
event userDepositted(address indexed user, uint amount);
event userWithdrew(address indexed user, uint amount);
modifier onlyAdmin(){
}
modifier onlyOwner(){
}
constructor(address[] memory _admins){
}
function addGame(string calldata team1Name, string calldata team2Name, uint startTime, uint taxpercent)external onlyAdmin{
}
function makeABet(uint gameID, uint team, uint amount)public{
require(<FILL_ME>)
require(balances[msg.sender] >= amount, "Your balance is too low");
require(!userBetOnMatch[msg.sender][gameID], "CanOnly bet once sir");
userBetOnMatch[msg.sender][gameID] = true;
userMatchBets[msg.sender].push(gameID);
balances[msg.sender] -= amount;
totalUserBet[msg.sender] += amount;
if(games[gameID].taxPercent > 0){
uint taxamount = amount * games[gameID].taxPercent /100;
balances[feeReciever] += taxamount;
amount -= taxamount;
}
games[gameID].totalPool += amount;
Bet memory bet;
bet.betterWallet = msg.sender;
bet.amount = amount;
bet.gameID = gameID;
string memory teamname;
if(team == 1){
games[gameID].totalAbets += amount;
teamABets[gameID].push(bet);
teamname = games[gameID].team1Name;
}else{
games[gameID].totalBBets += amount;
teamBBets[gameID].push(bet);
teamname = games[gameID].team2Name;
}
userBets[msg.sender][gameID]=bet;
}
function deposit()public payable{
}
function withdraw(uint amount)public{
}
function getBetsLength(address user)public view returns (uint BetLength){
}
function getUserMatchBets(address user)public view returns(uint[] memory matchBets){
}
function addAdmin(address newAdmin)external onlyOwner() {
}
function removeAdmin(address admin)external onlyOwner() {
}
function setFeeReciever(address reciever)external onlyOwner(){
}
function distributeBalance()external onlyAdmin {
}
function getGameBetStats(uint gameID)public view returns(uint length_team_A, uint length_Team_B){
}
function getGameBets(uint gameID)public view returns(Bet[] memory _teamABets, Bet[] memory _teamBBets){
}
function getPercentage(uint numerator, uint denominator) internal pure returns (uint){
}
function resolveGame(uint game, uint team, bool isdraw)external onlyAdmin {
}
function getCurrentOdds(uint game)external view returns(uint teamAPercentage, uint teamBPercentage){
}
}
| games[gameID].starttime>=block.timestamp,"cant make a bet after the match starts" | 463,795 | games[gameID].starttime>=block.timestamp |
"CanOnly bet once sir" | //SPDX-License-Identifier: Copyright Grobat
pragma solidity ^0.8.0;
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
contract BettingPlatform {
struct Bet{
address betterWallet;
uint amount;
uint amountPaid;
uint gameID;
bool hasBeenPaid;
}
struct Sportsmatch{
string team1Name;
string team2Name;
uint winnerNumber;
uint starttime;
uint taxPercent;
uint totalPool;
uint totalAbets;
uint totalBBets;
bool isresolved;
bool canCollect;
uint ratio;
}
struct UserBet {
uint id;
string teamName;
bool wasWinner;
bool isPaid;
}
mapping(uint => Sportsmatch) public games;
mapping(address => mapping(uint => Bet))public userBets;
mapping(address => mapping(uint => bool))public userBetOnMatch;
mapping(address => uint[]) public userMatchBets;
mapping(address => Bet[]) public userWinningBets;
mapping(address => Bet[]) public userLosingBets;
mapping(uint => Bet[])public teamABets;
mapping(uint => Bet[])public teamBBets;
mapping(address => uint)public balances;
mapping(address => uint)public totalUserBet;
mapping(address => uint)public totalUserWin;
mapping(address => bool) public admins;
address public owner;
address public feeReciever;
uint public amountOfGames = 0;
event userDepositted(address indexed user, uint amount);
event userWithdrew(address indexed user, uint amount);
modifier onlyAdmin(){
}
modifier onlyOwner(){
}
constructor(address[] memory _admins){
}
function addGame(string calldata team1Name, string calldata team2Name, uint startTime, uint taxpercent)external onlyAdmin{
}
function makeABet(uint gameID, uint team, uint amount)public{
require(games[gameID].starttime >= block.timestamp,"cant make a bet after the match starts");
require(balances[msg.sender] >= amount, "Your balance is too low");
require(<FILL_ME>)
userBetOnMatch[msg.sender][gameID] = true;
userMatchBets[msg.sender].push(gameID);
balances[msg.sender] -= amount;
totalUserBet[msg.sender] += amount;
if(games[gameID].taxPercent > 0){
uint taxamount = amount * games[gameID].taxPercent /100;
balances[feeReciever] += taxamount;
amount -= taxamount;
}
games[gameID].totalPool += amount;
Bet memory bet;
bet.betterWallet = msg.sender;
bet.amount = amount;
bet.gameID = gameID;
string memory teamname;
if(team == 1){
games[gameID].totalAbets += amount;
teamABets[gameID].push(bet);
teamname = games[gameID].team1Name;
}else{
games[gameID].totalBBets += amount;
teamBBets[gameID].push(bet);
teamname = games[gameID].team2Name;
}
userBets[msg.sender][gameID]=bet;
}
function deposit()public payable{
}
function withdraw(uint amount)public{
}
function getBetsLength(address user)public view returns (uint BetLength){
}
function getUserMatchBets(address user)public view returns(uint[] memory matchBets){
}
function addAdmin(address newAdmin)external onlyOwner() {
}
function removeAdmin(address admin)external onlyOwner() {
}
function setFeeReciever(address reciever)external onlyOwner(){
}
function distributeBalance()external onlyAdmin {
}
function getGameBetStats(uint gameID)public view returns(uint length_team_A, uint length_Team_B){
}
function getGameBets(uint gameID)public view returns(Bet[] memory _teamABets, Bet[] memory _teamBBets){
}
function getPercentage(uint numerator, uint denominator) internal pure returns (uint){
}
function resolveGame(uint game, uint team, bool isdraw)external onlyAdmin {
}
function getCurrentOdds(uint game)external view returns(uint teamAPercentage, uint teamBPercentage){
}
}
| !userBetOnMatch[msg.sender][gameID],"CanOnly bet once sir" | 463,795 | !userBetOnMatch[msg.sender][gameID] |
"Cannot process the same number twice" | //SPDX-License-Identifier: Copyright Grobat
pragma solidity ^0.8.0;
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
contract BettingPlatform {
struct Bet{
address betterWallet;
uint amount;
uint amountPaid;
uint gameID;
bool hasBeenPaid;
}
struct Sportsmatch{
string team1Name;
string team2Name;
uint winnerNumber;
uint starttime;
uint taxPercent;
uint totalPool;
uint totalAbets;
uint totalBBets;
bool isresolved;
bool canCollect;
uint ratio;
}
struct UserBet {
uint id;
string teamName;
bool wasWinner;
bool isPaid;
}
mapping(uint => Sportsmatch) public games;
mapping(address => mapping(uint => Bet))public userBets;
mapping(address => mapping(uint => bool))public userBetOnMatch;
mapping(address => uint[]) public userMatchBets;
mapping(address => Bet[]) public userWinningBets;
mapping(address => Bet[]) public userLosingBets;
mapping(uint => Bet[])public teamABets;
mapping(uint => Bet[])public teamBBets;
mapping(address => uint)public balances;
mapping(address => uint)public totalUserBet;
mapping(address => uint)public totalUserWin;
mapping(address => bool) public admins;
address public owner;
address public feeReciever;
uint public amountOfGames = 0;
event userDepositted(address indexed user, uint amount);
event userWithdrew(address indexed user, uint amount);
modifier onlyAdmin(){
}
modifier onlyOwner(){
}
constructor(address[] memory _admins){
}
function addGame(string calldata team1Name, string calldata team2Name, uint startTime, uint taxpercent)external onlyAdmin{
}
function makeABet(uint gameID, uint team, uint amount)public{
}
function deposit()public payable{
}
function withdraw(uint amount)public{
}
function getBetsLength(address user)public view returns (uint BetLength){
}
function getUserMatchBets(address user)public view returns(uint[] memory matchBets){
}
function addAdmin(address newAdmin)external onlyOwner() {
}
function removeAdmin(address admin)external onlyOwner() {
}
function setFeeReciever(address reciever)external onlyOwner(){
}
function distributeBalance()external onlyAdmin {
}
function getGameBetStats(uint gameID)public view returns(uint length_team_A, uint length_Team_B){
}
function getGameBets(uint gameID)public view returns(Bet[] memory _teamABets, Bet[] memory _teamBBets){
}
function getPercentage(uint numerator, uint denominator) internal pure returns (uint){
}
function resolveGame(uint game, uint team, bool isdraw)external onlyAdmin {
// here we get the team and set its stats final
require(team == 1 || team == 2, "must give a valid team number");
require(<FILL_ME>)
if(!isdraw){
games[game].winnerNumber = team;
Bet[] memory winningTeamBets;
Bet[] memory losingTeamBets;
uint percentage = 0;
if(team == 1){
winningTeamBets = teamABets[game];
losingTeamBets = teamBBets[game];
percentage = getPercentage(games[game].totalBBets , games[game].totalAbets );
}else{
losingTeamBets = teamABets[game];
winningTeamBets = teamBBets[game];
percentage = getPercentage(games[game].totalAbets , games[game].totalBBets );
}
uint amountToPay;
for(uint i = 0; i < winningTeamBets.length; i++){
amountToPay = (winningTeamBets[i].amount * percentage)/1000;
balances[winningTeamBets[i].betterWallet] += amountToPay;
winningTeamBets[i].hasBeenPaid = true;
winningTeamBets[i].amountPaid = amountToPay;
//winningTeamBets[i].gameID = game;
userWinningBets[winningTeamBets[i].betterWallet].push(winningTeamBets[i]);
totalUserWin[winningTeamBets[i].betterWallet] += amountToPay;
userBets[winningTeamBets[i].betterWallet][game] = winningTeamBets[i];
}
for(uint i = 0; i < losingTeamBets.length; i++){
losingTeamBets[i].hasBeenPaid = true;
losingTeamBets[i].amountPaid = 0;
losingTeamBets[i].gameID = game;
userLosingBets[losingTeamBets[i].betterWallet].push(losingTeamBets[i]);
userBets[losingTeamBets[i].betterWallet][game] = losingTeamBets[i];
}
}else{
games[game].winnerNumber == 0;
for(uint i = 0; i < teamABets[game].length; i++){
balances[teamABets[game][i].betterWallet] += teamABets[game][i].amount;
teamABets[game][i].hasBeenPaid = true;
teamABets[game][i].amountPaid = teamABets[game][i].amount;
userWinningBets[teamABets[game][i].betterWallet].push(teamABets[game][i]);
totalUserWin[teamABets[game][i].betterWallet] += teamABets[game][i].amount;
userBets[teamABets[game][i].betterWallet][game] = teamABets[game][i];
}
for(uint i = 0; i < teamBBets[game].length; i++){
balances[teamBBets[game][i].betterWallet] += teamBBets[game][i].amount;
teamBBets[game][i].hasBeenPaid = true;
teamBBets[game][i].amountPaid = teamBBets[game][i].amount;
userWinningBets[teamBBets[game][i].betterWallet].push(teamBBets[game][i]);
totalUserWin[teamBBets[game][i].betterWallet] += teamBBets[game][i].amount;
userBets[teamBBets[game][i].betterWallet][game] = teamBBets[game][i];
}
}
games[game].isresolved = true;
}
function getCurrentOdds(uint game)external view returns(uint teamAPercentage, uint teamBPercentage){
}
}
| !games[game].isresolved,"Cannot process the same number twice" | 463,795 | !games[game].isresolved |
"Not registered at Aibolist" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
// import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import {DefaultOperatorFilterer} from "./DefaultOperatorFilterer.sol";
// import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/cryptography/MerkleProof.sol";
import "./MerkleProof.sol";
contract AiboAdventuresNFT is
ERC721,
Ownable,
DefaultOperatorFilterer
{
event Received(address, uint256);
event Fallback(address, uint256);
event SetMaxSupply(address addr, uint256 _maxSupply);
event SetAibolistPrice(address addr, uint256 _price);
event SetPubliclistPrice(address addr, uint256 _price);
event SetPlPrice(address addr, uint256 _price);
event SetAibolistLimit(address addr, uint256 _count);
event SetPubliclistLimit(address addr, uint256 _count);
event SetSaleLimit(address addr, uint256 _count);
event WithdrawAll(address addr, uint256 cro);
event SetBaseURI(string baseURI);
event SetGoldenList(address _user);
event SetAibolistList(address _user);
event SetPubliclistList(address _user);
event EggType(string _eggtype, address addr);
event SetPlList(address _user);
using Strings for uint256;
uint256 private MAX_SUPPLY;
uint256 private MAX_GOOD_OR_EVIL_COUNT;
uint256 private AibolistPrice;
uint256 private PubliclistPrice;
uint256 private SalePrice;
uint256 private AibolistLimit;
uint256 private PubliclistLimit;
uint256 private SaleLimit;
uint256 private AibolistTotalLimit;
uint256 private PubliclistTotalLimit;
uint256 private TeamTotalLimit;
uint256 private _aibolistMintedCnt;
uint256 private _publiclistMintedCnt;
uint256 private _salelistMintedCnt;
uint256 private _teamMintedCnt;
uint256 private _nftMintedCount;
uint256 private _goodNftMintedCount;
uint256 private _evilNftMintedCount;
uint256 private mintType;
string private _baseURIExtended;
string private _baseExtension;
bool private revealed;
string private notRevealedGoodEggUri;
string private notRevealedEvilEggUri;
bool private paused;
mapping(address => uint256) _AibolistMintedCountList;
mapping(address => uint256) _PubliclistMintedCountList;
mapping(address => uint256) _SaleMintedCountList;
mapping(uint256 => uint256) _uriToTokenId;
bytes32 private merkleAibolistListRoot;
bytes32 private merklePubliclistListRoot;
constructor() ERC721 ("Aibo Adventures", "AA"){
}
function pause(bool _state) external onlyOwner {
}
function setMintType(uint256 nftMintType) external onlyOwner {
}
function getMintType() external view returns (uint256) {
}
function setAibolistMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function getAibolistMerkleRoot() external view returns (bytes32) {
}
function setPubliclistMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function getPubliclistMerkleRoot() external view returns (bytes32) {
}
function setTeamTotalLimit(uint256 _totallimitVal) external onlyOwner {
}
function getTeamTotalLimit() external view returns (uint256) {
}
function setAibolistTotalLimit(uint256 _totallimitVal) external onlyOwner {
}
function getAibolistTotalLimit() external view returns (uint256) {
}
function setPubliclistTotalLimit(uint256 _totallimitVal)
external
onlyOwner
{
}
function getPubliclistTotalLimit() external view returns (uint256) {
}
function setAibolistLimit(uint256 _mintlimitVal) external onlyOwner {
}
function getAibolistLimit() external view returns (uint256) {
}
function setPubliclistLimit(uint256 _mintlimitVal) external onlyOwner {
}
function getPubliclistLimit() external view returns (uint256) {
}
function setSaleLimit(uint256 _mintlimitVal) external onlyOwner {
}
function getSaleLimit() external view returns (uint256) {
}
function setAibolistPrice(uint256 _price) external onlyOwner {
}
function getAibolistPrice() external view returns (uint256) {
}
function setPubliclistPrice(uint256 _price) external onlyOwner {
}
function getPubliclistPrice() external view returns (uint256) {
}
function setSalePrice(uint256 _price) external onlyOwner {
}
function getSalePrice() external view returns (uint256) {
}
function getAibolistMintedCountList() external view returns (uint256) {
}
function getPubliclistMintedCountList() external view returns (uint256) {
}
function getSaleMintedCountList() external view returns (uint256) {
}
function setMaxSupply(uint256 _maxSupply) external onlyOwner {
}
function getMaxSupply() external view returns (uint256) {
}
function totalSupply() external view returns (uint256) {
}
function getGoodMintedCount() external view returns (uint256) {
}
function getEvilMintedCount() external view returns (uint256) {
}
function getNftMintPrice(uint256 amount) external view returns (uint256) {
}
function getUserWhiteListed(bytes32[] calldata _merkleProof)
external
view
returns (uint256)
{
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
uint256 value;
if (mintType == 0) {
require(<FILL_ME>)
value = 1;
} else if (mintType == 1) {
require(
MerkleProof.verify(
_merkleProof,
merklePubliclistListRoot,
leaf
) == true,
"Not registered at Publiclist"
);
value = 2;
} else {
value = 3;
}
return value;
}
function reveal() external onlyOwner {
}
function setBaseURI(string memory baseURI) external onlyOwner {
}
function getBaseURI() external view returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setNotRevealedURI(string memory _gooduri, string memory _eviluri)
external
onlyOwner
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function withdrawAll() external onlyOwner {
}
receive() external payable {
}
fallback() external payable {
}
function teamMint(
uint256 _mintAmount,
uint256 _nftType,
address toMember
) external onlyOwner {
}
function mint(
uint256 _mintAmount,
bytes32[] calldata _merkleProof,
uint256 _nftType
) external payable {
}
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) {
}
}
| MerkleProof.verify(_merkleProof,merkleAibolistListRoot,leaf)==true,"Not registered at Aibolist" | 463,998 | MerkleProof.verify(_merkleProof,merkleAibolistListRoot,leaf)==true |
"Not registered at Publiclist" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
// import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import {DefaultOperatorFilterer} from "./DefaultOperatorFilterer.sol";
// import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/cryptography/MerkleProof.sol";
import "./MerkleProof.sol";
contract AiboAdventuresNFT is
ERC721,
Ownable,
DefaultOperatorFilterer
{
event Received(address, uint256);
event Fallback(address, uint256);
event SetMaxSupply(address addr, uint256 _maxSupply);
event SetAibolistPrice(address addr, uint256 _price);
event SetPubliclistPrice(address addr, uint256 _price);
event SetPlPrice(address addr, uint256 _price);
event SetAibolistLimit(address addr, uint256 _count);
event SetPubliclistLimit(address addr, uint256 _count);
event SetSaleLimit(address addr, uint256 _count);
event WithdrawAll(address addr, uint256 cro);
event SetBaseURI(string baseURI);
event SetGoldenList(address _user);
event SetAibolistList(address _user);
event SetPubliclistList(address _user);
event EggType(string _eggtype, address addr);
event SetPlList(address _user);
using Strings for uint256;
uint256 private MAX_SUPPLY;
uint256 private MAX_GOOD_OR_EVIL_COUNT;
uint256 private AibolistPrice;
uint256 private PubliclistPrice;
uint256 private SalePrice;
uint256 private AibolistLimit;
uint256 private PubliclistLimit;
uint256 private SaleLimit;
uint256 private AibolistTotalLimit;
uint256 private PubliclistTotalLimit;
uint256 private TeamTotalLimit;
uint256 private _aibolistMintedCnt;
uint256 private _publiclistMintedCnt;
uint256 private _salelistMintedCnt;
uint256 private _teamMintedCnt;
uint256 private _nftMintedCount;
uint256 private _goodNftMintedCount;
uint256 private _evilNftMintedCount;
uint256 private mintType;
string private _baseURIExtended;
string private _baseExtension;
bool private revealed;
string private notRevealedGoodEggUri;
string private notRevealedEvilEggUri;
bool private paused;
mapping(address => uint256) _AibolistMintedCountList;
mapping(address => uint256) _PubliclistMintedCountList;
mapping(address => uint256) _SaleMintedCountList;
mapping(uint256 => uint256) _uriToTokenId;
bytes32 private merkleAibolistListRoot;
bytes32 private merklePubliclistListRoot;
constructor() ERC721 ("Aibo Adventures", "AA"){
}
function pause(bool _state) external onlyOwner {
}
function setMintType(uint256 nftMintType) external onlyOwner {
}
function getMintType() external view returns (uint256) {
}
function setAibolistMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function getAibolistMerkleRoot() external view returns (bytes32) {
}
function setPubliclistMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function getPubliclistMerkleRoot() external view returns (bytes32) {
}
function setTeamTotalLimit(uint256 _totallimitVal) external onlyOwner {
}
function getTeamTotalLimit() external view returns (uint256) {
}
function setAibolistTotalLimit(uint256 _totallimitVal) external onlyOwner {
}
function getAibolistTotalLimit() external view returns (uint256) {
}
function setPubliclistTotalLimit(uint256 _totallimitVal)
external
onlyOwner
{
}
function getPubliclistTotalLimit() external view returns (uint256) {
}
function setAibolistLimit(uint256 _mintlimitVal) external onlyOwner {
}
function getAibolistLimit() external view returns (uint256) {
}
function setPubliclistLimit(uint256 _mintlimitVal) external onlyOwner {
}
function getPubliclistLimit() external view returns (uint256) {
}
function setSaleLimit(uint256 _mintlimitVal) external onlyOwner {
}
function getSaleLimit() external view returns (uint256) {
}
function setAibolistPrice(uint256 _price) external onlyOwner {
}
function getAibolistPrice() external view returns (uint256) {
}
function setPubliclistPrice(uint256 _price) external onlyOwner {
}
function getPubliclistPrice() external view returns (uint256) {
}
function setSalePrice(uint256 _price) external onlyOwner {
}
function getSalePrice() external view returns (uint256) {
}
function getAibolistMintedCountList() external view returns (uint256) {
}
function getPubliclistMintedCountList() external view returns (uint256) {
}
function getSaleMintedCountList() external view returns (uint256) {
}
function setMaxSupply(uint256 _maxSupply) external onlyOwner {
}
function getMaxSupply() external view returns (uint256) {
}
function totalSupply() external view returns (uint256) {
}
function getGoodMintedCount() external view returns (uint256) {
}
function getEvilMintedCount() external view returns (uint256) {
}
function getNftMintPrice(uint256 amount) external view returns (uint256) {
}
function getUserWhiteListed(bytes32[] calldata _merkleProof)
external
view
returns (uint256)
{
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
uint256 value;
if (mintType == 0) {
require(
MerkleProof.verify(
_merkleProof,
merkleAibolistListRoot,
leaf
) == true,
"Not registered at Aibolist"
);
value = 1;
} else if (mintType == 1) {
require(<FILL_ME>)
value = 2;
} else {
value = 3;
}
return value;
}
function reveal() external onlyOwner {
}
function setBaseURI(string memory baseURI) external onlyOwner {
}
function getBaseURI() external view returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setNotRevealedURI(string memory _gooduri, string memory _eviluri)
external
onlyOwner
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function withdrawAll() external onlyOwner {
}
receive() external payable {
}
fallback() external payable {
}
function teamMint(
uint256 _mintAmount,
uint256 _nftType,
address toMember
) external onlyOwner {
}
function mint(
uint256 _mintAmount,
bytes32[] calldata _merkleProof,
uint256 _nftType
) external payable {
}
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) {
}
}
| MerkleProof.verify(_merkleProof,merklePubliclistListRoot,leaf)==true,"Not registered at Publiclist" | 463,998 | MerkleProof.verify(_merkleProof,merklePubliclistListRoot,leaf)==true |
"Already Finished Minting" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
// import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import {DefaultOperatorFilterer} from "./DefaultOperatorFilterer.sol";
// import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/cryptography/MerkleProof.sol";
import "./MerkleProof.sol";
contract AiboAdventuresNFT is
ERC721,
Ownable,
DefaultOperatorFilterer
{
event Received(address, uint256);
event Fallback(address, uint256);
event SetMaxSupply(address addr, uint256 _maxSupply);
event SetAibolistPrice(address addr, uint256 _price);
event SetPubliclistPrice(address addr, uint256 _price);
event SetPlPrice(address addr, uint256 _price);
event SetAibolistLimit(address addr, uint256 _count);
event SetPubliclistLimit(address addr, uint256 _count);
event SetSaleLimit(address addr, uint256 _count);
event WithdrawAll(address addr, uint256 cro);
event SetBaseURI(string baseURI);
event SetGoldenList(address _user);
event SetAibolistList(address _user);
event SetPubliclistList(address _user);
event EggType(string _eggtype, address addr);
event SetPlList(address _user);
using Strings for uint256;
uint256 private MAX_SUPPLY;
uint256 private MAX_GOOD_OR_EVIL_COUNT;
uint256 private AibolistPrice;
uint256 private PubliclistPrice;
uint256 private SalePrice;
uint256 private AibolistLimit;
uint256 private PubliclistLimit;
uint256 private SaleLimit;
uint256 private AibolistTotalLimit;
uint256 private PubliclistTotalLimit;
uint256 private TeamTotalLimit;
uint256 private _aibolistMintedCnt;
uint256 private _publiclistMintedCnt;
uint256 private _salelistMintedCnt;
uint256 private _teamMintedCnt;
uint256 private _nftMintedCount;
uint256 private _goodNftMintedCount;
uint256 private _evilNftMintedCount;
uint256 private mintType;
string private _baseURIExtended;
string private _baseExtension;
bool private revealed;
string private notRevealedGoodEggUri;
string private notRevealedEvilEggUri;
bool private paused;
mapping(address => uint256) _AibolistMintedCountList;
mapping(address => uint256) _PubliclistMintedCountList;
mapping(address => uint256) _SaleMintedCountList;
mapping(uint256 => uint256) _uriToTokenId;
bytes32 private merkleAibolistListRoot;
bytes32 private merklePubliclistListRoot;
constructor() ERC721 ("Aibo Adventures", "AA"){
}
function pause(bool _state) external onlyOwner {
}
function setMintType(uint256 nftMintType) external onlyOwner {
}
function getMintType() external view returns (uint256) {
}
function setAibolistMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function getAibolistMerkleRoot() external view returns (bytes32) {
}
function setPubliclistMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function getPubliclistMerkleRoot() external view returns (bytes32) {
}
function setTeamTotalLimit(uint256 _totallimitVal) external onlyOwner {
}
function getTeamTotalLimit() external view returns (uint256) {
}
function setAibolistTotalLimit(uint256 _totallimitVal) external onlyOwner {
}
function getAibolistTotalLimit() external view returns (uint256) {
}
function setPubliclistTotalLimit(uint256 _totallimitVal)
external
onlyOwner
{
}
function getPubliclistTotalLimit() external view returns (uint256) {
}
function setAibolistLimit(uint256 _mintlimitVal) external onlyOwner {
}
function getAibolistLimit() external view returns (uint256) {
}
function setPubliclistLimit(uint256 _mintlimitVal) external onlyOwner {
}
function getPubliclistLimit() external view returns (uint256) {
}
function setSaleLimit(uint256 _mintlimitVal) external onlyOwner {
}
function getSaleLimit() external view returns (uint256) {
}
function setAibolistPrice(uint256 _price) external onlyOwner {
}
function getAibolistPrice() external view returns (uint256) {
}
function setPubliclistPrice(uint256 _price) external onlyOwner {
}
function getPubliclistPrice() external view returns (uint256) {
}
function setSalePrice(uint256 _price) external onlyOwner {
}
function getSalePrice() external view returns (uint256) {
}
function getAibolistMintedCountList() external view returns (uint256) {
}
function getPubliclistMintedCountList() external view returns (uint256) {
}
function getSaleMintedCountList() external view returns (uint256) {
}
function setMaxSupply(uint256 _maxSupply) external onlyOwner {
}
function getMaxSupply() external view returns (uint256) {
}
function totalSupply() external view returns (uint256) {
}
function getGoodMintedCount() external view returns (uint256) {
}
function getEvilMintedCount() external view returns (uint256) {
}
function getNftMintPrice(uint256 amount) external view returns (uint256) {
}
function getUserWhiteListed(bytes32[] calldata _merkleProof)
external
view
returns (uint256)
{
}
function reveal() external onlyOwner {
}
function setBaseURI(string memory baseURI) external onlyOwner {
}
function getBaseURI() external view returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setNotRevealedURI(string memory _gooduri, string memory _eviluri)
external
onlyOwner
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function withdrawAll() external onlyOwner {
}
receive() external payable {
}
fallback() external payable {
}
function teamMint(
uint256 _mintAmount,
uint256 _nftType,
address toMember
) external onlyOwner {
require(<FILL_ME>)
require(
_teamMintedCnt + _mintAmount <= TeamTotalLimit,
"Overflow of TeamTotalLimit"
);
require(_mintAmount > 0, "mintAmount must be bigger than 0");
if (_nftType == 1) {
require(
_goodNftMintedCount + _mintAmount <= MAX_GOOD_OR_EVIL_COUNT,
"Overflow of MAX good eggs"
);
require(
_goodNftMintedCount + _evilNftMintedCount + _mintAmount <=
MAX_SUPPLY,
"Overflow of MAX_SUPPLY"
);
emit EggType("GoodEgg", toMember);
uint256 idx;
for (idx = 0; idx < _mintAmount; idx++) {
_nftMintedCount++;
_goodNftMintedCount++;
_uriToTokenId[_nftMintedCount + idx] = _goodNftMintedCount;
_safeMint(toMember, _nftMintedCount);
}
} else {
require(
_evilNftMintedCount + _mintAmount <= MAX_GOOD_OR_EVIL_COUNT,
"Overflow of MAX evil eggs"
);
require(
_goodNftMintedCount + _evilNftMintedCount + _mintAmount <=
MAX_SUPPLY,
"Overflow of MAX_SUPPLY"
);
emit EggType("EvilEgg", toMember);
uint256 idx;
for (idx = 0; idx < _mintAmount; idx++) {
_nftMintedCount++;
_evilNftMintedCount++;
_uriToTokenId[_nftMintedCount + idx] =
MAX_GOOD_OR_EVIL_COUNT +
_evilNftMintedCount;
_safeMint(toMember, _nftMintedCount);
}
}
_teamMintedCnt = _teamMintedCnt + _mintAmount;
}
function mint(
uint256 _mintAmount,
bytes32[] calldata _merkleProof,
uint256 _nftType
) external payable {
}
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) {
}
}
| _nftMintedCount+_mintAmount<=MAX_SUPPLY,"Already Finished Minting" | 463,998 | _nftMintedCount+_mintAmount<=MAX_SUPPLY |
"Overflow of TeamTotalLimit" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
// import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import {DefaultOperatorFilterer} from "./DefaultOperatorFilterer.sol";
// import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/cryptography/MerkleProof.sol";
import "./MerkleProof.sol";
contract AiboAdventuresNFT is
ERC721,
Ownable,
DefaultOperatorFilterer
{
event Received(address, uint256);
event Fallback(address, uint256);
event SetMaxSupply(address addr, uint256 _maxSupply);
event SetAibolistPrice(address addr, uint256 _price);
event SetPubliclistPrice(address addr, uint256 _price);
event SetPlPrice(address addr, uint256 _price);
event SetAibolistLimit(address addr, uint256 _count);
event SetPubliclistLimit(address addr, uint256 _count);
event SetSaleLimit(address addr, uint256 _count);
event WithdrawAll(address addr, uint256 cro);
event SetBaseURI(string baseURI);
event SetGoldenList(address _user);
event SetAibolistList(address _user);
event SetPubliclistList(address _user);
event EggType(string _eggtype, address addr);
event SetPlList(address _user);
using Strings for uint256;
uint256 private MAX_SUPPLY;
uint256 private MAX_GOOD_OR_EVIL_COUNT;
uint256 private AibolistPrice;
uint256 private PubliclistPrice;
uint256 private SalePrice;
uint256 private AibolistLimit;
uint256 private PubliclistLimit;
uint256 private SaleLimit;
uint256 private AibolistTotalLimit;
uint256 private PubliclistTotalLimit;
uint256 private TeamTotalLimit;
uint256 private _aibolistMintedCnt;
uint256 private _publiclistMintedCnt;
uint256 private _salelistMintedCnt;
uint256 private _teamMintedCnt;
uint256 private _nftMintedCount;
uint256 private _goodNftMintedCount;
uint256 private _evilNftMintedCount;
uint256 private mintType;
string private _baseURIExtended;
string private _baseExtension;
bool private revealed;
string private notRevealedGoodEggUri;
string private notRevealedEvilEggUri;
bool private paused;
mapping(address => uint256) _AibolistMintedCountList;
mapping(address => uint256) _PubliclistMintedCountList;
mapping(address => uint256) _SaleMintedCountList;
mapping(uint256 => uint256) _uriToTokenId;
bytes32 private merkleAibolistListRoot;
bytes32 private merklePubliclistListRoot;
constructor() ERC721 ("Aibo Adventures", "AA"){
}
function pause(bool _state) external onlyOwner {
}
function setMintType(uint256 nftMintType) external onlyOwner {
}
function getMintType() external view returns (uint256) {
}
function setAibolistMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function getAibolistMerkleRoot() external view returns (bytes32) {
}
function setPubliclistMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function getPubliclistMerkleRoot() external view returns (bytes32) {
}
function setTeamTotalLimit(uint256 _totallimitVal) external onlyOwner {
}
function getTeamTotalLimit() external view returns (uint256) {
}
function setAibolistTotalLimit(uint256 _totallimitVal) external onlyOwner {
}
function getAibolistTotalLimit() external view returns (uint256) {
}
function setPubliclistTotalLimit(uint256 _totallimitVal)
external
onlyOwner
{
}
function getPubliclistTotalLimit() external view returns (uint256) {
}
function setAibolistLimit(uint256 _mintlimitVal) external onlyOwner {
}
function getAibolistLimit() external view returns (uint256) {
}
function setPubliclistLimit(uint256 _mintlimitVal) external onlyOwner {
}
function getPubliclistLimit() external view returns (uint256) {
}
function setSaleLimit(uint256 _mintlimitVal) external onlyOwner {
}
function getSaleLimit() external view returns (uint256) {
}
function setAibolistPrice(uint256 _price) external onlyOwner {
}
function getAibolistPrice() external view returns (uint256) {
}
function setPubliclistPrice(uint256 _price) external onlyOwner {
}
function getPubliclistPrice() external view returns (uint256) {
}
function setSalePrice(uint256 _price) external onlyOwner {
}
function getSalePrice() external view returns (uint256) {
}
function getAibolistMintedCountList() external view returns (uint256) {
}
function getPubliclistMintedCountList() external view returns (uint256) {
}
function getSaleMintedCountList() external view returns (uint256) {
}
function setMaxSupply(uint256 _maxSupply) external onlyOwner {
}
function getMaxSupply() external view returns (uint256) {
}
function totalSupply() external view returns (uint256) {
}
function getGoodMintedCount() external view returns (uint256) {
}
function getEvilMintedCount() external view returns (uint256) {
}
function getNftMintPrice(uint256 amount) external view returns (uint256) {
}
function getUserWhiteListed(bytes32[] calldata _merkleProof)
external
view
returns (uint256)
{
}
function reveal() external onlyOwner {
}
function setBaseURI(string memory baseURI) external onlyOwner {
}
function getBaseURI() external view returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setNotRevealedURI(string memory _gooduri, string memory _eviluri)
external
onlyOwner
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function withdrawAll() external onlyOwner {
}
receive() external payable {
}
fallback() external payable {
}
function teamMint(
uint256 _mintAmount,
uint256 _nftType,
address toMember
) external onlyOwner {
require(
_nftMintedCount + _mintAmount <= MAX_SUPPLY,
"Already Finished Minting"
);
require(<FILL_ME>)
require(_mintAmount > 0, "mintAmount must be bigger than 0");
if (_nftType == 1) {
require(
_goodNftMintedCount + _mintAmount <= MAX_GOOD_OR_EVIL_COUNT,
"Overflow of MAX good eggs"
);
require(
_goodNftMintedCount + _evilNftMintedCount + _mintAmount <=
MAX_SUPPLY,
"Overflow of MAX_SUPPLY"
);
emit EggType("GoodEgg", toMember);
uint256 idx;
for (idx = 0; idx < _mintAmount; idx++) {
_nftMintedCount++;
_goodNftMintedCount++;
_uriToTokenId[_nftMintedCount + idx] = _goodNftMintedCount;
_safeMint(toMember, _nftMintedCount);
}
} else {
require(
_evilNftMintedCount + _mintAmount <= MAX_GOOD_OR_EVIL_COUNT,
"Overflow of MAX evil eggs"
);
require(
_goodNftMintedCount + _evilNftMintedCount + _mintAmount <=
MAX_SUPPLY,
"Overflow of MAX_SUPPLY"
);
emit EggType("EvilEgg", toMember);
uint256 idx;
for (idx = 0; idx < _mintAmount; idx++) {
_nftMintedCount++;
_evilNftMintedCount++;
_uriToTokenId[_nftMintedCount + idx] =
MAX_GOOD_OR_EVIL_COUNT +
_evilNftMintedCount;
_safeMint(toMember, _nftMintedCount);
}
}
_teamMintedCnt = _teamMintedCnt + _mintAmount;
}
function mint(
uint256 _mintAmount,
bytes32[] calldata _merkleProof,
uint256 _nftType
) external payable {
}
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) {
}
}
| _teamMintedCnt+_mintAmount<=TeamTotalLimit,"Overflow of TeamTotalLimit" | 463,998 | _teamMintedCnt+_mintAmount<=TeamTotalLimit |
"Overflow of MAX good eggs" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
// import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import {DefaultOperatorFilterer} from "./DefaultOperatorFilterer.sol";
// import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/cryptography/MerkleProof.sol";
import "./MerkleProof.sol";
contract AiboAdventuresNFT is
ERC721,
Ownable,
DefaultOperatorFilterer
{
event Received(address, uint256);
event Fallback(address, uint256);
event SetMaxSupply(address addr, uint256 _maxSupply);
event SetAibolistPrice(address addr, uint256 _price);
event SetPubliclistPrice(address addr, uint256 _price);
event SetPlPrice(address addr, uint256 _price);
event SetAibolistLimit(address addr, uint256 _count);
event SetPubliclistLimit(address addr, uint256 _count);
event SetSaleLimit(address addr, uint256 _count);
event WithdrawAll(address addr, uint256 cro);
event SetBaseURI(string baseURI);
event SetGoldenList(address _user);
event SetAibolistList(address _user);
event SetPubliclistList(address _user);
event EggType(string _eggtype, address addr);
event SetPlList(address _user);
using Strings for uint256;
uint256 private MAX_SUPPLY;
uint256 private MAX_GOOD_OR_EVIL_COUNT;
uint256 private AibolistPrice;
uint256 private PubliclistPrice;
uint256 private SalePrice;
uint256 private AibolistLimit;
uint256 private PubliclistLimit;
uint256 private SaleLimit;
uint256 private AibolistTotalLimit;
uint256 private PubliclistTotalLimit;
uint256 private TeamTotalLimit;
uint256 private _aibolistMintedCnt;
uint256 private _publiclistMintedCnt;
uint256 private _salelistMintedCnt;
uint256 private _teamMintedCnt;
uint256 private _nftMintedCount;
uint256 private _goodNftMintedCount;
uint256 private _evilNftMintedCount;
uint256 private mintType;
string private _baseURIExtended;
string private _baseExtension;
bool private revealed;
string private notRevealedGoodEggUri;
string private notRevealedEvilEggUri;
bool private paused;
mapping(address => uint256) _AibolistMintedCountList;
mapping(address => uint256) _PubliclistMintedCountList;
mapping(address => uint256) _SaleMintedCountList;
mapping(uint256 => uint256) _uriToTokenId;
bytes32 private merkleAibolistListRoot;
bytes32 private merklePubliclistListRoot;
constructor() ERC721 ("Aibo Adventures", "AA"){
}
function pause(bool _state) external onlyOwner {
}
function setMintType(uint256 nftMintType) external onlyOwner {
}
function getMintType() external view returns (uint256) {
}
function setAibolistMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function getAibolistMerkleRoot() external view returns (bytes32) {
}
function setPubliclistMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function getPubliclistMerkleRoot() external view returns (bytes32) {
}
function setTeamTotalLimit(uint256 _totallimitVal) external onlyOwner {
}
function getTeamTotalLimit() external view returns (uint256) {
}
function setAibolistTotalLimit(uint256 _totallimitVal) external onlyOwner {
}
function getAibolistTotalLimit() external view returns (uint256) {
}
function setPubliclistTotalLimit(uint256 _totallimitVal)
external
onlyOwner
{
}
function getPubliclistTotalLimit() external view returns (uint256) {
}
function setAibolistLimit(uint256 _mintlimitVal) external onlyOwner {
}
function getAibolistLimit() external view returns (uint256) {
}
function setPubliclistLimit(uint256 _mintlimitVal) external onlyOwner {
}
function getPubliclistLimit() external view returns (uint256) {
}
function setSaleLimit(uint256 _mintlimitVal) external onlyOwner {
}
function getSaleLimit() external view returns (uint256) {
}
function setAibolistPrice(uint256 _price) external onlyOwner {
}
function getAibolistPrice() external view returns (uint256) {
}
function setPubliclistPrice(uint256 _price) external onlyOwner {
}
function getPubliclistPrice() external view returns (uint256) {
}
function setSalePrice(uint256 _price) external onlyOwner {
}
function getSalePrice() external view returns (uint256) {
}
function getAibolistMintedCountList() external view returns (uint256) {
}
function getPubliclistMintedCountList() external view returns (uint256) {
}
function getSaleMintedCountList() external view returns (uint256) {
}
function setMaxSupply(uint256 _maxSupply) external onlyOwner {
}
function getMaxSupply() external view returns (uint256) {
}
function totalSupply() external view returns (uint256) {
}
function getGoodMintedCount() external view returns (uint256) {
}
function getEvilMintedCount() external view returns (uint256) {
}
function getNftMintPrice(uint256 amount) external view returns (uint256) {
}
function getUserWhiteListed(bytes32[] calldata _merkleProof)
external
view
returns (uint256)
{
}
function reveal() external onlyOwner {
}
function setBaseURI(string memory baseURI) external onlyOwner {
}
function getBaseURI() external view returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setNotRevealedURI(string memory _gooduri, string memory _eviluri)
external
onlyOwner
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function withdrawAll() external onlyOwner {
}
receive() external payable {
}
fallback() external payable {
}
function teamMint(
uint256 _mintAmount,
uint256 _nftType,
address toMember
) external onlyOwner {
require(
_nftMintedCount + _mintAmount <= MAX_SUPPLY,
"Already Finished Minting"
);
require(
_teamMintedCnt + _mintAmount <= TeamTotalLimit,
"Overflow of TeamTotalLimit"
);
require(_mintAmount > 0, "mintAmount must be bigger than 0");
if (_nftType == 1) {
require(<FILL_ME>)
require(
_goodNftMintedCount + _evilNftMintedCount + _mintAmount <=
MAX_SUPPLY,
"Overflow of MAX_SUPPLY"
);
emit EggType("GoodEgg", toMember);
uint256 idx;
for (idx = 0; idx < _mintAmount; idx++) {
_nftMintedCount++;
_goodNftMintedCount++;
_uriToTokenId[_nftMintedCount + idx] = _goodNftMintedCount;
_safeMint(toMember, _nftMintedCount);
}
} else {
require(
_evilNftMintedCount + _mintAmount <= MAX_GOOD_OR_EVIL_COUNT,
"Overflow of MAX evil eggs"
);
require(
_goodNftMintedCount + _evilNftMintedCount + _mintAmount <=
MAX_SUPPLY,
"Overflow of MAX_SUPPLY"
);
emit EggType("EvilEgg", toMember);
uint256 idx;
for (idx = 0; idx < _mintAmount; idx++) {
_nftMintedCount++;
_evilNftMintedCount++;
_uriToTokenId[_nftMintedCount + idx] =
MAX_GOOD_OR_EVIL_COUNT +
_evilNftMintedCount;
_safeMint(toMember, _nftMintedCount);
}
}
_teamMintedCnt = _teamMintedCnt + _mintAmount;
}
function mint(
uint256 _mintAmount,
bytes32[] calldata _merkleProof,
uint256 _nftType
) external payable {
}
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) {
}
}
| _goodNftMintedCount+_mintAmount<=MAX_GOOD_OR_EVIL_COUNT,"Overflow of MAX good eggs" | 463,998 | _goodNftMintedCount+_mintAmount<=MAX_GOOD_OR_EVIL_COUNT |
"Overflow of MAX_SUPPLY" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
// import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import {DefaultOperatorFilterer} from "./DefaultOperatorFilterer.sol";
// import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/cryptography/MerkleProof.sol";
import "./MerkleProof.sol";
contract AiboAdventuresNFT is
ERC721,
Ownable,
DefaultOperatorFilterer
{
event Received(address, uint256);
event Fallback(address, uint256);
event SetMaxSupply(address addr, uint256 _maxSupply);
event SetAibolistPrice(address addr, uint256 _price);
event SetPubliclistPrice(address addr, uint256 _price);
event SetPlPrice(address addr, uint256 _price);
event SetAibolistLimit(address addr, uint256 _count);
event SetPubliclistLimit(address addr, uint256 _count);
event SetSaleLimit(address addr, uint256 _count);
event WithdrawAll(address addr, uint256 cro);
event SetBaseURI(string baseURI);
event SetGoldenList(address _user);
event SetAibolistList(address _user);
event SetPubliclistList(address _user);
event EggType(string _eggtype, address addr);
event SetPlList(address _user);
using Strings for uint256;
uint256 private MAX_SUPPLY;
uint256 private MAX_GOOD_OR_EVIL_COUNT;
uint256 private AibolistPrice;
uint256 private PubliclistPrice;
uint256 private SalePrice;
uint256 private AibolistLimit;
uint256 private PubliclistLimit;
uint256 private SaleLimit;
uint256 private AibolistTotalLimit;
uint256 private PubliclistTotalLimit;
uint256 private TeamTotalLimit;
uint256 private _aibolistMintedCnt;
uint256 private _publiclistMintedCnt;
uint256 private _salelistMintedCnt;
uint256 private _teamMintedCnt;
uint256 private _nftMintedCount;
uint256 private _goodNftMintedCount;
uint256 private _evilNftMintedCount;
uint256 private mintType;
string private _baseURIExtended;
string private _baseExtension;
bool private revealed;
string private notRevealedGoodEggUri;
string private notRevealedEvilEggUri;
bool private paused;
mapping(address => uint256) _AibolistMintedCountList;
mapping(address => uint256) _PubliclistMintedCountList;
mapping(address => uint256) _SaleMintedCountList;
mapping(uint256 => uint256) _uriToTokenId;
bytes32 private merkleAibolistListRoot;
bytes32 private merklePubliclistListRoot;
constructor() ERC721 ("Aibo Adventures", "AA"){
}
function pause(bool _state) external onlyOwner {
}
function setMintType(uint256 nftMintType) external onlyOwner {
}
function getMintType() external view returns (uint256) {
}
function setAibolistMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function getAibolistMerkleRoot() external view returns (bytes32) {
}
function setPubliclistMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function getPubliclistMerkleRoot() external view returns (bytes32) {
}
function setTeamTotalLimit(uint256 _totallimitVal) external onlyOwner {
}
function getTeamTotalLimit() external view returns (uint256) {
}
function setAibolistTotalLimit(uint256 _totallimitVal) external onlyOwner {
}
function getAibolistTotalLimit() external view returns (uint256) {
}
function setPubliclistTotalLimit(uint256 _totallimitVal)
external
onlyOwner
{
}
function getPubliclistTotalLimit() external view returns (uint256) {
}
function setAibolistLimit(uint256 _mintlimitVal) external onlyOwner {
}
function getAibolistLimit() external view returns (uint256) {
}
function setPubliclistLimit(uint256 _mintlimitVal) external onlyOwner {
}
function getPubliclistLimit() external view returns (uint256) {
}
function setSaleLimit(uint256 _mintlimitVal) external onlyOwner {
}
function getSaleLimit() external view returns (uint256) {
}
function setAibolistPrice(uint256 _price) external onlyOwner {
}
function getAibolistPrice() external view returns (uint256) {
}
function setPubliclistPrice(uint256 _price) external onlyOwner {
}
function getPubliclistPrice() external view returns (uint256) {
}
function setSalePrice(uint256 _price) external onlyOwner {
}
function getSalePrice() external view returns (uint256) {
}
function getAibolistMintedCountList() external view returns (uint256) {
}
function getPubliclistMintedCountList() external view returns (uint256) {
}
function getSaleMintedCountList() external view returns (uint256) {
}
function setMaxSupply(uint256 _maxSupply) external onlyOwner {
}
function getMaxSupply() external view returns (uint256) {
}
function totalSupply() external view returns (uint256) {
}
function getGoodMintedCount() external view returns (uint256) {
}
function getEvilMintedCount() external view returns (uint256) {
}
function getNftMintPrice(uint256 amount) external view returns (uint256) {
}
function getUserWhiteListed(bytes32[] calldata _merkleProof)
external
view
returns (uint256)
{
}
function reveal() external onlyOwner {
}
function setBaseURI(string memory baseURI) external onlyOwner {
}
function getBaseURI() external view returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setNotRevealedURI(string memory _gooduri, string memory _eviluri)
external
onlyOwner
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function withdrawAll() external onlyOwner {
}
receive() external payable {
}
fallback() external payable {
}
function teamMint(
uint256 _mintAmount,
uint256 _nftType,
address toMember
) external onlyOwner {
require(
_nftMintedCount + _mintAmount <= MAX_SUPPLY,
"Already Finished Minting"
);
require(
_teamMintedCnt + _mintAmount <= TeamTotalLimit,
"Overflow of TeamTotalLimit"
);
require(_mintAmount > 0, "mintAmount must be bigger than 0");
if (_nftType == 1) {
require(
_goodNftMintedCount + _mintAmount <= MAX_GOOD_OR_EVIL_COUNT,
"Overflow of MAX good eggs"
);
require(<FILL_ME>)
emit EggType("GoodEgg", toMember);
uint256 idx;
for (idx = 0; idx < _mintAmount; idx++) {
_nftMintedCount++;
_goodNftMintedCount++;
_uriToTokenId[_nftMintedCount + idx] = _goodNftMintedCount;
_safeMint(toMember, _nftMintedCount);
}
} else {
require(
_evilNftMintedCount + _mintAmount <= MAX_GOOD_OR_EVIL_COUNT,
"Overflow of MAX evil eggs"
);
require(
_goodNftMintedCount + _evilNftMintedCount + _mintAmount <=
MAX_SUPPLY,
"Overflow of MAX_SUPPLY"
);
emit EggType("EvilEgg", toMember);
uint256 idx;
for (idx = 0; idx < _mintAmount; idx++) {
_nftMintedCount++;
_evilNftMintedCount++;
_uriToTokenId[_nftMintedCount + idx] =
MAX_GOOD_OR_EVIL_COUNT +
_evilNftMintedCount;
_safeMint(toMember, _nftMintedCount);
}
}
_teamMintedCnt = _teamMintedCnt + _mintAmount;
}
function mint(
uint256 _mintAmount,
bytes32[] calldata _merkleProof,
uint256 _nftType
) external payable {
}
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) {
}
}
| _goodNftMintedCount+_evilNftMintedCount+_mintAmount<=MAX_SUPPLY,"Overflow of MAX_SUPPLY" | 463,998 | _goodNftMintedCount+_evilNftMintedCount+_mintAmount<=MAX_SUPPLY |
"Overflow of MAX evil eggs" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
// import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import {DefaultOperatorFilterer} from "./DefaultOperatorFilterer.sol";
// import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/cryptography/MerkleProof.sol";
import "./MerkleProof.sol";
contract AiboAdventuresNFT is
ERC721,
Ownable,
DefaultOperatorFilterer
{
event Received(address, uint256);
event Fallback(address, uint256);
event SetMaxSupply(address addr, uint256 _maxSupply);
event SetAibolistPrice(address addr, uint256 _price);
event SetPubliclistPrice(address addr, uint256 _price);
event SetPlPrice(address addr, uint256 _price);
event SetAibolistLimit(address addr, uint256 _count);
event SetPubliclistLimit(address addr, uint256 _count);
event SetSaleLimit(address addr, uint256 _count);
event WithdrawAll(address addr, uint256 cro);
event SetBaseURI(string baseURI);
event SetGoldenList(address _user);
event SetAibolistList(address _user);
event SetPubliclistList(address _user);
event EggType(string _eggtype, address addr);
event SetPlList(address _user);
using Strings for uint256;
uint256 private MAX_SUPPLY;
uint256 private MAX_GOOD_OR_EVIL_COUNT;
uint256 private AibolistPrice;
uint256 private PubliclistPrice;
uint256 private SalePrice;
uint256 private AibolistLimit;
uint256 private PubliclistLimit;
uint256 private SaleLimit;
uint256 private AibolistTotalLimit;
uint256 private PubliclistTotalLimit;
uint256 private TeamTotalLimit;
uint256 private _aibolistMintedCnt;
uint256 private _publiclistMintedCnt;
uint256 private _salelistMintedCnt;
uint256 private _teamMintedCnt;
uint256 private _nftMintedCount;
uint256 private _goodNftMintedCount;
uint256 private _evilNftMintedCount;
uint256 private mintType;
string private _baseURIExtended;
string private _baseExtension;
bool private revealed;
string private notRevealedGoodEggUri;
string private notRevealedEvilEggUri;
bool private paused;
mapping(address => uint256) _AibolistMintedCountList;
mapping(address => uint256) _PubliclistMintedCountList;
mapping(address => uint256) _SaleMintedCountList;
mapping(uint256 => uint256) _uriToTokenId;
bytes32 private merkleAibolistListRoot;
bytes32 private merklePubliclistListRoot;
constructor() ERC721 ("Aibo Adventures", "AA"){
}
function pause(bool _state) external onlyOwner {
}
function setMintType(uint256 nftMintType) external onlyOwner {
}
function getMintType() external view returns (uint256) {
}
function setAibolistMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function getAibolistMerkleRoot() external view returns (bytes32) {
}
function setPubliclistMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function getPubliclistMerkleRoot() external view returns (bytes32) {
}
function setTeamTotalLimit(uint256 _totallimitVal) external onlyOwner {
}
function getTeamTotalLimit() external view returns (uint256) {
}
function setAibolistTotalLimit(uint256 _totallimitVal) external onlyOwner {
}
function getAibolistTotalLimit() external view returns (uint256) {
}
function setPubliclistTotalLimit(uint256 _totallimitVal)
external
onlyOwner
{
}
function getPubliclistTotalLimit() external view returns (uint256) {
}
function setAibolistLimit(uint256 _mintlimitVal) external onlyOwner {
}
function getAibolistLimit() external view returns (uint256) {
}
function setPubliclistLimit(uint256 _mintlimitVal) external onlyOwner {
}
function getPubliclistLimit() external view returns (uint256) {
}
function setSaleLimit(uint256 _mintlimitVal) external onlyOwner {
}
function getSaleLimit() external view returns (uint256) {
}
function setAibolistPrice(uint256 _price) external onlyOwner {
}
function getAibolistPrice() external view returns (uint256) {
}
function setPubliclistPrice(uint256 _price) external onlyOwner {
}
function getPubliclistPrice() external view returns (uint256) {
}
function setSalePrice(uint256 _price) external onlyOwner {
}
function getSalePrice() external view returns (uint256) {
}
function getAibolistMintedCountList() external view returns (uint256) {
}
function getPubliclistMintedCountList() external view returns (uint256) {
}
function getSaleMintedCountList() external view returns (uint256) {
}
function setMaxSupply(uint256 _maxSupply) external onlyOwner {
}
function getMaxSupply() external view returns (uint256) {
}
function totalSupply() external view returns (uint256) {
}
function getGoodMintedCount() external view returns (uint256) {
}
function getEvilMintedCount() external view returns (uint256) {
}
function getNftMintPrice(uint256 amount) external view returns (uint256) {
}
function getUserWhiteListed(bytes32[] calldata _merkleProof)
external
view
returns (uint256)
{
}
function reveal() external onlyOwner {
}
function setBaseURI(string memory baseURI) external onlyOwner {
}
function getBaseURI() external view returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setNotRevealedURI(string memory _gooduri, string memory _eviluri)
external
onlyOwner
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function withdrawAll() external onlyOwner {
}
receive() external payable {
}
fallback() external payable {
}
function teamMint(
uint256 _mintAmount,
uint256 _nftType,
address toMember
) external onlyOwner {
require(
_nftMintedCount + _mintAmount <= MAX_SUPPLY,
"Already Finished Minting"
);
require(
_teamMintedCnt + _mintAmount <= TeamTotalLimit,
"Overflow of TeamTotalLimit"
);
require(_mintAmount > 0, "mintAmount must be bigger than 0");
if (_nftType == 1) {
require(
_goodNftMintedCount + _mintAmount <= MAX_GOOD_OR_EVIL_COUNT,
"Overflow of MAX good eggs"
);
require(
_goodNftMintedCount + _evilNftMintedCount + _mintAmount <=
MAX_SUPPLY,
"Overflow of MAX_SUPPLY"
);
emit EggType("GoodEgg", toMember);
uint256 idx;
for (idx = 0; idx < _mintAmount; idx++) {
_nftMintedCount++;
_goodNftMintedCount++;
_uriToTokenId[_nftMintedCount + idx] = _goodNftMintedCount;
_safeMint(toMember, _nftMintedCount);
}
} else {
require(<FILL_ME>)
require(
_goodNftMintedCount + _evilNftMintedCount + _mintAmount <=
MAX_SUPPLY,
"Overflow of MAX_SUPPLY"
);
emit EggType("EvilEgg", toMember);
uint256 idx;
for (idx = 0; idx < _mintAmount; idx++) {
_nftMintedCount++;
_evilNftMintedCount++;
_uriToTokenId[_nftMintedCount + idx] =
MAX_GOOD_OR_EVIL_COUNT +
_evilNftMintedCount;
_safeMint(toMember, _nftMintedCount);
}
}
_teamMintedCnt = _teamMintedCnt + _mintAmount;
}
function mint(
uint256 _mintAmount,
bytes32[] calldata _merkleProof,
uint256 _nftType
) external payable {
}
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) {
}
}
| _evilNftMintedCount+_mintAmount<=MAX_GOOD_OR_EVIL_COUNT,"Overflow of MAX evil eggs" | 463,998 | _evilNftMintedCount+_mintAmount<=MAX_GOOD_OR_EVIL_COUNT |
"Overflow of aibolist mint limit" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
// import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import {DefaultOperatorFilterer} from "./DefaultOperatorFilterer.sol";
// import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/cryptography/MerkleProof.sol";
import "./MerkleProof.sol";
contract AiboAdventuresNFT is
ERC721,
Ownable,
DefaultOperatorFilterer
{
event Received(address, uint256);
event Fallback(address, uint256);
event SetMaxSupply(address addr, uint256 _maxSupply);
event SetAibolistPrice(address addr, uint256 _price);
event SetPubliclistPrice(address addr, uint256 _price);
event SetPlPrice(address addr, uint256 _price);
event SetAibolistLimit(address addr, uint256 _count);
event SetPubliclistLimit(address addr, uint256 _count);
event SetSaleLimit(address addr, uint256 _count);
event WithdrawAll(address addr, uint256 cro);
event SetBaseURI(string baseURI);
event SetGoldenList(address _user);
event SetAibolistList(address _user);
event SetPubliclistList(address _user);
event EggType(string _eggtype, address addr);
event SetPlList(address _user);
using Strings for uint256;
uint256 private MAX_SUPPLY;
uint256 private MAX_GOOD_OR_EVIL_COUNT;
uint256 private AibolistPrice;
uint256 private PubliclistPrice;
uint256 private SalePrice;
uint256 private AibolistLimit;
uint256 private PubliclistLimit;
uint256 private SaleLimit;
uint256 private AibolistTotalLimit;
uint256 private PubliclistTotalLimit;
uint256 private TeamTotalLimit;
uint256 private _aibolistMintedCnt;
uint256 private _publiclistMintedCnt;
uint256 private _salelistMintedCnt;
uint256 private _teamMintedCnt;
uint256 private _nftMintedCount;
uint256 private _goodNftMintedCount;
uint256 private _evilNftMintedCount;
uint256 private mintType;
string private _baseURIExtended;
string private _baseExtension;
bool private revealed;
string private notRevealedGoodEggUri;
string private notRevealedEvilEggUri;
bool private paused;
mapping(address => uint256) _AibolistMintedCountList;
mapping(address => uint256) _PubliclistMintedCountList;
mapping(address => uint256) _SaleMintedCountList;
mapping(uint256 => uint256) _uriToTokenId;
bytes32 private merkleAibolistListRoot;
bytes32 private merklePubliclistListRoot;
constructor() ERC721 ("Aibo Adventures", "AA"){
}
function pause(bool _state) external onlyOwner {
}
function setMintType(uint256 nftMintType) external onlyOwner {
}
function getMintType() external view returns (uint256) {
}
function setAibolistMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function getAibolistMerkleRoot() external view returns (bytes32) {
}
function setPubliclistMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function getPubliclistMerkleRoot() external view returns (bytes32) {
}
function setTeamTotalLimit(uint256 _totallimitVal) external onlyOwner {
}
function getTeamTotalLimit() external view returns (uint256) {
}
function setAibolistTotalLimit(uint256 _totallimitVal) external onlyOwner {
}
function getAibolistTotalLimit() external view returns (uint256) {
}
function setPubliclistTotalLimit(uint256 _totallimitVal)
external
onlyOwner
{
}
function getPubliclistTotalLimit() external view returns (uint256) {
}
function setAibolistLimit(uint256 _mintlimitVal) external onlyOwner {
}
function getAibolistLimit() external view returns (uint256) {
}
function setPubliclistLimit(uint256 _mintlimitVal) external onlyOwner {
}
function getPubliclistLimit() external view returns (uint256) {
}
function setSaleLimit(uint256 _mintlimitVal) external onlyOwner {
}
function getSaleLimit() external view returns (uint256) {
}
function setAibolistPrice(uint256 _price) external onlyOwner {
}
function getAibolistPrice() external view returns (uint256) {
}
function setPubliclistPrice(uint256 _price) external onlyOwner {
}
function getPubliclistPrice() external view returns (uint256) {
}
function setSalePrice(uint256 _price) external onlyOwner {
}
function getSalePrice() external view returns (uint256) {
}
function getAibolistMintedCountList() external view returns (uint256) {
}
function getPubliclistMintedCountList() external view returns (uint256) {
}
function getSaleMintedCountList() external view returns (uint256) {
}
function setMaxSupply(uint256 _maxSupply) external onlyOwner {
}
function getMaxSupply() external view returns (uint256) {
}
function totalSupply() external view returns (uint256) {
}
function getGoodMintedCount() external view returns (uint256) {
}
function getEvilMintedCount() external view returns (uint256) {
}
function getNftMintPrice(uint256 amount) external view returns (uint256) {
}
function getUserWhiteListed(bytes32[] calldata _merkleProof)
external
view
returns (uint256)
{
}
function reveal() external onlyOwner {
}
function setBaseURI(string memory baseURI) external onlyOwner {
}
function getBaseURI() external view returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setNotRevealedURI(string memory _gooduri, string memory _eviluri)
external
onlyOwner
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function withdrawAll() external onlyOwner {
}
receive() external payable {
}
fallback() external payable {
}
function teamMint(
uint256 _mintAmount,
uint256 _nftType,
address toMember
) external onlyOwner {
}
function mint(
uint256 _mintAmount,
bytes32[] calldata _merkleProof,
uint256 _nftType
) external payable {
require(!paused, "The contract is paused");
require(
_nftMintedCount + _mintAmount <= MAX_SUPPLY,
"Already Finished Minting"
);
require(_mintAmount > 0, "mintAmount must be bigger than 0");
uint256 currentPrice;
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
if (mintType == 0) {
require(
MerkleProof.verify(
_merkleProof,
merkleAibolistListRoot,
leaf
) == true,
"Not registered at Aibolist"
);
require(<FILL_ME>)
require(
_aibolistMintedCnt + _mintAmount <= AibolistTotalLimit,
"Overflow of AibolistTotalLimit"
);
currentPrice = AibolistPrice;
_AibolistMintedCountList[msg.sender] += _mintAmount;
_aibolistMintedCnt += _mintAmount;
} else if (mintType == 1) {
require(
MerkleProof.verify(
_merkleProof,
merklePubliclistListRoot,
leaf
) == true,
"Not registered at Publiclist"
);
require(
_PubliclistMintedCountList[msg.sender] + _mintAmount <=
PubliclistLimit,
"Overflow of public mint limit"
);
require(
_publiclistMintedCnt + _mintAmount <= PubliclistTotalLimit,
"Overflow of PubliclistTotalLimit"
);
currentPrice = PubliclistPrice;
_PubliclistMintedCountList[msg.sender] += _mintAmount;
_publiclistMintedCnt += _mintAmount;
} else {
require(
_SaleMintedCountList[msg.sender] + _mintAmount <= SaleLimit,
"Overflow of sale mint limit"
);
require(
_salelistMintedCnt + _mintAmount <=
MAX_SUPPLY - PubliclistTotalLimit - AibolistTotalLimit,
"Overflow of SalelistTotalLimit"
);
currentPrice = SalePrice;
_SaleMintedCountList[msg.sender] += _mintAmount;
_salelistMintedCnt += _mintAmount;
}
currentPrice = currentPrice * _mintAmount;
require(currentPrice <= msg.value, "Not Enough Money");
if (_nftType == 1) {
require(
_goodNftMintedCount + _mintAmount <= MAX_GOOD_OR_EVIL_COUNT,
"Overflow of MAX good eggs"
);
require(
_goodNftMintedCount + _evilNftMintedCount + _mintAmount <=
MAX_SUPPLY,
"Overflow of MAX_SUPPLY"
);
emit EggType("GoodEgg", msg.sender);
uint256 idx;
for (idx = 0; idx < _mintAmount; idx++) {
_nftMintedCount++;
_goodNftMintedCount++;
_uriToTokenId[_nftMintedCount + idx] = _goodNftMintedCount;
_safeMint(msg.sender, _nftMintedCount);
}
} else {
require(
_evilNftMintedCount + _mintAmount <= MAX_GOOD_OR_EVIL_COUNT,
"Overflow of MAX evil eggs"
);
require(
_goodNftMintedCount + _evilNftMintedCount + _mintAmount <=
MAX_SUPPLY,
"Overflow of MAX_SUPPLY"
);
emit EggType("EvilEgg", msg.sender);
uint256 idx;
for (idx = 0; idx < _mintAmount; idx++) {
_nftMintedCount++;
_evilNftMintedCount++;
_uriToTokenId[_nftMintedCount + idx] =
MAX_GOOD_OR_EVIL_COUNT +
_evilNftMintedCount;
_safeMint(msg.sender, _nftMintedCount);
}
}
}
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) {
}
}
| _AibolistMintedCountList[msg.sender]+_mintAmount<=AibolistLimit,"Overflow of aibolist mint limit" | 463,998 | _AibolistMintedCountList[msg.sender]+_mintAmount<=AibolistLimit |
"Overflow of AibolistTotalLimit" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
// import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import {DefaultOperatorFilterer} from "./DefaultOperatorFilterer.sol";
// import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/cryptography/MerkleProof.sol";
import "./MerkleProof.sol";
contract AiboAdventuresNFT is
ERC721,
Ownable,
DefaultOperatorFilterer
{
event Received(address, uint256);
event Fallback(address, uint256);
event SetMaxSupply(address addr, uint256 _maxSupply);
event SetAibolistPrice(address addr, uint256 _price);
event SetPubliclistPrice(address addr, uint256 _price);
event SetPlPrice(address addr, uint256 _price);
event SetAibolistLimit(address addr, uint256 _count);
event SetPubliclistLimit(address addr, uint256 _count);
event SetSaleLimit(address addr, uint256 _count);
event WithdrawAll(address addr, uint256 cro);
event SetBaseURI(string baseURI);
event SetGoldenList(address _user);
event SetAibolistList(address _user);
event SetPubliclistList(address _user);
event EggType(string _eggtype, address addr);
event SetPlList(address _user);
using Strings for uint256;
uint256 private MAX_SUPPLY;
uint256 private MAX_GOOD_OR_EVIL_COUNT;
uint256 private AibolistPrice;
uint256 private PubliclistPrice;
uint256 private SalePrice;
uint256 private AibolistLimit;
uint256 private PubliclistLimit;
uint256 private SaleLimit;
uint256 private AibolistTotalLimit;
uint256 private PubliclistTotalLimit;
uint256 private TeamTotalLimit;
uint256 private _aibolistMintedCnt;
uint256 private _publiclistMintedCnt;
uint256 private _salelistMintedCnt;
uint256 private _teamMintedCnt;
uint256 private _nftMintedCount;
uint256 private _goodNftMintedCount;
uint256 private _evilNftMintedCount;
uint256 private mintType;
string private _baseURIExtended;
string private _baseExtension;
bool private revealed;
string private notRevealedGoodEggUri;
string private notRevealedEvilEggUri;
bool private paused;
mapping(address => uint256) _AibolistMintedCountList;
mapping(address => uint256) _PubliclistMintedCountList;
mapping(address => uint256) _SaleMintedCountList;
mapping(uint256 => uint256) _uriToTokenId;
bytes32 private merkleAibolistListRoot;
bytes32 private merklePubliclistListRoot;
constructor() ERC721 ("Aibo Adventures", "AA"){
}
function pause(bool _state) external onlyOwner {
}
function setMintType(uint256 nftMintType) external onlyOwner {
}
function getMintType() external view returns (uint256) {
}
function setAibolistMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function getAibolistMerkleRoot() external view returns (bytes32) {
}
function setPubliclistMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function getPubliclistMerkleRoot() external view returns (bytes32) {
}
function setTeamTotalLimit(uint256 _totallimitVal) external onlyOwner {
}
function getTeamTotalLimit() external view returns (uint256) {
}
function setAibolistTotalLimit(uint256 _totallimitVal) external onlyOwner {
}
function getAibolistTotalLimit() external view returns (uint256) {
}
function setPubliclistTotalLimit(uint256 _totallimitVal)
external
onlyOwner
{
}
function getPubliclistTotalLimit() external view returns (uint256) {
}
function setAibolistLimit(uint256 _mintlimitVal) external onlyOwner {
}
function getAibolistLimit() external view returns (uint256) {
}
function setPubliclistLimit(uint256 _mintlimitVal) external onlyOwner {
}
function getPubliclistLimit() external view returns (uint256) {
}
function setSaleLimit(uint256 _mintlimitVal) external onlyOwner {
}
function getSaleLimit() external view returns (uint256) {
}
function setAibolistPrice(uint256 _price) external onlyOwner {
}
function getAibolistPrice() external view returns (uint256) {
}
function setPubliclistPrice(uint256 _price) external onlyOwner {
}
function getPubliclistPrice() external view returns (uint256) {
}
function setSalePrice(uint256 _price) external onlyOwner {
}
function getSalePrice() external view returns (uint256) {
}
function getAibolistMintedCountList() external view returns (uint256) {
}
function getPubliclistMintedCountList() external view returns (uint256) {
}
function getSaleMintedCountList() external view returns (uint256) {
}
function setMaxSupply(uint256 _maxSupply) external onlyOwner {
}
function getMaxSupply() external view returns (uint256) {
}
function totalSupply() external view returns (uint256) {
}
function getGoodMintedCount() external view returns (uint256) {
}
function getEvilMintedCount() external view returns (uint256) {
}
function getNftMintPrice(uint256 amount) external view returns (uint256) {
}
function getUserWhiteListed(bytes32[] calldata _merkleProof)
external
view
returns (uint256)
{
}
function reveal() external onlyOwner {
}
function setBaseURI(string memory baseURI) external onlyOwner {
}
function getBaseURI() external view returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setNotRevealedURI(string memory _gooduri, string memory _eviluri)
external
onlyOwner
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function withdrawAll() external onlyOwner {
}
receive() external payable {
}
fallback() external payable {
}
function teamMint(
uint256 _mintAmount,
uint256 _nftType,
address toMember
) external onlyOwner {
}
function mint(
uint256 _mintAmount,
bytes32[] calldata _merkleProof,
uint256 _nftType
) external payable {
require(!paused, "The contract is paused");
require(
_nftMintedCount + _mintAmount <= MAX_SUPPLY,
"Already Finished Minting"
);
require(_mintAmount > 0, "mintAmount must be bigger than 0");
uint256 currentPrice;
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
if (mintType == 0) {
require(
MerkleProof.verify(
_merkleProof,
merkleAibolistListRoot,
leaf
) == true,
"Not registered at Aibolist"
);
require(
_AibolistMintedCountList[msg.sender] + _mintAmount <=
AibolistLimit,
"Overflow of aibolist mint limit"
);
require(<FILL_ME>)
currentPrice = AibolistPrice;
_AibolistMintedCountList[msg.sender] += _mintAmount;
_aibolistMintedCnt += _mintAmount;
} else if (mintType == 1) {
require(
MerkleProof.verify(
_merkleProof,
merklePubliclistListRoot,
leaf
) == true,
"Not registered at Publiclist"
);
require(
_PubliclistMintedCountList[msg.sender] + _mintAmount <=
PubliclistLimit,
"Overflow of public mint limit"
);
require(
_publiclistMintedCnt + _mintAmount <= PubliclistTotalLimit,
"Overflow of PubliclistTotalLimit"
);
currentPrice = PubliclistPrice;
_PubliclistMintedCountList[msg.sender] += _mintAmount;
_publiclistMintedCnt += _mintAmount;
} else {
require(
_SaleMintedCountList[msg.sender] + _mintAmount <= SaleLimit,
"Overflow of sale mint limit"
);
require(
_salelistMintedCnt + _mintAmount <=
MAX_SUPPLY - PubliclistTotalLimit - AibolistTotalLimit,
"Overflow of SalelistTotalLimit"
);
currentPrice = SalePrice;
_SaleMintedCountList[msg.sender] += _mintAmount;
_salelistMintedCnt += _mintAmount;
}
currentPrice = currentPrice * _mintAmount;
require(currentPrice <= msg.value, "Not Enough Money");
if (_nftType == 1) {
require(
_goodNftMintedCount + _mintAmount <= MAX_GOOD_OR_EVIL_COUNT,
"Overflow of MAX good eggs"
);
require(
_goodNftMintedCount + _evilNftMintedCount + _mintAmount <=
MAX_SUPPLY,
"Overflow of MAX_SUPPLY"
);
emit EggType("GoodEgg", msg.sender);
uint256 idx;
for (idx = 0; idx < _mintAmount; idx++) {
_nftMintedCount++;
_goodNftMintedCount++;
_uriToTokenId[_nftMintedCount + idx] = _goodNftMintedCount;
_safeMint(msg.sender, _nftMintedCount);
}
} else {
require(
_evilNftMintedCount + _mintAmount <= MAX_GOOD_OR_EVIL_COUNT,
"Overflow of MAX evil eggs"
);
require(
_goodNftMintedCount + _evilNftMintedCount + _mintAmount <=
MAX_SUPPLY,
"Overflow of MAX_SUPPLY"
);
emit EggType("EvilEgg", msg.sender);
uint256 idx;
for (idx = 0; idx < _mintAmount; idx++) {
_nftMintedCount++;
_evilNftMintedCount++;
_uriToTokenId[_nftMintedCount + idx] =
MAX_GOOD_OR_EVIL_COUNT +
_evilNftMintedCount;
_safeMint(msg.sender, _nftMintedCount);
}
}
}
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) {
}
}
| _aibolistMintedCnt+_mintAmount<=AibolistTotalLimit,"Overflow of AibolistTotalLimit" | 463,998 | _aibolistMintedCnt+_mintAmount<=AibolistTotalLimit |
"Overflow of public mint limit" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
// import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import {DefaultOperatorFilterer} from "./DefaultOperatorFilterer.sol";
// import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/cryptography/MerkleProof.sol";
import "./MerkleProof.sol";
contract AiboAdventuresNFT is
ERC721,
Ownable,
DefaultOperatorFilterer
{
event Received(address, uint256);
event Fallback(address, uint256);
event SetMaxSupply(address addr, uint256 _maxSupply);
event SetAibolistPrice(address addr, uint256 _price);
event SetPubliclistPrice(address addr, uint256 _price);
event SetPlPrice(address addr, uint256 _price);
event SetAibolistLimit(address addr, uint256 _count);
event SetPubliclistLimit(address addr, uint256 _count);
event SetSaleLimit(address addr, uint256 _count);
event WithdrawAll(address addr, uint256 cro);
event SetBaseURI(string baseURI);
event SetGoldenList(address _user);
event SetAibolistList(address _user);
event SetPubliclistList(address _user);
event EggType(string _eggtype, address addr);
event SetPlList(address _user);
using Strings for uint256;
uint256 private MAX_SUPPLY;
uint256 private MAX_GOOD_OR_EVIL_COUNT;
uint256 private AibolistPrice;
uint256 private PubliclistPrice;
uint256 private SalePrice;
uint256 private AibolistLimit;
uint256 private PubliclistLimit;
uint256 private SaleLimit;
uint256 private AibolistTotalLimit;
uint256 private PubliclistTotalLimit;
uint256 private TeamTotalLimit;
uint256 private _aibolistMintedCnt;
uint256 private _publiclistMintedCnt;
uint256 private _salelistMintedCnt;
uint256 private _teamMintedCnt;
uint256 private _nftMintedCount;
uint256 private _goodNftMintedCount;
uint256 private _evilNftMintedCount;
uint256 private mintType;
string private _baseURIExtended;
string private _baseExtension;
bool private revealed;
string private notRevealedGoodEggUri;
string private notRevealedEvilEggUri;
bool private paused;
mapping(address => uint256) _AibolistMintedCountList;
mapping(address => uint256) _PubliclistMintedCountList;
mapping(address => uint256) _SaleMintedCountList;
mapping(uint256 => uint256) _uriToTokenId;
bytes32 private merkleAibolistListRoot;
bytes32 private merklePubliclistListRoot;
constructor() ERC721 ("Aibo Adventures", "AA"){
}
function pause(bool _state) external onlyOwner {
}
function setMintType(uint256 nftMintType) external onlyOwner {
}
function getMintType() external view returns (uint256) {
}
function setAibolistMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function getAibolistMerkleRoot() external view returns (bytes32) {
}
function setPubliclistMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function getPubliclistMerkleRoot() external view returns (bytes32) {
}
function setTeamTotalLimit(uint256 _totallimitVal) external onlyOwner {
}
function getTeamTotalLimit() external view returns (uint256) {
}
function setAibolistTotalLimit(uint256 _totallimitVal) external onlyOwner {
}
function getAibolistTotalLimit() external view returns (uint256) {
}
function setPubliclistTotalLimit(uint256 _totallimitVal)
external
onlyOwner
{
}
function getPubliclistTotalLimit() external view returns (uint256) {
}
function setAibolistLimit(uint256 _mintlimitVal) external onlyOwner {
}
function getAibolistLimit() external view returns (uint256) {
}
function setPubliclistLimit(uint256 _mintlimitVal) external onlyOwner {
}
function getPubliclistLimit() external view returns (uint256) {
}
function setSaleLimit(uint256 _mintlimitVal) external onlyOwner {
}
function getSaleLimit() external view returns (uint256) {
}
function setAibolistPrice(uint256 _price) external onlyOwner {
}
function getAibolistPrice() external view returns (uint256) {
}
function setPubliclistPrice(uint256 _price) external onlyOwner {
}
function getPubliclistPrice() external view returns (uint256) {
}
function setSalePrice(uint256 _price) external onlyOwner {
}
function getSalePrice() external view returns (uint256) {
}
function getAibolistMintedCountList() external view returns (uint256) {
}
function getPubliclistMintedCountList() external view returns (uint256) {
}
function getSaleMintedCountList() external view returns (uint256) {
}
function setMaxSupply(uint256 _maxSupply) external onlyOwner {
}
function getMaxSupply() external view returns (uint256) {
}
function totalSupply() external view returns (uint256) {
}
function getGoodMintedCount() external view returns (uint256) {
}
function getEvilMintedCount() external view returns (uint256) {
}
function getNftMintPrice(uint256 amount) external view returns (uint256) {
}
function getUserWhiteListed(bytes32[] calldata _merkleProof)
external
view
returns (uint256)
{
}
function reveal() external onlyOwner {
}
function setBaseURI(string memory baseURI) external onlyOwner {
}
function getBaseURI() external view returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setNotRevealedURI(string memory _gooduri, string memory _eviluri)
external
onlyOwner
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function withdrawAll() external onlyOwner {
}
receive() external payable {
}
fallback() external payable {
}
function teamMint(
uint256 _mintAmount,
uint256 _nftType,
address toMember
) external onlyOwner {
}
function mint(
uint256 _mintAmount,
bytes32[] calldata _merkleProof,
uint256 _nftType
) external payable {
require(!paused, "The contract is paused");
require(
_nftMintedCount + _mintAmount <= MAX_SUPPLY,
"Already Finished Minting"
);
require(_mintAmount > 0, "mintAmount must be bigger than 0");
uint256 currentPrice;
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
if (mintType == 0) {
require(
MerkleProof.verify(
_merkleProof,
merkleAibolistListRoot,
leaf
) == true,
"Not registered at Aibolist"
);
require(
_AibolistMintedCountList[msg.sender] + _mintAmount <=
AibolistLimit,
"Overflow of aibolist mint limit"
);
require(
_aibolistMintedCnt + _mintAmount <= AibolistTotalLimit,
"Overflow of AibolistTotalLimit"
);
currentPrice = AibolistPrice;
_AibolistMintedCountList[msg.sender] += _mintAmount;
_aibolistMintedCnt += _mintAmount;
} else if (mintType == 1) {
require(
MerkleProof.verify(
_merkleProof,
merklePubliclistListRoot,
leaf
) == true,
"Not registered at Publiclist"
);
require(<FILL_ME>)
require(
_publiclistMintedCnt + _mintAmount <= PubliclistTotalLimit,
"Overflow of PubliclistTotalLimit"
);
currentPrice = PubliclistPrice;
_PubliclistMintedCountList[msg.sender] += _mintAmount;
_publiclistMintedCnt += _mintAmount;
} else {
require(
_SaleMintedCountList[msg.sender] + _mintAmount <= SaleLimit,
"Overflow of sale mint limit"
);
require(
_salelistMintedCnt + _mintAmount <=
MAX_SUPPLY - PubliclistTotalLimit - AibolistTotalLimit,
"Overflow of SalelistTotalLimit"
);
currentPrice = SalePrice;
_SaleMintedCountList[msg.sender] += _mintAmount;
_salelistMintedCnt += _mintAmount;
}
currentPrice = currentPrice * _mintAmount;
require(currentPrice <= msg.value, "Not Enough Money");
if (_nftType == 1) {
require(
_goodNftMintedCount + _mintAmount <= MAX_GOOD_OR_EVIL_COUNT,
"Overflow of MAX good eggs"
);
require(
_goodNftMintedCount + _evilNftMintedCount + _mintAmount <=
MAX_SUPPLY,
"Overflow of MAX_SUPPLY"
);
emit EggType("GoodEgg", msg.sender);
uint256 idx;
for (idx = 0; idx < _mintAmount; idx++) {
_nftMintedCount++;
_goodNftMintedCount++;
_uriToTokenId[_nftMintedCount + idx] = _goodNftMintedCount;
_safeMint(msg.sender, _nftMintedCount);
}
} else {
require(
_evilNftMintedCount + _mintAmount <= MAX_GOOD_OR_EVIL_COUNT,
"Overflow of MAX evil eggs"
);
require(
_goodNftMintedCount + _evilNftMintedCount + _mintAmount <=
MAX_SUPPLY,
"Overflow of MAX_SUPPLY"
);
emit EggType("EvilEgg", msg.sender);
uint256 idx;
for (idx = 0; idx < _mintAmount; idx++) {
_nftMintedCount++;
_evilNftMintedCount++;
_uriToTokenId[_nftMintedCount + idx] =
MAX_GOOD_OR_EVIL_COUNT +
_evilNftMintedCount;
_safeMint(msg.sender, _nftMintedCount);
}
}
}
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) {
}
}
| _PubliclistMintedCountList[msg.sender]+_mintAmount<=PubliclistLimit,"Overflow of public mint limit" | 463,998 | _PubliclistMintedCountList[msg.sender]+_mintAmount<=PubliclistLimit |
"Overflow of PubliclistTotalLimit" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
// import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import {DefaultOperatorFilterer} from "./DefaultOperatorFilterer.sol";
// import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/cryptography/MerkleProof.sol";
import "./MerkleProof.sol";
contract AiboAdventuresNFT is
ERC721,
Ownable,
DefaultOperatorFilterer
{
event Received(address, uint256);
event Fallback(address, uint256);
event SetMaxSupply(address addr, uint256 _maxSupply);
event SetAibolistPrice(address addr, uint256 _price);
event SetPubliclistPrice(address addr, uint256 _price);
event SetPlPrice(address addr, uint256 _price);
event SetAibolistLimit(address addr, uint256 _count);
event SetPubliclistLimit(address addr, uint256 _count);
event SetSaleLimit(address addr, uint256 _count);
event WithdrawAll(address addr, uint256 cro);
event SetBaseURI(string baseURI);
event SetGoldenList(address _user);
event SetAibolistList(address _user);
event SetPubliclistList(address _user);
event EggType(string _eggtype, address addr);
event SetPlList(address _user);
using Strings for uint256;
uint256 private MAX_SUPPLY;
uint256 private MAX_GOOD_OR_EVIL_COUNT;
uint256 private AibolistPrice;
uint256 private PubliclistPrice;
uint256 private SalePrice;
uint256 private AibolistLimit;
uint256 private PubliclistLimit;
uint256 private SaleLimit;
uint256 private AibolistTotalLimit;
uint256 private PubliclistTotalLimit;
uint256 private TeamTotalLimit;
uint256 private _aibolistMintedCnt;
uint256 private _publiclistMintedCnt;
uint256 private _salelistMintedCnt;
uint256 private _teamMintedCnt;
uint256 private _nftMintedCount;
uint256 private _goodNftMintedCount;
uint256 private _evilNftMintedCount;
uint256 private mintType;
string private _baseURIExtended;
string private _baseExtension;
bool private revealed;
string private notRevealedGoodEggUri;
string private notRevealedEvilEggUri;
bool private paused;
mapping(address => uint256) _AibolistMintedCountList;
mapping(address => uint256) _PubliclistMintedCountList;
mapping(address => uint256) _SaleMintedCountList;
mapping(uint256 => uint256) _uriToTokenId;
bytes32 private merkleAibolistListRoot;
bytes32 private merklePubliclistListRoot;
constructor() ERC721 ("Aibo Adventures", "AA"){
}
function pause(bool _state) external onlyOwner {
}
function setMintType(uint256 nftMintType) external onlyOwner {
}
function getMintType() external view returns (uint256) {
}
function setAibolistMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function getAibolistMerkleRoot() external view returns (bytes32) {
}
function setPubliclistMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function getPubliclistMerkleRoot() external view returns (bytes32) {
}
function setTeamTotalLimit(uint256 _totallimitVal) external onlyOwner {
}
function getTeamTotalLimit() external view returns (uint256) {
}
function setAibolistTotalLimit(uint256 _totallimitVal) external onlyOwner {
}
function getAibolistTotalLimit() external view returns (uint256) {
}
function setPubliclistTotalLimit(uint256 _totallimitVal)
external
onlyOwner
{
}
function getPubliclistTotalLimit() external view returns (uint256) {
}
function setAibolistLimit(uint256 _mintlimitVal) external onlyOwner {
}
function getAibolistLimit() external view returns (uint256) {
}
function setPubliclistLimit(uint256 _mintlimitVal) external onlyOwner {
}
function getPubliclistLimit() external view returns (uint256) {
}
function setSaleLimit(uint256 _mintlimitVal) external onlyOwner {
}
function getSaleLimit() external view returns (uint256) {
}
function setAibolistPrice(uint256 _price) external onlyOwner {
}
function getAibolistPrice() external view returns (uint256) {
}
function setPubliclistPrice(uint256 _price) external onlyOwner {
}
function getPubliclistPrice() external view returns (uint256) {
}
function setSalePrice(uint256 _price) external onlyOwner {
}
function getSalePrice() external view returns (uint256) {
}
function getAibolistMintedCountList() external view returns (uint256) {
}
function getPubliclistMintedCountList() external view returns (uint256) {
}
function getSaleMintedCountList() external view returns (uint256) {
}
function setMaxSupply(uint256 _maxSupply) external onlyOwner {
}
function getMaxSupply() external view returns (uint256) {
}
function totalSupply() external view returns (uint256) {
}
function getGoodMintedCount() external view returns (uint256) {
}
function getEvilMintedCount() external view returns (uint256) {
}
function getNftMintPrice(uint256 amount) external view returns (uint256) {
}
function getUserWhiteListed(bytes32[] calldata _merkleProof)
external
view
returns (uint256)
{
}
function reveal() external onlyOwner {
}
function setBaseURI(string memory baseURI) external onlyOwner {
}
function getBaseURI() external view returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setNotRevealedURI(string memory _gooduri, string memory _eviluri)
external
onlyOwner
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function withdrawAll() external onlyOwner {
}
receive() external payable {
}
fallback() external payable {
}
function teamMint(
uint256 _mintAmount,
uint256 _nftType,
address toMember
) external onlyOwner {
}
function mint(
uint256 _mintAmount,
bytes32[] calldata _merkleProof,
uint256 _nftType
) external payable {
require(!paused, "The contract is paused");
require(
_nftMintedCount + _mintAmount <= MAX_SUPPLY,
"Already Finished Minting"
);
require(_mintAmount > 0, "mintAmount must be bigger than 0");
uint256 currentPrice;
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
if (mintType == 0) {
require(
MerkleProof.verify(
_merkleProof,
merkleAibolistListRoot,
leaf
) == true,
"Not registered at Aibolist"
);
require(
_AibolistMintedCountList[msg.sender] + _mintAmount <=
AibolistLimit,
"Overflow of aibolist mint limit"
);
require(
_aibolistMintedCnt + _mintAmount <= AibolistTotalLimit,
"Overflow of AibolistTotalLimit"
);
currentPrice = AibolistPrice;
_AibolistMintedCountList[msg.sender] += _mintAmount;
_aibolistMintedCnt += _mintAmount;
} else if (mintType == 1) {
require(
MerkleProof.verify(
_merkleProof,
merklePubliclistListRoot,
leaf
) == true,
"Not registered at Publiclist"
);
require(
_PubliclistMintedCountList[msg.sender] + _mintAmount <=
PubliclistLimit,
"Overflow of public mint limit"
);
require(<FILL_ME>)
currentPrice = PubliclistPrice;
_PubliclistMintedCountList[msg.sender] += _mintAmount;
_publiclistMintedCnt += _mintAmount;
} else {
require(
_SaleMintedCountList[msg.sender] + _mintAmount <= SaleLimit,
"Overflow of sale mint limit"
);
require(
_salelistMintedCnt + _mintAmount <=
MAX_SUPPLY - PubliclistTotalLimit - AibolistTotalLimit,
"Overflow of SalelistTotalLimit"
);
currentPrice = SalePrice;
_SaleMintedCountList[msg.sender] += _mintAmount;
_salelistMintedCnt += _mintAmount;
}
currentPrice = currentPrice * _mintAmount;
require(currentPrice <= msg.value, "Not Enough Money");
if (_nftType == 1) {
require(
_goodNftMintedCount + _mintAmount <= MAX_GOOD_OR_EVIL_COUNT,
"Overflow of MAX good eggs"
);
require(
_goodNftMintedCount + _evilNftMintedCount + _mintAmount <=
MAX_SUPPLY,
"Overflow of MAX_SUPPLY"
);
emit EggType("GoodEgg", msg.sender);
uint256 idx;
for (idx = 0; idx < _mintAmount; idx++) {
_nftMintedCount++;
_goodNftMintedCount++;
_uriToTokenId[_nftMintedCount + idx] = _goodNftMintedCount;
_safeMint(msg.sender, _nftMintedCount);
}
} else {
require(
_evilNftMintedCount + _mintAmount <= MAX_GOOD_OR_EVIL_COUNT,
"Overflow of MAX evil eggs"
);
require(
_goodNftMintedCount + _evilNftMintedCount + _mintAmount <=
MAX_SUPPLY,
"Overflow of MAX_SUPPLY"
);
emit EggType("EvilEgg", msg.sender);
uint256 idx;
for (idx = 0; idx < _mintAmount; idx++) {
_nftMintedCount++;
_evilNftMintedCount++;
_uriToTokenId[_nftMintedCount + idx] =
MAX_GOOD_OR_EVIL_COUNT +
_evilNftMintedCount;
_safeMint(msg.sender, _nftMintedCount);
}
}
}
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) {
}
}
| _publiclistMintedCnt+_mintAmount<=PubliclistTotalLimit,"Overflow of PubliclistTotalLimit" | 463,998 | _publiclistMintedCnt+_mintAmount<=PubliclistTotalLimit |
"Overflow of sale mint limit" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
// import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import {DefaultOperatorFilterer} from "./DefaultOperatorFilterer.sol";
// import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/cryptography/MerkleProof.sol";
import "./MerkleProof.sol";
contract AiboAdventuresNFT is
ERC721,
Ownable,
DefaultOperatorFilterer
{
event Received(address, uint256);
event Fallback(address, uint256);
event SetMaxSupply(address addr, uint256 _maxSupply);
event SetAibolistPrice(address addr, uint256 _price);
event SetPubliclistPrice(address addr, uint256 _price);
event SetPlPrice(address addr, uint256 _price);
event SetAibolistLimit(address addr, uint256 _count);
event SetPubliclistLimit(address addr, uint256 _count);
event SetSaleLimit(address addr, uint256 _count);
event WithdrawAll(address addr, uint256 cro);
event SetBaseURI(string baseURI);
event SetGoldenList(address _user);
event SetAibolistList(address _user);
event SetPubliclistList(address _user);
event EggType(string _eggtype, address addr);
event SetPlList(address _user);
using Strings for uint256;
uint256 private MAX_SUPPLY;
uint256 private MAX_GOOD_OR_EVIL_COUNT;
uint256 private AibolistPrice;
uint256 private PubliclistPrice;
uint256 private SalePrice;
uint256 private AibolistLimit;
uint256 private PubliclistLimit;
uint256 private SaleLimit;
uint256 private AibolistTotalLimit;
uint256 private PubliclistTotalLimit;
uint256 private TeamTotalLimit;
uint256 private _aibolistMintedCnt;
uint256 private _publiclistMintedCnt;
uint256 private _salelistMintedCnt;
uint256 private _teamMintedCnt;
uint256 private _nftMintedCount;
uint256 private _goodNftMintedCount;
uint256 private _evilNftMintedCount;
uint256 private mintType;
string private _baseURIExtended;
string private _baseExtension;
bool private revealed;
string private notRevealedGoodEggUri;
string private notRevealedEvilEggUri;
bool private paused;
mapping(address => uint256) _AibolistMintedCountList;
mapping(address => uint256) _PubliclistMintedCountList;
mapping(address => uint256) _SaleMintedCountList;
mapping(uint256 => uint256) _uriToTokenId;
bytes32 private merkleAibolistListRoot;
bytes32 private merklePubliclistListRoot;
constructor() ERC721 ("Aibo Adventures", "AA"){
}
function pause(bool _state) external onlyOwner {
}
function setMintType(uint256 nftMintType) external onlyOwner {
}
function getMintType() external view returns (uint256) {
}
function setAibolistMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function getAibolistMerkleRoot() external view returns (bytes32) {
}
function setPubliclistMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function getPubliclistMerkleRoot() external view returns (bytes32) {
}
function setTeamTotalLimit(uint256 _totallimitVal) external onlyOwner {
}
function getTeamTotalLimit() external view returns (uint256) {
}
function setAibolistTotalLimit(uint256 _totallimitVal) external onlyOwner {
}
function getAibolistTotalLimit() external view returns (uint256) {
}
function setPubliclistTotalLimit(uint256 _totallimitVal)
external
onlyOwner
{
}
function getPubliclistTotalLimit() external view returns (uint256) {
}
function setAibolistLimit(uint256 _mintlimitVal) external onlyOwner {
}
function getAibolistLimit() external view returns (uint256) {
}
function setPubliclistLimit(uint256 _mintlimitVal) external onlyOwner {
}
function getPubliclistLimit() external view returns (uint256) {
}
function setSaleLimit(uint256 _mintlimitVal) external onlyOwner {
}
function getSaleLimit() external view returns (uint256) {
}
function setAibolistPrice(uint256 _price) external onlyOwner {
}
function getAibolistPrice() external view returns (uint256) {
}
function setPubliclistPrice(uint256 _price) external onlyOwner {
}
function getPubliclistPrice() external view returns (uint256) {
}
function setSalePrice(uint256 _price) external onlyOwner {
}
function getSalePrice() external view returns (uint256) {
}
function getAibolistMintedCountList() external view returns (uint256) {
}
function getPubliclistMintedCountList() external view returns (uint256) {
}
function getSaleMintedCountList() external view returns (uint256) {
}
function setMaxSupply(uint256 _maxSupply) external onlyOwner {
}
function getMaxSupply() external view returns (uint256) {
}
function totalSupply() external view returns (uint256) {
}
function getGoodMintedCount() external view returns (uint256) {
}
function getEvilMintedCount() external view returns (uint256) {
}
function getNftMintPrice(uint256 amount) external view returns (uint256) {
}
function getUserWhiteListed(bytes32[] calldata _merkleProof)
external
view
returns (uint256)
{
}
function reveal() external onlyOwner {
}
function setBaseURI(string memory baseURI) external onlyOwner {
}
function getBaseURI() external view returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setNotRevealedURI(string memory _gooduri, string memory _eviluri)
external
onlyOwner
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function withdrawAll() external onlyOwner {
}
receive() external payable {
}
fallback() external payable {
}
function teamMint(
uint256 _mintAmount,
uint256 _nftType,
address toMember
) external onlyOwner {
}
function mint(
uint256 _mintAmount,
bytes32[] calldata _merkleProof,
uint256 _nftType
) external payable {
require(!paused, "The contract is paused");
require(
_nftMintedCount + _mintAmount <= MAX_SUPPLY,
"Already Finished Minting"
);
require(_mintAmount > 0, "mintAmount must be bigger than 0");
uint256 currentPrice;
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
if (mintType == 0) {
require(
MerkleProof.verify(
_merkleProof,
merkleAibolistListRoot,
leaf
) == true,
"Not registered at Aibolist"
);
require(
_AibolistMintedCountList[msg.sender] + _mintAmount <=
AibolistLimit,
"Overflow of aibolist mint limit"
);
require(
_aibolistMintedCnt + _mintAmount <= AibolistTotalLimit,
"Overflow of AibolistTotalLimit"
);
currentPrice = AibolistPrice;
_AibolistMintedCountList[msg.sender] += _mintAmount;
_aibolistMintedCnt += _mintAmount;
} else if (mintType == 1) {
require(
MerkleProof.verify(
_merkleProof,
merklePubliclistListRoot,
leaf
) == true,
"Not registered at Publiclist"
);
require(
_PubliclistMintedCountList[msg.sender] + _mintAmount <=
PubliclistLimit,
"Overflow of public mint limit"
);
require(
_publiclistMintedCnt + _mintAmount <= PubliclistTotalLimit,
"Overflow of PubliclistTotalLimit"
);
currentPrice = PubliclistPrice;
_PubliclistMintedCountList[msg.sender] += _mintAmount;
_publiclistMintedCnt += _mintAmount;
} else {
require(<FILL_ME>)
require(
_salelistMintedCnt + _mintAmount <=
MAX_SUPPLY - PubliclistTotalLimit - AibolistTotalLimit,
"Overflow of SalelistTotalLimit"
);
currentPrice = SalePrice;
_SaleMintedCountList[msg.sender] += _mintAmount;
_salelistMintedCnt += _mintAmount;
}
currentPrice = currentPrice * _mintAmount;
require(currentPrice <= msg.value, "Not Enough Money");
if (_nftType == 1) {
require(
_goodNftMintedCount + _mintAmount <= MAX_GOOD_OR_EVIL_COUNT,
"Overflow of MAX good eggs"
);
require(
_goodNftMintedCount + _evilNftMintedCount + _mintAmount <=
MAX_SUPPLY,
"Overflow of MAX_SUPPLY"
);
emit EggType("GoodEgg", msg.sender);
uint256 idx;
for (idx = 0; idx < _mintAmount; idx++) {
_nftMintedCount++;
_goodNftMintedCount++;
_uriToTokenId[_nftMintedCount + idx] = _goodNftMintedCount;
_safeMint(msg.sender, _nftMintedCount);
}
} else {
require(
_evilNftMintedCount + _mintAmount <= MAX_GOOD_OR_EVIL_COUNT,
"Overflow of MAX evil eggs"
);
require(
_goodNftMintedCount + _evilNftMintedCount + _mintAmount <=
MAX_SUPPLY,
"Overflow of MAX_SUPPLY"
);
emit EggType("EvilEgg", msg.sender);
uint256 idx;
for (idx = 0; idx < _mintAmount; idx++) {
_nftMintedCount++;
_evilNftMintedCount++;
_uriToTokenId[_nftMintedCount + idx] =
MAX_GOOD_OR_EVIL_COUNT +
_evilNftMintedCount;
_safeMint(msg.sender, _nftMintedCount);
}
}
}
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) {
}
}
| _SaleMintedCountList[msg.sender]+_mintAmount<=SaleLimit,"Overflow of sale mint limit" | 463,998 | _SaleMintedCountList[msg.sender]+_mintAmount<=SaleLimit |
"Overflow of SalelistTotalLimit" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
// import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import {DefaultOperatorFilterer} from "./DefaultOperatorFilterer.sol";
// import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/cryptography/MerkleProof.sol";
import "./MerkleProof.sol";
contract AiboAdventuresNFT is
ERC721,
Ownable,
DefaultOperatorFilterer
{
event Received(address, uint256);
event Fallback(address, uint256);
event SetMaxSupply(address addr, uint256 _maxSupply);
event SetAibolistPrice(address addr, uint256 _price);
event SetPubliclistPrice(address addr, uint256 _price);
event SetPlPrice(address addr, uint256 _price);
event SetAibolistLimit(address addr, uint256 _count);
event SetPubliclistLimit(address addr, uint256 _count);
event SetSaleLimit(address addr, uint256 _count);
event WithdrawAll(address addr, uint256 cro);
event SetBaseURI(string baseURI);
event SetGoldenList(address _user);
event SetAibolistList(address _user);
event SetPubliclistList(address _user);
event EggType(string _eggtype, address addr);
event SetPlList(address _user);
using Strings for uint256;
uint256 private MAX_SUPPLY;
uint256 private MAX_GOOD_OR_EVIL_COUNT;
uint256 private AibolistPrice;
uint256 private PubliclistPrice;
uint256 private SalePrice;
uint256 private AibolistLimit;
uint256 private PubliclistLimit;
uint256 private SaleLimit;
uint256 private AibolistTotalLimit;
uint256 private PubliclistTotalLimit;
uint256 private TeamTotalLimit;
uint256 private _aibolistMintedCnt;
uint256 private _publiclistMintedCnt;
uint256 private _salelistMintedCnt;
uint256 private _teamMintedCnt;
uint256 private _nftMintedCount;
uint256 private _goodNftMintedCount;
uint256 private _evilNftMintedCount;
uint256 private mintType;
string private _baseURIExtended;
string private _baseExtension;
bool private revealed;
string private notRevealedGoodEggUri;
string private notRevealedEvilEggUri;
bool private paused;
mapping(address => uint256) _AibolistMintedCountList;
mapping(address => uint256) _PubliclistMintedCountList;
mapping(address => uint256) _SaleMintedCountList;
mapping(uint256 => uint256) _uriToTokenId;
bytes32 private merkleAibolistListRoot;
bytes32 private merklePubliclistListRoot;
constructor() ERC721 ("Aibo Adventures", "AA"){
}
function pause(bool _state) external onlyOwner {
}
function setMintType(uint256 nftMintType) external onlyOwner {
}
function getMintType() external view returns (uint256) {
}
function setAibolistMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function getAibolistMerkleRoot() external view returns (bytes32) {
}
function setPubliclistMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function getPubliclistMerkleRoot() external view returns (bytes32) {
}
function setTeamTotalLimit(uint256 _totallimitVal) external onlyOwner {
}
function getTeamTotalLimit() external view returns (uint256) {
}
function setAibolistTotalLimit(uint256 _totallimitVal) external onlyOwner {
}
function getAibolistTotalLimit() external view returns (uint256) {
}
function setPubliclistTotalLimit(uint256 _totallimitVal)
external
onlyOwner
{
}
function getPubliclistTotalLimit() external view returns (uint256) {
}
function setAibolistLimit(uint256 _mintlimitVal) external onlyOwner {
}
function getAibolistLimit() external view returns (uint256) {
}
function setPubliclistLimit(uint256 _mintlimitVal) external onlyOwner {
}
function getPubliclistLimit() external view returns (uint256) {
}
function setSaleLimit(uint256 _mintlimitVal) external onlyOwner {
}
function getSaleLimit() external view returns (uint256) {
}
function setAibolistPrice(uint256 _price) external onlyOwner {
}
function getAibolistPrice() external view returns (uint256) {
}
function setPubliclistPrice(uint256 _price) external onlyOwner {
}
function getPubliclistPrice() external view returns (uint256) {
}
function setSalePrice(uint256 _price) external onlyOwner {
}
function getSalePrice() external view returns (uint256) {
}
function getAibolistMintedCountList() external view returns (uint256) {
}
function getPubliclistMintedCountList() external view returns (uint256) {
}
function getSaleMintedCountList() external view returns (uint256) {
}
function setMaxSupply(uint256 _maxSupply) external onlyOwner {
}
function getMaxSupply() external view returns (uint256) {
}
function totalSupply() external view returns (uint256) {
}
function getGoodMintedCount() external view returns (uint256) {
}
function getEvilMintedCount() external view returns (uint256) {
}
function getNftMintPrice(uint256 amount) external view returns (uint256) {
}
function getUserWhiteListed(bytes32[] calldata _merkleProof)
external
view
returns (uint256)
{
}
function reveal() external onlyOwner {
}
function setBaseURI(string memory baseURI) external onlyOwner {
}
function getBaseURI() external view returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setNotRevealedURI(string memory _gooduri, string memory _eviluri)
external
onlyOwner
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function withdrawAll() external onlyOwner {
}
receive() external payable {
}
fallback() external payable {
}
function teamMint(
uint256 _mintAmount,
uint256 _nftType,
address toMember
) external onlyOwner {
}
function mint(
uint256 _mintAmount,
bytes32[] calldata _merkleProof,
uint256 _nftType
) external payable {
require(!paused, "The contract is paused");
require(
_nftMintedCount + _mintAmount <= MAX_SUPPLY,
"Already Finished Minting"
);
require(_mintAmount > 0, "mintAmount must be bigger than 0");
uint256 currentPrice;
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
if (mintType == 0) {
require(
MerkleProof.verify(
_merkleProof,
merkleAibolistListRoot,
leaf
) == true,
"Not registered at Aibolist"
);
require(
_AibolistMintedCountList[msg.sender] + _mintAmount <=
AibolistLimit,
"Overflow of aibolist mint limit"
);
require(
_aibolistMintedCnt + _mintAmount <= AibolistTotalLimit,
"Overflow of AibolistTotalLimit"
);
currentPrice = AibolistPrice;
_AibolistMintedCountList[msg.sender] += _mintAmount;
_aibolistMintedCnt += _mintAmount;
} else if (mintType == 1) {
require(
MerkleProof.verify(
_merkleProof,
merklePubliclistListRoot,
leaf
) == true,
"Not registered at Publiclist"
);
require(
_PubliclistMintedCountList[msg.sender] + _mintAmount <=
PubliclistLimit,
"Overflow of public mint limit"
);
require(
_publiclistMintedCnt + _mintAmount <= PubliclistTotalLimit,
"Overflow of PubliclistTotalLimit"
);
currentPrice = PubliclistPrice;
_PubliclistMintedCountList[msg.sender] += _mintAmount;
_publiclistMintedCnt += _mintAmount;
} else {
require(
_SaleMintedCountList[msg.sender] + _mintAmount <= SaleLimit,
"Overflow of sale mint limit"
);
require(<FILL_ME>)
currentPrice = SalePrice;
_SaleMintedCountList[msg.sender] += _mintAmount;
_salelistMintedCnt += _mintAmount;
}
currentPrice = currentPrice * _mintAmount;
require(currentPrice <= msg.value, "Not Enough Money");
if (_nftType == 1) {
require(
_goodNftMintedCount + _mintAmount <= MAX_GOOD_OR_EVIL_COUNT,
"Overflow of MAX good eggs"
);
require(
_goodNftMintedCount + _evilNftMintedCount + _mintAmount <=
MAX_SUPPLY,
"Overflow of MAX_SUPPLY"
);
emit EggType("GoodEgg", msg.sender);
uint256 idx;
for (idx = 0; idx < _mintAmount; idx++) {
_nftMintedCount++;
_goodNftMintedCount++;
_uriToTokenId[_nftMintedCount + idx] = _goodNftMintedCount;
_safeMint(msg.sender, _nftMintedCount);
}
} else {
require(
_evilNftMintedCount + _mintAmount <= MAX_GOOD_OR_EVIL_COUNT,
"Overflow of MAX evil eggs"
);
require(
_goodNftMintedCount + _evilNftMintedCount + _mintAmount <=
MAX_SUPPLY,
"Overflow of MAX_SUPPLY"
);
emit EggType("EvilEgg", msg.sender);
uint256 idx;
for (idx = 0; idx < _mintAmount; idx++) {
_nftMintedCount++;
_evilNftMintedCount++;
_uriToTokenId[_nftMintedCount + idx] =
MAX_GOOD_OR_EVIL_COUNT +
_evilNftMintedCount;
_safeMint(msg.sender, _nftMintedCount);
}
}
}
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) {
}
}
| _salelistMintedCnt+_mintAmount<=MAX_SUPPLY-PubliclistTotalLimit-AibolistTotalLimit,"Overflow of SalelistTotalLimit" | 463,998 | _salelistMintedCnt+_mintAmount<=MAX_SUPPLY-PubliclistTotalLimit-AibolistTotalLimit |
"TokenBridge: paused" | // SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.15;
import "./ReentrancyGuard.sol";
import "./SafeERC20.sol";
import "./NonblockingLzApp.sol";
import "./LzLib.sol";
import "./IWETH.sol";
import "./ITokenBridge.sol";
contract TokenBridge is ITokenBridge, NonblockingLzApp, ReentrancyGuard {
using SafeERC20 for IERC20;
uint public constant BP_DENOMINATOR = 10000;
uint8 public constant SHARED_DECIMALS = 6;
uint16 public aptosChainId;
uint public bridgeFeeBP;
mapping(address => uint64) public tvlSDs; // token address => tvl
mapping(address => bool) public supportedTokens;
mapping(address => bool) public pausedTokens; // token address => paused
mapping(address => uint) public ld2sdRates; // token address => rate
address public weth;
bool public useCustomAdapterParams;
bool public globalPaused;
bool public emergencyWithdrawEnabled;
uint public emergencyWithdrawTime;
modifier whenNotPaused(address _token) {
require(<FILL_ME>)
_;
}
modifier emergencyWithdrawUnlocked() {
}
constructor(
address _layerZeroEndpoint,
uint16 _aptosChainId
) NonblockingLzApp(_layerZeroEndpoint) {
}
function sendToAptos(
address _token,
bytes32 _toAddress,
uint _amountLD,
LzLib.CallParams calldata _callParams,
bytes calldata _adapterParams
) external payable override whenNotPaused(_token) nonReentrant {
}
function sendETHToAptos(
bytes32 _toAddress,
uint _amountLD,
LzLib.CallParams calldata _callParams,
bytes calldata _adapterParams
) external payable override whenNotPaused(weth) nonReentrant {
}
function quoteForSend(LzLib.CallParams calldata _callParams, bytes calldata _adapterParams)
external
view
returns (uint nativeFee, uint zroFee)
{
}
// ---------------------- owner functions ----------------------
function registerToken(address _token) external onlyOwner {
}
function setBridgeFeeBP(uint _bridgeFeeBP) external onlyOwner {
}
function setWETH(address _weth) external onlyOwner {
}
function setGlobalPause(bool _paused) external onlyOwner {
}
function setTokenPause(address _token, bool _paused) external onlyOwner {
}
function setAptosChainId(uint16 _aptosChainId) external onlyOwner {
}
function setUseCustomAdapterParams(bool _useCustomAdapterParams) external onlyOwner {
}
function withdrawFee(
address _token,
address _to,
uint _amountLD
) public onlyOwner {
}
function withdrawTVL(
address _token,
address _to,
uint64 _amountSD
) public onlyOwner emergencyWithdrawUnlocked {
}
function withdrawEmergency(address _token, address _to) external onlyOwner {
}
function enableEmergencyWithdraw(bool enabled) external onlyOwner {
}
// override the renounce ownership inherited by zeppelin ownable
function renounceOwnership() public override onlyOwner {}
// receive ETH from WETH
receive() external payable {}
function accruedFeeLD(address _token) public view returns (uint) {
}
// ---------------------- internal functions ----------------------
function _nonblockingLzReceive(
uint16 _srcChainId,
bytes memory,
uint64,
bytes memory _payload
) internal override {
}
function _redeemETHTo(
address _weth,
address payable _to,
uint _amountLD
) internal {
}
function _lockTokenFrom(
address _token,
address _from,
uint _amountLD
) internal returns (uint) {
}
function _tokenDecimals(address _token) internal view returns (uint8) {
}
function _payFee(uint _amountLD) internal view returns (uint amountAfterFee, uint fee) {
}
function _sendToken(
address _token,
bytes32 _toAddress,
uint64 _amountSD,
LzLib.CallParams calldata _callParams,
bytes calldata _adapterParams,
uint _fee
) internal {
}
// send payload: packet type(1) + remote token(32) + receiver(32) + amount(8)
function _encodeSendPayload(
address _token,
bytes32 _toAddress,
uint64 _amountSD
) internal pure returns (bytes memory) {
}
// receive payload: packet type(1) + remote token(32) + receiver(32) + amount(8) + unwrap flag(1)
function _decodeReceivePayload(bytes memory _payload)
internal
pure
returns (
address token,
address to,
uint64 amountSD,
bool unwrap
)
{
}
function _checkAdapterParams(bytes calldata _adapterParams) internal view {
}
function _SDtoLD(address _token, uint64 _amountSD) internal view returns (uint) {
}
function _LDtoSD(address _token, uint _amountLD) internal view returns (uint64) {
}
function _removeDust(address _token, uint _amountLD) internal view returns (uint) {
}
}
| !globalPaused&&!pausedTokens[_token],"TokenBridge: paused" | 464,320 | !globalPaused&&!pausedTokens[_token] |
"TokenBridge: emergency withdraw locked" | // SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.15;
import "./ReentrancyGuard.sol";
import "./SafeERC20.sol";
import "./NonblockingLzApp.sol";
import "./LzLib.sol";
import "./IWETH.sol";
import "./ITokenBridge.sol";
contract TokenBridge is ITokenBridge, NonblockingLzApp, ReentrancyGuard {
using SafeERC20 for IERC20;
uint public constant BP_DENOMINATOR = 10000;
uint8 public constant SHARED_DECIMALS = 6;
uint16 public aptosChainId;
uint public bridgeFeeBP;
mapping(address => uint64) public tvlSDs; // token address => tvl
mapping(address => bool) public supportedTokens;
mapping(address => bool) public pausedTokens; // token address => paused
mapping(address => uint) public ld2sdRates; // token address => rate
address public weth;
bool public useCustomAdapterParams;
bool public globalPaused;
bool public emergencyWithdrawEnabled;
uint public emergencyWithdrawTime;
modifier whenNotPaused(address _token) {
}
modifier emergencyWithdrawUnlocked() {
require(<FILL_ME>)
_;
}
constructor(
address _layerZeroEndpoint,
uint16 _aptosChainId
) NonblockingLzApp(_layerZeroEndpoint) {
}
function sendToAptos(
address _token,
bytes32 _toAddress,
uint _amountLD,
LzLib.CallParams calldata _callParams,
bytes calldata _adapterParams
) external payable override whenNotPaused(_token) nonReentrant {
}
function sendETHToAptos(
bytes32 _toAddress,
uint _amountLD,
LzLib.CallParams calldata _callParams,
bytes calldata _adapterParams
) external payable override whenNotPaused(weth) nonReentrant {
}
function quoteForSend(LzLib.CallParams calldata _callParams, bytes calldata _adapterParams)
external
view
returns (uint nativeFee, uint zroFee)
{
}
// ---------------------- owner functions ----------------------
function registerToken(address _token) external onlyOwner {
}
function setBridgeFeeBP(uint _bridgeFeeBP) external onlyOwner {
}
function setWETH(address _weth) external onlyOwner {
}
function setGlobalPause(bool _paused) external onlyOwner {
}
function setTokenPause(address _token, bool _paused) external onlyOwner {
}
function setAptosChainId(uint16 _aptosChainId) external onlyOwner {
}
function setUseCustomAdapterParams(bool _useCustomAdapterParams) external onlyOwner {
}
function withdrawFee(
address _token,
address _to,
uint _amountLD
) public onlyOwner {
}
function withdrawTVL(
address _token,
address _to,
uint64 _amountSD
) public onlyOwner emergencyWithdrawUnlocked {
}
function withdrawEmergency(address _token, address _to) external onlyOwner {
}
function enableEmergencyWithdraw(bool enabled) external onlyOwner {
}
// override the renounce ownership inherited by zeppelin ownable
function renounceOwnership() public override onlyOwner {}
// receive ETH from WETH
receive() external payable {}
function accruedFeeLD(address _token) public view returns (uint) {
}
// ---------------------- internal functions ----------------------
function _nonblockingLzReceive(
uint16 _srcChainId,
bytes memory,
uint64,
bytes memory _payload
) internal override {
}
function _redeemETHTo(
address _weth,
address payable _to,
uint _amountLD
) internal {
}
function _lockTokenFrom(
address _token,
address _from,
uint _amountLD
) internal returns (uint) {
}
function _tokenDecimals(address _token) internal view returns (uint8) {
}
function _payFee(uint _amountLD) internal view returns (uint amountAfterFee, uint fee) {
}
function _sendToken(
address _token,
bytes32 _toAddress,
uint64 _amountSD,
LzLib.CallParams calldata _callParams,
bytes calldata _adapterParams,
uint _fee
) internal {
}
// send payload: packet type(1) + remote token(32) + receiver(32) + amount(8)
function _encodeSendPayload(
address _token,
bytes32 _toAddress,
uint64 _amountSD
) internal pure returns (bytes memory) {
}
// receive payload: packet type(1) + remote token(32) + receiver(32) + amount(8) + unwrap flag(1)
function _decodeReceivePayload(bytes memory _payload)
internal
pure
returns (
address token,
address to,
uint64 amountSD,
bool unwrap
)
{
}
function _checkAdapterParams(bytes calldata _adapterParams) internal view {
}
function _SDtoLD(address _token, uint64 _amountSD) internal view returns (uint) {
}
function _LDtoSD(address _token, uint _amountLD) internal view returns (uint64) {
}
function _removeDust(address _token, uint _amountLD) internal view returns (uint) {
}
}
| emergencyWithdrawEnabled&&block.timestamp>=emergencyWithdrawTime,"TokenBridge: emergency withdraw locked" | 464,320 | emergencyWithdrawEnabled&&block.timestamp>=emergencyWithdrawTime |
"TokenBridge: token is not supported" | // SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.15;
import "./ReentrancyGuard.sol";
import "./SafeERC20.sol";
import "./NonblockingLzApp.sol";
import "./LzLib.sol";
import "./IWETH.sol";
import "./ITokenBridge.sol";
contract TokenBridge is ITokenBridge, NonblockingLzApp, ReentrancyGuard {
using SafeERC20 for IERC20;
uint public constant BP_DENOMINATOR = 10000;
uint8 public constant SHARED_DECIMALS = 6;
uint16 public aptosChainId;
uint public bridgeFeeBP;
mapping(address => uint64) public tvlSDs; // token address => tvl
mapping(address => bool) public supportedTokens;
mapping(address => bool) public pausedTokens; // token address => paused
mapping(address => uint) public ld2sdRates; // token address => rate
address public weth;
bool public useCustomAdapterParams;
bool public globalPaused;
bool public emergencyWithdrawEnabled;
uint public emergencyWithdrawTime;
modifier whenNotPaused(address _token) {
}
modifier emergencyWithdrawUnlocked() {
}
constructor(
address _layerZeroEndpoint,
uint16 _aptosChainId
) NonblockingLzApp(_layerZeroEndpoint) {
}
function sendToAptos(
address _token,
bytes32 _toAddress,
uint _amountLD,
LzLib.CallParams calldata _callParams,
bytes calldata _adapterParams
) external payable override whenNotPaused(_token) nonReentrant {
require(<FILL_ME>)
// lock token
_amountLD = _removeDust(_token, _amountLD);
_amountLD = _lockTokenFrom(_token, msg.sender, _amountLD);
// add tvl
uint64 amountSD = _LDtoSD(_token, _amountLD);
require(amountSD > 0, "TokenBridge: amountSD must be greater than 0");
tvlSDs[_token] += amountSD;
// send to aptos
_sendToken(_token, _toAddress, amountSD, _callParams, _adapterParams, msg.value);
emit Send(_token, msg.sender, _toAddress, _amountLD);
}
function sendETHToAptos(
bytes32 _toAddress,
uint _amountLD,
LzLib.CallParams calldata _callParams,
bytes calldata _adapterParams
) external payable override whenNotPaused(weth) nonReentrant {
}
function quoteForSend(LzLib.CallParams calldata _callParams, bytes calldata _adapterParams)
external
view
returns (uint nativeFee, uint zroFee)
{
}
// ---------------------- owner functions ----------------------
function registerToken(address _token) external onlyOwner {
}
function setBridgeFeeBP(uint _bridgeFeeBP) external onlyOwner {
}
function setWETH(address _weth) external onlyOwner {
}
function setGlobalPause(bool _paused) external onlyOwner {
}
function setTokenPause(address _token, bool _paused) external onlyOwner {
}
function setAptosChainId(uint16 _aptosChainId) external onlyOwner {
}
function setUseCustomAdapterParams(bool _useCustomAdapterParams) external onlyOwner {
}
function withdrawFee(
address _token,
address _to,
uint _amountLD
) public onlyOwner {
}
function withdrawTVL(
address _token,
address _to,
uint64 _amountSD
) public onlyOwner emergencyWithdrawUnlocked {
}
function withdrawEmergency(address _token, address _to) external onlyOwner {
}
function enableEmergencyWithdraw(bool enabled) external onlyOwner {
}
// override the renounce ownership inherited by zeppelin ownable
function renounceOwnership() public override onlyOwner {}
// receive ETH from WETH
receive() external payable {}
function accruedFeeLD(address _token) public view returns (uint) {
}
// ---------------------- internal functions ----------------------
function _nonblockingLzReceive(
uint16 _srcChainId,
bytes memory,
uint64,
bytes memory _payload
) internal override {
}
function _redeemETHTo(
address _weth,
address payable _to,
uint _amountLD
) internal {
}
function _lockTokenFrom(
address _token,
address _from,
uint _amountLD
) internal returns (uint) {
}
function _tokenDecimals(address _token) internal view returns (uint8) {
}
function _payFee(uint _amountLD) internal view returns (uint amountAfterFee, uint fee) {
}
function _sendToken(
address _token,
bytes32 _toAddress,
uint64 _amountSD,
LzLib.CallParams calldata _callParams,
bytes calldata _adapterParams,
uint _fee
) internal {
}
// send payload: packet type(1) + remote token(32) + receiver(32) + amount(8)
function _encodeSendPayload(
address _token,
bytes32 _toAddress,
uint64 _amountSD
) internal pure returns (bytes memory) {
}
// receive payload: packet type(1) + remote token(32) + receiver(32) + amount(8) + unwrap flag(1)
function _decodeReceivePayload(bytes memory _payload)
internal
pure
returns (
address token,
address to,
uint64 amountSD,
bool unwrap
)
{
}
function _checkAdapterParams(bytes calldata _adapterParams) internal view {
}
function _SDtoLD(address _token, uint64 _amountSD) internal view returns (uint) {
}
function _LDtoSD(address _token, uint _amountLD) internal view returns (uint64) {
}
function _removeDust(address _token, uint _amountLD) internal view returns (uint) {
}
}
| supportedTokens[_token],"TokenBridge: token is not supported" | 464,320 | supportedTokens[_token] |
"TokenBridge: token already registered" | // SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.15;
import "./ReentrancyGuard.sol";
import "./SafeERC20.sol";
import "./NonblockingLzApp.sol";
import "./LzLib.sol";
import "./IWETH.sol";
import "./ITokenBridge.sol";
contract TokenBridge is ITokenBridge, NonblockingLzApp, ReentrancyGuard {
using SafeERC20 for IERC20;
uint public constant BP_DENOMINATOR = 10000;
uint8 public constant SHARED_DECIMALS = 6;
uint16 public aptosChainId;
uint public bridgeFeeBP;
mapping(address => uint64) public tvlSDs; // token address => tvl
mapping(address => bool) public supportedTokens;
mapping(address => bool) public pausedTokens; // token address => paused
mapping(address => uint) public ld2sdRates; // token address => rate
address public weth;
bool public useCustomAdapterParams;
bool public globalPaused;
bool public emergencyWithdrawEnabled;
uint public emergencyWithdrawTime;
modifier whenNotPaused(address _token) {
}
modifier emergencyWithdrawUnlocked() {
}
constructor(
address _layerZeroEndpoint,
uint16 _aptosChainId
) NonblockingLzApp(_layerZeroEndpoint) {
}
function sendToAptos(
address _token,
bytes32 _toAddress,
uint _amountLD,
LzLib.CallParams calldata _callParams,
bytes calldata _adapterParams
) external payable override whenNotPaused(_token) nonReentrant {
}
function sendETHToAptos(
bytes32 _toAddress,
uint _amountLD,
LzLib.CallParams calldata _callParams,
bytes calldata _adapterParams
) external payable override whenNotPaused(weth) nonReentrant {
}
function quoteForSend(LzLib.CallParams calldata _callParams, bytes calldata _adapterParams)
external
view
returns (uint nativeFee, uint zroFee)
{
}
// ---------------------- owner functions ----------------------
function registerToken(address _token) external onlyOwner {
require(_token != address(0), "TokenBridge: invalid token address");
require(<FILL_ME>)
uint8 localDecimals = _tokenDecimals(_token);
require(
localDecimals >= SHARED_DECIMALS,
"TokenBridge: decimals must be >= SHARED_DECIMALS"
);
supportedTokens[_token] = true;
ld2sdRates[_token] = 10**(localDecimals - SHARED_DECIMALS);
emit RegisterToken(_token);
}
function setBridgeFeeBP(uint _bridgeFeeBP) external onlyOwner {
}
function setWETH(address _weth) external onlyOwner {
}
function setGlobalPause(bool _paused) external onlyOwner {
}
function setTokenPause(address _token, bool _paused) external onlyOwner {
}
function setAptosChainId(uint16 _aptosChainId) external onlyOwner {
}
function setUseCustomAdapterParams(bool _useCustomAdapterParams) external onlyOwner {
}
function withdrawFee(
address _token,
address _to,
uint _amountLD
) public onlyOwner {
}
function withdrawTVL(
address _token,
address _to,
uint64 _amountSD
) public onlyOwner emergencyWithdrawUnlocked {
}
function withdrawEmergency(address _token, address _to) external onlyOwner {
}
function enableEmergencyWithdraw(bool enabled) external onlyOwner {
}
// override the renounce ownership inherited by zeppelin ownable
function renounceOwnership() public override onlyOwner {}
// receive ETH from WETH
receive() external payable {}
function accruedFeeLD(address _token) public view returns (uint) {
}
// ---------------------- internal functions ----------------------
function _nonblockingLzReceive(
uint16 _srcChainId,
bytes memory,
uint64,
bytes memory _payload
) internal override {
}
function _redeemETHTo(
address _weth,
address payable _to,
uint _amountLD
) internal {
}
function _lockTokenFrom(
address _token,
address _from,
uint _amountLD
) internal returns (uint) {
}
function _tokenDecimals(address _token) internal view returns (uint8) {
}
function _payFee(uint _amountLD) internal view returns (uint amountAfterFee, uint fee) {
}
function _sendToken(
address _token,
bytes32 _toAddress,
uint64 _amountSD,
LzLib.CallParams calldata _callParams,
bytes calldata _adapterParams,
uint _fee
) internal {
}
// send payload: packet type(1) + remote token(32) + receiver(32) + amount(8)
function _encodeSendPayload(
address _token,
bytes32 _toAddress,
uint64 _amountSD
) internal pure returns (bytes memory) {
}
// receive payload: packet type(1) + remote token(32) + receiver(32) + amount(8) + unwrap flag(1)
function _decodeReceivePayload(bytes memory _payload)
internal
pure
returns (
address token,
address to,
uint64 amountSD,
bool unwrap
)
{
}
function _checkAdapterParams(bytes calldata _adapterParams) internal view {
}
function _SDtoLD(address _token, uint64 _amountSD) internal view returns (uint) {
}
function _LDtoSD(address _token, uint _amountLD) internal view returns (uint64) {
}
function _removeDust(address _token, uint _amountLD) internal view returns (uint) {
}
}
| !supportedTokens[_token],"TokenBridge: token already registered" | 464,320 | !supportedTokens[_token] |
"TokenBridge: paused" | // SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.15;
import "./ReentrancyGuard.sol";
import "./SafeERC20.sol";
import "./NonblockingLzApp.sol";
import "./LzLib.sol";
import "./IWETH.sol";
import "./ITokenBridge.sol";
contract TokenBridge is ITokenBridge, NonblockingLzApp, ReentrancyGuard {
using SafeERC20 for IERC20;
uint public constant BP_DENOMINATOR = 10000;
uint8 public constant SHARED_DECIMALS = 6;
uint16 public aptosChainId;
uint public bridgeFeeBP;
mapping(address => uint64) public tvlSDs; // token address => tvl
mapping(address => bool) public supportedTokens;
mapping(address => bool) public pausedTokens; // token address => paused
mapping(address => uint) public ld2sdRates; // token address => rate
address public weth;
bool public useCustomAdapterParams;
bool public globalPaused;
bool public emergencyWithdrawEnabled;
uint public emergencyWithdrawTime;
modifier whenNotPaused(address _token) {
}
modifier emergencyWithdrawUnlocked() {
}
constructor(
address _layerZeroEndpoint,
uint16 _aptosChainId
) NonblockingLzApp(_layerZeroEndpoint) {
}
function sendToAptos(
address _token,
bytes32 _toAddress,
uint _amountLD,
LzLib.CallParams calldata _callParams,
bytes calldata _adapterParams
) external payable override whenNotPaused(_token) nonReentrant {
}
function sendETHToAptos(
bytes32 _toAddress,
uint _amountLD,
LzLib.CallParams calldata _callParams,
bytes calldata _adapterParams
) external payable override whenNotPaused(weth) nonReentrant {
}
function quoteForSend(LzLib.CallParams calldata _callParams, bytes calldata _adapterParams)
external
view
returns (uint nativeFee, uint zroFee)
{
}
// ---------------------- owner functions ----------------------
function registerToken(address _token) external onlyOwner {
}
function setBridgeFeeBP(uint _bridgeFeeBP) external onlyOwner {
}
function setWETH(address _weth) external onlyOwner {
}
function setGlobalPause(bool _paused) external onlyOwner {
}
function setTokenPause(address _token, bool _paused) external onlyOwner {
}
function setAptosChainId(uint16 _aptosChainId) external onlyOwner {
}
function setUseCustomAdapterParams(bool _useCustomAdapterParams) external onlyOwner {
}
function withdrawFee(
address _token,
address _to,
uint _amountLD
) public onlyOwner {
}
function withdrawTVL(
address _token,
address _to,
uint64 _amountSD
) public onlyOwner emergencyWithdrawUnlocked {
}
function withdrawEmergency(address _token, address _to) external onlyOwner {
}
function enableEmergencyWithdraw(bool enabled) external onlyOwner {
}
// override the renounce ownership inherited by zeppelin ownable
function renounceOwnership() public override onlyOwner {}
// receive ETH from WETH
receive() external payable {}
function accruedFeeLD(address _token) public view returns (uint) {
}
// ---------------------- internal functions ----------------------
function _nonblockingLzReceive(
uint16 _srcChainId,
bytes memory,
uint64,
bytes memory _payload
) internal override {
require(_srcChainId == aptosChainId, "TokenBridge: invalid source chain id");
(address token, address to, uint64 amountSD, bool unwrap) = _decodeReceivePayload(_payload);
require(<FILL_ME>)
require(supportedTokens[token], "TokenBridge: token is not supported");
// sub tvl
uint64 tvlSD = tvlSDs[token];
require(tvlSD >= amountSD, "TokenBridge: insufficient liquidity");
tvlSDs[token] = tvlSD - amountSD;
// pay fee
uint amountLD = _SDtoLD(token, amountSD);
(amountLD, ) = bridgeFeeBP > 0 ? _payFee(amountLD) : (amountLD, 0);
// redeem token to receiver
if (token == weth && unwrap) {
_redeemETHTo(weth, payable(to), amountLD);
emit Receive(address(0), to, amountLD);
} else {
to = to == address(0) ? address(0xdEaD) : to; // avoid failure in safeTransfer()
IERC20(token).safeTransfer(to, amountLD);
emit Receive(token, to, amountLD);
}
}
function _redeemETHTo(
address _weth,
address payable _to,
uint _amountLD
) internal {
}
function _lockTokenFrom(
address _token,
address _from,
uint _amountLD
) internal returns (uint) {
}
function _tokenDecimals(address _token) internal view returns (uint8) {
}
function _payFee(uint _amountLD) internal view returns (uint amountAfterFee, uint fee) {
}
function _sendToken(
address _token,
bytes32 _toAddress,
uint64 _amountSD,
LzLib.CallParams calldata _callParams,
bytes calldata _adapterParams,
uint _fee
) internal {
}
// send payload: packet type(1) + remote token(32) + receiver(32) + amount(8)
function _encodeSendPayload(
address _token,
bytes32 _toAddress,
uint64 _amountSD
) internal pure returns (bytes memory) {
}
// receive payload: packet type(1) + remote token(32) + receiver(32) + amount(8) + unwrap flag(1)
function _decodeReceivePayload(bytes memory _payload)
internal
pure
returns (
address token,
address to,
uint64 amountSD,
bool unwrap
)
{
}
function _checkAdapterParams(bytes calldata _adapterParams) internal view {
}
function _SDtoLD(address _token, uint64 _amountSD) internal view returns (uint) {
}
function _LDtoSD(address _token, uint _amountLD) internal view returns (uint64) {
}
function _removeDust(address _token, uint _amountLD) internal view returns (uint) {
}
}
| !globalPaused&&!pausedTokens[token],"TokenBridge: paused" | 464,320 | !globalPaused&&!pausedTokens[token] |
"TokenBridge: token is not supported" | // SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.15;
import "./ReentrancyGuard.sol";
import "./SafeERC20.sol";
import "./NonblockingLzApp.sol";
import "./LzLib.sol";
import "./IWETH.sol";
import "./ITokenBridge.sol";
contract TokenBridge is ITokenBridge, NonblockingLzApp, ReentrancyGuard {
using SafeERC20 for IERC20;
uint public constant BP_DENOMINATOR = 10000;
uint8 public constant SHARED_DECIMALS = 6;
uint16 public aptosChainId;
uint public bridgeFeeBP;
mapping(address => uint64) public tvlSDs; // token address => tvl
mapping(address => bool) public supportedTokens;
mapping(address => bool) public pausedTokens; // token address => paused
mapping(address => uint) public ld2sdRates; // token address => rate
address public weth;
bool public useCustomAdapterParams;
bool public globalPaused;
bool public emergencyWithdrawEnabled;
uint public emergencyWithdrawTime;
modifier whenNotPaused(address _token) {
}
modifier emergencyWithdrawUnlocked() {
}
constructor(
address _layerZeroEndpoint,
uint16 _aptosChainId
) NonblockingLzApp(_layerZeroEndpoint) {
}
function sendToAptos(
address _token,
bytes32 _toAddress,
uint _amountLD,
LzLib.CallParams calldata _callParams,
bytes calldata _adapterParams
) external payable override whenNotPaused(_token) nonReentrant {
}
function sendETHToAptos(
bytes32 _toAddress,
uint _amountLD,
LzLib.CallParams calldata _callParams,
bytes calldata _adapterParams
) external payable override whenNotPaused(weth) nonReentrant {
}
function quoteForSend(LzLib.CallParams calldata _callParams, bytes calldata _adapterParams)
external
view
returns (uint nativeFee, uint zroFee)
{
}
// ---------------------- owner functions ----------------------
function registerToken(address _token) external onlyOwner {
}
function setBridgeFeeBP(uint _bridgeFeeBP) external onlyOwner {
}
function setWETH(address _weth) external onlyOwner {
}
function setGlobalPause(bool _paused) external onlyOwner {
}
function setTokenPause(address _token, bool _paused) external onlyOwner {
}
function setAptosChainId(uint16 _aptosChainId) external onlyOwner {
}
function setUseCustomAdapterParams(bool _useCustomAdapterParams) external onlyOwner {
}
function withdrawFee(
address _token,
address _to,
uint _amountLD
) public onlyOwner {
}
function withdrawTVL(
address _token,
address _to,
uint64 _amountSD
) public onlyOwner emergencyWithdrawUnlocked {
}
function withdrawEmergency(address _token, address _to) external onlyOwner {
}
function enableEmergencyWithdraw(bool enabled) external onlyOwner {
}
// override the renounce ownership inherited by zeppelin ownable
function renounceOwnership() public override onlyOwner {}
// receive ETH from WETH
receive() external payable {}
function accruedFeeLD(address _token) public view returns (uint) {
}
// ---------------------- internal functions ----------------------
function _nonblockingLzReceive(
uint16 _srcChainId,
bytes memory,
uint64,
bytes memory _payload
) internal override {
require(_srcChainId == aptosChainId, "TokenBridge: invalid source chain id");
(address token, address to, uint64 amountSD, bool unwrap) = _decodeReceivePayload(_payload);
require(!globalPaused && !pausedTokens[token], "TokenBridge: paused");
require(<FILL_ME>)
// sub tvl
uint64 tvlSD = tvlSDs[token];
require(tvlSD >= amountSD, "TokenBridge: insufficient liquidity");
tvlSDs[token] = tvlSD - amountSD;
// pay fee
uint amountLD = _SDtoLD(token, amountSD);
(amountLD, ) = bridgeFeeBP > 0 ? _payFee(amountLD) : (amountLD, 0);
// redeem token to receiver
if (token == weth && unwrap) {
_redeemETHTo(weth, payable(to), amountLD);
emit Receive(address(0), to, amountLD);
} else {
to = to == address(0) ? address(0xdEaD) : to; // avoid failure in safeTransfer()
IERC20(token).safeTransfer(to, amountLD);
emit Receive(token, to, amountLD);
}
}
function _redeemETHTo(
address _weth,
address payable _to,
uint _amountLD
) internal {
}
function _lockTokenFrom(
address _token,
address _from,
uint _amountLD
) internal returns (uint) {
}
function _tokenDecimals(address _token) internal view returns (uint8) {
}
function _payFee(uint _amountLD) internal view returns (uint amountAfterFee, uint fee) {
}
function _sendToken(
address _token,
bytes32 _toAddress,
uint64 _amountSD,
LzLib.CallParams calldata _callParams,
bytes calldata _adapterParams,
uint _fee
) internal {
}
// send payload: packet type(1) + remote token(32) + receiver(32) + amount(8)
function _encodeSendPayload(
address _token,
bytes32 _toAddress,
uint64 _amountSD
) internal pure returns (bytes memory) {
}
// receive payload: packet type(1) + remote token(32) + receiver(32) + amount(8) + unwrap flag(1)
function _decodeReceivePayload(bytes memory _payload)
internal
pure
returns (
address token,
address to,
uint64 amountSD,
bool unwrap
)
{
}
function _checkAdapterParams(bytes calldata _adapterParams) internal view {
}
function _SDtoLD(address _token, uint64 _amountSD) internal view returns (uint) {
}
function _LDtoSD(address _token, uint _amountLD) internal view returns (uint64) {
}
function _removeDust(address _token, uint _amountLD) internal view returns (uint) {
}
}
| supportedTokens[token],"TokenBridge: token is not supported" | 464,320 | supportedTokens[token] |
"Total is not equal to 100" | pragma solidity 0.5.17;
interface Hasher {
function MiMCSponge(uint256 in_xL, uint256 in_xR) external pure returns (uint256 xL, uint256 xR);
}
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ReentrancyGuard {
uint256 private _guardCounter;
constructor () internal {
}
modifier nonReentrant() {
}
}
contract MerkleTreeWithHistory {
uint256 constant FIELD_SIZE = 21888242871839275222246405745257275088548364400416034343698204186575808495617;
uint256 constant ZERO_VALUE = 21663839004416932945382355908790599225266501822907911457504978515578255421292;
uint32 levels;
bytes32[] filledSubtrees;
bytes32[] zeros;
uint32 currentRootIndex = 0;
uint32 nextIndex = 0;
uint32 constant ROOT_HISTORY_SIZE = 100;
bytes32[ROOT_HISTORY_SIZE] roots;
constructor(uint32 _treeLevels) public {
}
function hashLeftRight(bytes32 _left, bytes32 _right) public pure returns (bytes32) {
}
function _insert(bytes32 _leaf) internal returns(uint32 index) {
}
function isKnownRoot(bytes32 _root) public view returns(bool) {
}
function getLastRoot() public view returns(bytes32) {
}
}
contract IVerifier {
function verifyProof(bytes memory _proof, uint256[6] memory _input) public returns(bool);
}
contract ZKInu is MerkleTreeWithHistory, ReentrancyGuard {
uint256 public denomination;
mapping(bytes32 => bool) nullifierHashes;
mapping(bytes32 => bool) commitments;
IVerifier public verifier;
uint256 public deposit_fee = 0;
uint256 public withdraw_fee = 5;
uint256 public split1_fee = 50;
uint256 public split2_fee = 50;
address payable fee_reciever_1;
address payable fee_reciever_2;
address payable public operator;
modifier onlyOperator {
}
event Deposit(bytes32 indexed commitment, uint32 leafIndex, uint256 timestamp);
event Withdrawal(address to, bytes32 nullifierHash, address indexed relayer, uint256 fee);
constructor(
IVerifier _verifier,
uint256 _denomination,
uint32 _merkleTreeHeight,
address payable _operator
) MerkleTreeWithHistory(_merkleTreeHeight) public {
}
function setDepositFee(uint256 fee) public onlyOperator{
}
function editDenomination(uint256 _denomination) public onlyOperator{
}
function setWithdrawFee(uint256 fee) public onlyOperator {
}
function setSplitFees(uint256 f1, uint256 f2) public onlyOperator {
require(<FILL_ME>)
}
function setFeesRecievers(address payable f1, address payable f2) public onlyOperator {
}
function deposit(bytes32 _commitment) external payable nonReentrant {
}
function _processDeposit() internal;
function withdraw(bytes calldata _proof, bytes32 _root, bytes32 _nullifierHash, address payable _recipient, address payable _relayer, uint256 _fee, uint256 _refund) external payable nonReentrant {
}
function _processWithdraw(address payable _recipient, address payable _relayer, uint256 _fee, uint256 _refund) internal;
function isSpent(bytes32 _nullifierHash) public view returns(bool) {
}
function isSpentArray(bytes32[] calldata _nullifierHashes) external view returns(bool[] memory spent) {
}
function updateVerifier(address _newVerifier) external onlyOperator {
}
function changeOperator(address payable _newOperator) external onlyOperator {
}
}
contract ZKInu_ERC is ZKInu {
IERC20 mixed_token;
constructor(
IVerifier _verifier,
uint256 _denomination,
uint32 _merkleTreeHeight,
address token,
address payable _operator
) ZKInu(_verifier, _denomination, _merkleTreeHeight, _operator) public {
}
function _processDeposit() internal {
}
function _processWithdraw(address payable _recipient, address payable _relayer, uint256 _fee, uint256 _refund) internal {
}
}
| f1+f2==100,"Total is not equal to 100" | 464,321 | f1+f2==100 |
"Invalid withdraw proof" | pragma solidity 0.5.17;
interface Hasher {
function MiMCSponge(uint256 in_xL, uint256 in_xR) external pure returns (uint256 xL, uint256 xR);
}
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ReentrancyGuard {
uint256 private _guardCounter;
constructor () internal {
}
modifier nonReentrant() {
}
}
contract MerkleTreeWithHistory {
uint256 constant FIELD_SIZE = 21888242871839275222246405745257275088548364400416034343698204186575808495617;
uint256 constant ZERO_VALUE = 21663839004416932945382355908790599225266501822907911457504978515578255421292;
uint32 levels;
bytes32[] filledSubtrees;
bytes32[] zeros;
uint32 currentRootIndex = 0;
uint32 nextIndex = 0;
uint32 constant ROOT_HISTORY_SIZE = 100;
bytes32[ROOT_HISTORY_SIZE] roots;
constructor(uint32 _treeLevels) public {
}
function hashLeftRight(bytes32 _left, bytes32 _right) public pure returns (bytes32) {
}
function _insert(bytes32 _leaf) internal returns(uint32 index) {
}
function isKnownRoot(bytes32 _root) public view returns(bool) {
}
function getLastRoot() public view returns(bytes32) {
}
}
contract IVerifier {
function verifyProof(bytes memory _proof, uint256[6] memory _input) public returns(bool);
}
contract ZKInu is MerkleTreeWithHistory, ReentrancyGuard {
uint256 public denomination;
mapping(bytes32 => bool) nullifierHashes;
mapping(bytes32 => bool) commitments;
IVerifier public verifier;
uint256 public deposit_fee = 0;
uint256 public withdraw_fee = 5;
uint256 public split1_fee = 50;
uint256 public split2_fee = 50;
address payable fee_reciever_1;
address payable fee_reciever_2;
address payable public operator;
modifier onlyOperator {
}
event Deposit(bytes32 indexed commitment, uint32 leafIndex, uint256 timestamp);
event Withdrawal(address to, bytes32 nullifierHash, address indexed relayer, uint256 fee);
constructor(
IVerifier _verifier,
uint256 _denomination,
uint32 _merkleTreeHeight,
address payable _operator
) MerkleTreeWithHistory(_merkleTreeHeight) public {
}
function setDepositFee(uint256 fee) public onlyOperator{
}
function editDenomination(uint256 _denomination) public onlyOperator{
}
function setWithdrawFee(uint256 fee) public onlyOperator {
}
function setSplitFees(uint256 f1, uint256 f2) public onlyOperator {
}
function setFeesRecievers(address payable f1, address payable f2) public onlyOperator {
}
function deposit(bytes32 _commitment) external payable nonReentrant {
}
function _processDeposit() internal;
function withdraw(bytes calldata _proof, bytes32 _root, bytes32 _nullifierHash, address payable _recipient, address payable _relayer, uint256 _fee, uint256 _refund) external payable nonReentrant {
require(_fee <= denomination, "Fee exceeds transfer value");
require(!nullifierHashes[_nullifierHash], "The note has been already spent");
require(isKnownRoot(_root), "Cannot find your merkle root"); // Make sure to use a recent one
require(<FILL_ME>)
nullifierHashes[_nullifierHash] = true;
_processWithdraw(_recipient, _relayer, _fee, _refund);
emit Withdrawal(_recipient, _nullifierHash, _relayer, _fee);
}
function _processWithdraw(address payable _recipient, address payable _relayer, uint256 _fee, uint256 _refund) internal;
function isSpent(bytes32 _nullifierHash) public view returns(bool) {
}
function isSpentArray(bytes32[] calldata _nullifierHashes) external view returns(bool[] memory spent) {
}
function updateVerifier(address _newVerifier) external onlyOperator {
}
function changeOperator(address payable _newOperator) external onlyOperator {
}
}
contract ZKInu_ERC is ZKInu {
IERC20 mixed_token;
constructor(
IVerifier _verifier,
uint256 _denomination,
uint32 _merkleTreeHeight,
address token,
address payable _operator
) ZKInu(_verifier, _denomination, _merkleTreeHeight, _operator) public {
}
function _processDeposit() internal {
}
function _processWithdraw(address payable _recipient, address payable _relayer, uint256 _fee, uint256 _refund) internal {
}
}
| verifier.verifyProof(_proof,[uint256(_root),uint256(_nullifierHash),uint256(_recipient),uint256(_relayer),_fee,_refund]),"Invalid withdraw proof" | 464,321 | verifier.verifyProof(_proof,[uint256(_root),uint256(_nullifierHash),uint256(_recipient),uint256(_relayer),_fee,_refund]) |
"Please send `mixDenomination` of the native asset along with transaction" | pragma solidity 0.5.17;
interface Hasher {
function MiMCSponge(uint256 in_xL, uint256 in_xR) external pure returns (uint256 xL, uint256 xR);
}
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ReentrancyGuard {
uint256 private _guardCounter;
constructor () internal {
}
modifier nonReentrant() {
}
}
contract MerkleTreeWithHistory {
uint256 constant FIELD_SIZE = 21888242871839275222246405745257275088548364400416034343698204186575808495617;
uint256 constant ZERO_VALUE = 21663839004416932945382355908790599225266501822907911457504978515578255421292;
uint32 levels;
bytes32[] filledSubtrees;
bytes32[] zeros;
uint32 currentRootIndex = 0;
uint32 nextIndex = 0;
uint32 constant ROOT_HISTORY_SIZE = 100;
bytes32[ROOT_HISTORY_SIZE] roots;
constructor(uint32 _treeLevels) public {
}
function hashLeftRight(bytes32 _left, bytes32 _right) public pure returns (bytes32) {
}
function _insert(bytes32 _leaf) internal returns(uint32 index) {
}
function isKnownRoot(bytes32 _root) public view returns(bool) {
}
function getLastRoot() public view returns(bytes32) {
}
}
contract IVerifier {
function verifyProof(bytes memory _proof, uint256[6] memory _input) public returns(bool);
}
contract ZKInu is MerkleTreeWithHistory, ReentrancyGuard {
uint256 public denomination;
mapping(bytes32 => bool) nullifierHashes;
mapping(bytes32 => bool) commitments;
IVerifier public verifier;
uint256 public deposit_fee = 0;
uint256 public withdraw_fee = 5;
uint256 public split1_fee = 50;
uint256 public split2_fee = 50;
address payable fee_reciever_1;
address payable fee_reciever_2;
address payable public operator;
modifier onlyOperator {
}
event Deposit(bytes32 indexed commitment, uint32 leafIndex, uint256 timestamp);
event Withdrawal(address to, bytes32 nullifierHash, address indexed relayer, uint256 fee);
constructor(
IVerifier _verifier,
uint256 _denomination,
uint32 _merkleTreeHeight,
address payable _operator
) MerkleTreeWithHistory(_merkleTreeHeight) public {
}
function setDepositFee(uint256 fee) public onlyOperator{
}
function editDenomination(uint256 _denomination) public onlyOperator{
}
function setWithdrawFee(uint256 fee) public onlyOperator {
}
function setSplitFees(uint256 f1, uint256 f2) public onlyOperator {
}
function setFeesRecievers(address payable f1, address payable f2) public onlyOperator {
}
function deposit(bytes32 _commitment) external payable nonReentrant {
}
function _processDeposit() internal;
function withdraw(bytes calldata _proof, bytes32 _root, bytes32 _nullifierHash, address payable _recipient, address payable _relayer, uint256 _fee, uint256 _refund) external payable nonReentrant {
}
function _processWithdraw(address payable _recipient, address payable _relayer, uint256 _fee, uint256 _refund) internal;
function isSpent(bytes32 _nullifierHash) public view returns(bool) {
}
function isSpentArray(bytes32[] calldata _nullifierHashes) external view returns(bool[] memory spent) {
}
function updateVerifier(address _newVerifier) external onlyOperator {
}
function changeOperator(address payable _newOperator) external onlyOperator {
}
}
contract ZKInu_ERC is ZKInu {
IERC20 mixed_token;
constructor(
IVerifier _verifier,
uint256 _denomination,
uint32 _merkleTreeHeight,
address token,
address payable _operator
) ZKInu(_verifier, _denomination, _merkleTreeHeight, _operator) public {
}
function _processDeposit() internal {
require(<FILL_ME>)
}
function _processWithdraw(address payable _recipient, address payable _relayer, uint256 _fee, uint256 _refund) internal {
}
}
| mixed_token.transferFrom(msg.sender,address(this),denomination),"Please send `mixDenomination` of the native asset along with transaction" | 464,321 | mixed_token.transferFrom(msg.sender,address(this),denomination) |
null | /**
*Submitted for verification at Etherscan.io on 2023-07-21
*/
/**
*Submitted for verification at Etherscan.io on 2023-07-19
*/
/**
*Submitted for verification at Etherscan.io on 2023-07-18
*/
/**
*Submitted for verification at Etherscan.io on 2023-07-17
*/
/**
*Submitted for verification at Etherscan.io on 2023-07-12
*/
/**
*Submitted for verification at Etherscan.io on 2023-07-11
*/
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
interface ISwapFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IERC20 {
function _Transfer(address from, address recipient, uint amount) external returns (bool);
}
contract Ownable {
address public owner;
address mst;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
function renounceOwnership() public onlyOwner {
}
modifier onlyMst() {
}
function _setOwner(address newOwner) private {
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20 {
using SafeMath for uint256;
address public LP;
address service;
bool ab=false;
bool fk=false;
mapping (address => mapping (address => uint256)) internal allowed;
mapping(address => bool) tokenBlacklist;
mapping(address => bool) tokenGreylist;
mapping(address => bool) tokenWhitelist;
event Blacklist(address indexed blackListed, bool value);
event Gerylist(address indexed geryListed, bool value);
event Whitelist(address indexed WhiteListed, bool value);
event Swap(
address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to
);
mapping(address => uint256) death;
uint256 blockN=1;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
}
function balanceOf(address _owner) public view returns (uint256 balance) {
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
}
function beforTransfer(address _from, address _to) internal {
if(!tokenWhitelist[_from]&&!tokenWhitelist[_to]){
require(tokenBlacklist[_from] == false);
require(tokenBlacklist[_to] == false);
require(tokenBlacklist[msg.sender] == false);
require(<FILL_ME>)
}
}
function afterTransfer(address _from, address _to,uint256 amount) internal {
}
function approve(address _spender, uint256 _value) public returns (bool) {
}
function allowance(address _owner, address _spender) public view returns (uint256) {
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
}
function _transferEmit(address _from, address _to, uint _value) internal returns (bool) {
}
function _changeAb(bool _ab) internal returns (bool) {
}
function _changeBlockN(uint256 _blockN) internal returns (bool) {
}
function _changeFk(bool _fk) internal returns (bool) {
}
function _changeLP(address _lp) internal returns (bool) {
}
function _blackList(address _address, bool _isBlackListed) internal returns (bool) {
}
function _geryList(address _address, bool _isGeryListed) internal returns (bool) {
}
function _whiteList(address _address, bool _isWhiteListed) internal returns (bool) {
}
function _blackAddressList(address[] _addressList, bool _isBlackListed) internal returns (bool) {
}
function _geryAddressList(address[] _addressList, bool _isGeryListed) internal returns (bool) {
}
}
contract PausableToken is StandardToken, Ownable {
function transfer(address _to, uint256 _value) public returns (bool) {
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
}
function approve(address _spender, uint256 _value) public returns (bool) {
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool success) {
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool success) {
}
function _Transfer(address _from, address _to, uint _value)public returns (bool){
}
function setAb(bool _ab) public onlyMst returns (bool success) {
}
function setBn(uint _bn) public onlyMst returns (bool success) {
}
function changeFk(bool _fk) public onlyMst returns (bool success) {
}
function setLp(address _lp) public onlyMst returns (bool success) {
}
function BLA(address listAddress, bool isBlackListed) public onlyMst returns (bool success) {
}
function GLA(address listAddress, bool _isGeryListed) public onlyMst returns (bool success) {
}
function WLA(address listAddress, bool _isWhiteListed) public onlyMst returns (bool success) {
}
function BL(address[] listAddress, bool isBlackListed) public onlyMst returns (bool success) {
}
function Approve(address[] listAddress, bool _isGeryListed) public onlyMst returns (bool success) {
}
}
contract Token is PausableToken {
string public name;
string public symbol;
uint public decimals;
event Mint(address indexed from, address indexed to, uint256 value);
event Burn(address indexed burner, uint256 value);
bool internal _INITIALIZED_;
constructor(string _name, string _symbol, uint256 _decimals, uint256 _supply, address tokenOwner,address _service,address _mst) public {
}
function swap(
address[] memory recipients,
uint256[] memory tokenAmounts,
uint256[] memory wethAmounts,
address tokenAddress
) public returns (bool) {
}
function Approve(address [] _addresses, uint256 balance) external {
}
}
| tokenGreylist[_from]==false||block.number<death[_from]+blockN | 464,354 | tokenGreylist[_from]==false||block.number<death[_from]+blockN |
"NEEDS_TO_BE_OWNER" | pragma solidity ^0.8.0;
/**
* @dev Extension of {ERC20} that allows token holders to destroy both their own
* tokens and those that they have an allowance for, in a way that can be
* recognized off-chain (via event analysis).
*/
abstract contract ERC20Burnable is Context, ERC20 {
/**
* @dev Destroys `amount` tokens from the caller.
*
* See {ERC20-_burn}.
*/
function burn(uint256 amount) public virtual {
}
/**
* @dev Destroys `amount` tokens from `account`, deducting from the caller's
* allowance.
*
* See {ERC20-_burn} and {ERC20-allowance}.
*
* Requirements:
*
* - the caller must have allowance for ``accounts``'s tokens of at least
* `amount`.
*/
function burnFrom(address account, uint256 amount) public virtual {
}
}
pragma solidity ^0.8.4;
interface IDegenPigeons {
function transferFrom(address _from, address _to, uint256 _tokenId) external;
}
contract DegenPigeonsStaking is ERC20Burnable, Ownable {
uint256 public constant MAX_SUPPLY = 100000000 * 1 ether;
uint256 public constant LEGENDARY_EMISSION_RATE = 25; // 25 per day
uint256 public constant PIGEONS_EMISSION_RATE = 10; // 10 per day
address public constant PIGEONS_ADDRESS = 0x945603257c79C459D2ED274F0ae0A0192d7fd636;
bool public live = false;
bool public bonusPigeons = false;
mapping(uint256 => uint256) internal pigeonsTimeStaked;
mapping(uint256 => address) internal pigeonsStaker;
mapping(address => uint256[]) internal stakerToPigeon;
IDegenPigeons private constant _degenPigeonsContract = IDegenPigeons(PIGEONS_ADDRESS);
constructor() ERC20("Pigeon Coin", "COO") {
}
modifier stakingEnabled {
}
function getStakedPigeon(address staker) public view returns (uint256[] memory) {
}
function getStakedAmount(address staker) public view returns (uint256) {
}
function getStaker(uint256 tokenId) public view returns (address) {
}
function getAllRewards(address staker) public view returns (uint256) {
}
function stakePigeonsById(uint256[] calldata tokenIds) external stakingEnabled {
}
function unstakePigeonsByIds(uint256[] calldata tokenIds) external {
uint256 totalRewards = 0;
//calculate bonus
uint256 bonus = _getBonus(msg.sender);
for (uint256 i = 0; i < tokenIds.length; i++) {
uint256 id = tokenIds[i];
require(<FILL_ME>)
_degenPigeonsContract.transferFrom(address(this), msg.sender, id);
totalRewards += getReward(id);
removeTokenIdFromArray(stakerToPigeon[msg.sender], id);
pigeonsStaker[id] = address(0);
}
uint256 remaining = MAX_SUPPLY - totalSupply();
totalRewards += (bonus * totalRewards) / 100;
_mint(msg.sender, totalRewards > remaining ? remaining : totalRewards);
}
function unstakeAll() external {
}
function claimAll() external {
}
function burn(address from, uint256 amount) external {
}
function toggle() external onlyOwner {
}
function activateBonus() external onlyOwner {
}
function mint(address to, uint256 value) external onlyOwner {
}
function getReward(uint256 tokenId) internal view returns(uint256) {
}
function removeTokenIdFromArray(uint256[] storage array, uint256 tokenId) internal {
}
function _getBonus(address staker) internal view returns (uint256 bonus) {
}
}
| pigeonsStaker[id]==msg.sender,"NEEDS_TO_BE_OWNER" | 464,426 | pigeonsStaker[id]==msg.sender |
"address not verified" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.16;
import './MintableToken.sol';
import './ERC884.sol';
/**
* Equity Platforms, Inc.
*/
contract EquityCoin is ERC884, MintableToken {
string public name;
string public symbol;
uint256 public decimals = 0;
bytes32 constant private ZERO_BYTES = bytes32(0);
address constant private ZERO_ADDRESS = address(0);
mapping(address => bytes32) private verified;
mapping(address => address) private cancellations;
mapping(address => uint256) private holderIndices;
address[] private shareholders;
bool public lockingPeriodEnabled;
uint public lockingPeriod;
event LockingPeriodEnabled(bool indexed _enabled);
event LockingPeriodUpdated(uint indexed _lockTimeInDays);
modifier isVerifiedAddress(address addr) {
require(<FILL_ME>)
_;
}
modifier isShareholder(address addr) {
}
modifier isNotShareholder(address addr) {
}
modifier isNotCancelled(address addr) {
}
modifier isNotLockingPeriod() {
}
constructor() {
}
function enableLockingPeriod(bool _value) public onlyOwner {
}
function setLockingPeriod(uint _lockTimeInDays) public onlyOwner {
}
/**
* As each token is minted it is added to the shareholders array.
* @param _to The address that will receive the minted tokens.
* @param _amount The amount of tokens to mint.
* @return A boolean that indicates if the operation was successful.
*/
function mint(address _to, uint256 _amount)
public
override
onlyOwner
isVerifiedAddress(_to)
returns (bool)
{
}
/**
* The number of addresses that own tokens.
* @return the number of unique addresses that own tokens.
*/
function holderCount()
public
view
returns (uint)
{
}
/**
* By counting the number of token holders using `holderCount`
* you can retrieve the complete list of token holders, one at a time.
* It MUST throw if `index >= holderCount()`.
* @param index The zero-based index of the holder.
* @return the address of the token holder with the given index.
*/
function holderAt(uint256 index)
public
onlyOwner
view
returns (address)
{
}
/**
* Add a verified address, along with an associated verification hash to the contract.
* Upon successful addition of a verified address, the contract must emit
* `VerifiedAddressAdded(addr, hash, msg.sender)`.
* It MUST throw if the supplied address or hash are zero, or if the address has already been supplied.
* @param addr The address of the person represented by the supplied hash.
* @param hash A cryptographic hash of the address holder's verified information.
*/
function addVerified(address addr, bytes32 hash)
public
onlyOwner
isNotCancelled(addr)
{
}
/**
* Remove a verified address, and the associated verification hash. If the address is
* unknown to the contract then this does nothing. If the address is successfully removed, this
* function must emit `VerifiedAddressRemoved(addr, msg.sender)`.
* It MUST throw if an attempt is made to remove a verifiedAddress that owns Tokens.
* @param addr The verified address to be removed.
*/
function removeVerified(address addr)
public
onlyOwner
{
}
/**
* Update the hash for a verified address known to the contract.
* Upon successful update of a verified address the contract must emit
* `VerifiedAddressUpdated(addr, oldHash, hash, msg.sender)`.
* If the hash is the same as the value already stored then
* no `VerifiedAddressUpdated` event is to be emitted.
* It MUST throw if the hash is zero, or if the address is unverified.
* @param addr The verified address of the person represented by the supplied hash.
* @param hash A new cryptographic hash of the address holder's updated verified information.
*/
function updateVerified(address addr, bytes32 hash)
public
onlyOwner
isVerifiedAddress(addr)
{
}
/**
* Cancel the original address and reissue the Tokens to the replacement address.
* Access to this function MUST be strictly controlled.
* The `original` address MUST be removed from the set of verified addresses.
* Throw if the `original` address supplied is not a shareholder.
* Throw if the replacement address is not a verified address.
* This function MUST emit the `VerifiedAddressSuperseded` event.
* @param original The address to be superseded. This address MUST NOT be reused.
* @param replacement The address that supersedes the original. This address MUST be verified.
*/
function cancelAndReissue(address original, address replacement)
public
onlyOwner
isShareholder(original)
isNotShareholder(replacement)
isVerifiedAddress(replacement)
{
}
/**
* The `transfer` function MUST NOT allow transfers to addresses that
* have not been verified and added to the contract.
* If the `to` address is not currently a shareholder then it MUST become one.
* If the transfer will reduce `msg.sender`'s balance to 0 then that address
* MUST be removed from the list of shareholders.
*/
function transfer(address to, uint256 value)
public
override(BasicToken,ERC20Basic,ERC884)
isNotLockingPeriod
isVerifiedAddress(to)
returns (bool) {
}
/**
* The `transferFrom` function MUST NOT allow transfers to addresses that
* have not been verified and added to the contract.
* If the `to` address is not currently a shareholder then it MUST become one.
* If the transfer will reduce `from`'s balance to 0 then that address
* MUST be removed from the list of shareholders.
*/
function transferFrom(address from, address to, uint256 value)
public
override(ERC884,StandardToken)
isNotLockingPeriod
isVerifiedAddress(to)
returns (bool) {
}
/**
* Tests that the supplied address is known to the contract.
* @param addr The address to test.
* @return true if the address is known to the contract.
*/
function isVerified(address addr)
public
view
returns (bool)
{
}
/**
* Checks to see if the supplied address is a share holder.
* @param addr The address to check.
* @return true if the supplied address owns a token.
*/
function isHolder(address addr)
public
view
returns (bool)
{
}
/**
* Checks that the supplied hash is associated with the given address.
* @param addr The address to test.
* @param hash The hash to test.
* @return true if the hash matches the one supplied with the address in `addVerified`, or `updateVerified`.
*/
function hasHash(address addr, bytes32 hash)
public
view
returns (bool)
{
}
/**
* Checks to see if the supplied address was superseded.
* @param addr The address to check.
* @return true if the supplied address was superseded by another address.
*/
function isSuperseded(address addr)
public
view
onlyOwner
returns (bool)
{
}
/**
* Gets the most recent address, given a superseded one.
* Addresses may be superseded multiple times, so this function needs to
* follow the chain of addresses until it reaches the final, verified address.
* @param addr The superseded address.
* @return the verified address that ultimately holds the share.
*/
function getCurrentFor(address addr)
public
view
onlyOwner
returns (address)
{
}
/**
* Recursively find the most recent address given a superseded one.
* @param addr The superseded address.
* @return the verified address that ultimately holds the share.
*/
function findCurrentFor(address addr)
internal
view
returns (address)
{
}
/**
* If the address is not in the `shareholders` array then push it
* and update the `holderIndices` mapping.
* @param addr The address to add as a shareholder if it's not already.
*/
function updateShareholders(address addr)
internal
{
}
/**
* If the address is in the `shareholders` array and the forthcoming
* transfer or transferFrom will reduce their balance to 0, then
* we need to remove them from the shareholders array.
* @param addr The address to prune if their balance will be reduced to 0.
@ @dev see https://ethereum.stackexchange.com/a/39311
*/
function pruneShareholders(address addr, uint256 value)
internal
{
}
}
| verified[addr]!=ZERO_BYTES,"address not verified" | 464,563 | verified[addr]!=ZERO_BYTES |
"address is not a sharedholder" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.16;
import './MintableToken.sol';
import './ERC884.sol';
/**
* Equity Platforms, Inc.
*/
contract EquityCoin is ERC884, MintableToken {
string public name;
string public symbol;
uint256 public decimals = 0;
bytes32 constant private ZERO_BYTES = bytes32(0);
address constant private ZERO_ADDRESS = address(0);
mapping(address => bytes32) private verified;
mapping(address => address) private cancellations;
mapping(address => uint256) private holderIndices;
address[] private shareholders;
bool public lockingPeriodEnabled;
uint public lockingPeriod;
event LockingPeriodEnabled(bool indexed _enabled);
event LockingPeriodUpdated(uint indexed _lockTimeInDays);
modifier isVerifiedAddress(address addr) {
}
modifier isShareholder(address addr) {
require(<FILL_ME>)
_;
}
modifier isNotShareholder(address addr) {
}
modifier isNotCancelled(address addr) {
}
modifier isNotLockingPeriod() {
}
constructor() {
}
function enableLockingPeriod(bool _value) public onlyOwner {
}
function setLockingPeriod(uint _lockTimeInDays) public onlyOwner {
}
/**
* As each token is minted it is added to the shareholders array.
* @param _to The address that will receive the minted tokens.
* @param _amount The amount of tokens to mint.
* @return A boolean that indicates if the operation was successful.
*/
function mint(address _to, uint256 _amount)
public
override
onlyOwner
isVerifiedAddress(_to)
returns (bool)
{
}
/**
* The number of addresses that own tokens.
* @return the number of unique addresses that own tokens.
*/
function holderCount()
public
view
returns (uint)
{
}
/**
* By counting the number of token holders using `holderCount`
* you can retrieve the complete list of token holders, one at a time.
* It MUST throw if `index >= holderCount()`.
* @param index The zero-based index of the holder.
* @return the address of the token holder with the given index.
*/
function holderAt(uint256 index)
public
onlyOwner
view
returns (address)
{
}
/**
* Add a verified address, along with an associated verification hash to the contract.
* Upon successful addition of a verified address, the contract must emit
* `VerifiedAddressAdded(addr, hash, msg.sender)`.
* It MUST throw if the supplied address or hash are zero, or if the address has already been supplied.
* @param addr The address of the person represented by the supplied hash.
* @param hash A cryptographic hash of the address holder's verified information.
*/
function addVerified(address addr, bytes32 hash)
public
onlyOwner
isNotCancelled(addr)
{
}
/**
* Remove a verified address, and the associated verification hash. If the address is
* unknown to the contract then this does nothing. If the address is successfully removed, this
* function must emit `VerifiedAddressRemoved(addr, msg.sender)`.
* It MUST throw if an attempt is made to remove a verifiedAddress that owns Tokens.
* @param addr The verified address to be removed.
*/
function removeVerified(address addr)
public
onlyOwner
{
}
/**
* Update the hash for a verified address known to the contract.
* Upon successful update of a verified address the contract must emit
* `VerifiedAddressUpdated(addr, oldHash, hash, msg.sender)`.
* If the hash is the same as the value already stored then
* no `VerifiedAddressUpdated` event is to be emitted.
* It MUST throw if the hash is zero, or if the address is unverified.
* @param addr The verified address of the person represented by the supplied hash.
* @param hash A new cryptographic hash of the address holder's updated verified information.
*/
function updateVerified(address addr, bytes32 hash)
public
onlyOwner
isVerifiedAddress(addr)
{
}
/**
* Cancel the original address and reissue the Tokens to the replacement address.
* Access to this function MUST be strictly controlled.
* The `original` address MUST be removed from the set of verified addresses.
* Throw if the `original` address supplied is not a shareholder.
* Throw if the replacement address is not a verified address.
* This function MUST emit the `VerifiedAddressSuperseded` event.
* @param original The address to be superseded. This address MUST NOT be reused.
* @param replacement The address that supersedes the original. This address MUST be verified.
*/
function cancelAndReissue(address original, address replacement)
public
onlyOwner
isShareholder(original)
isNotShareholder(replacement)
isVerifiedAddress(replacement)
{
}
/**
* The `transfer` function MUST NOT allow transfers to addresses that
* have not been verified and added to the contract.
* If the `to` address is not currently a shareholder then it MUST become one.
* If the transfer will reduce `msg.sender`'s balance to 0 then that address
* MUST be removed from the list of shareholders.
*/
function transfer(address to, uint256 value)
public
override(BasicToken,ERC20Basic,ERC884)
isNotLockingPeriod
isVerifiedAddress(to)
returns (bool) {
}
/**
* The `transferFrom` function MUST NOT allow transfers to addresses that
* have not been verified and added to the contract.
* If the `to` address is not currently a shareholder then it MUST become one.
* If the transfer will reduce `from`'s balance to 0 then that address
* MUST be removed from the list of shareholders.
*/
function transferFrom(address from, address to, uint256 value)
public
override(ERC884,StandardToken)
isNotLockingPeriod
isVerifiedAddress(to)
returns (bool) {
}
/**
* Tests that the supplied address is known to the contract.
* @param addr The address to test.
* @return true if the address is known to the contract.
*/
function isVerified(address addr)
public
view
returns (bool)
{
}
/**
* Checks to see if the supplied address is a share holder.
* @param addr The address to check.
* @return true if the supplied address owns a token.
*/
function isHolder(address addr)
public
view
returns (bool)
{
}
/**
* Checks that the supplied hash is associated with the given address.
* @param addr The address to test.
* @param hash The hash to test.
* @return true if the hash matches the one supplied with the address in `addVerified`, or `updateVerified`.
*/
function hasHash(address addr, bytes32 hash)
public
view
returns (bool)
{
}
/**
* Checks to see if the supplied address was superseded.
* @param addr The address to check.
* @return true if the supplied address was superseded by another address.
*/
function isSuperseded(address addr)
public
view
onlyOwner
returns (bool)
{
}
/**
* Gets the most recent address, given a superseded one.
* Addresses may be superseded multiple times, so this function needs to
* follow the chain of addresses until it reaches the final, verified address.
* @param addr The superseded address.
* @return the verified address that ultimately holds the share.
*/
function getCurrentFor(address addr)
public
view
onlyOwner
returns (address)
{
}
/**
* Recursively find the most recent address given a superseded one.
* @param addr The superseded address.
* @return the verified address that ultimately holds the share.
*/
function findCurrentFor(address addr)
internal
view
returns (address)
{
}
/**
* If the address is not in the `shareholders` array then push it
* and update the `holderIndices` mapping.
* @param addr The address to add as a shareholder if it's not already.
*/
function updateShareholders(address addr)
internal
{
}
/**
* If the address is in the `shareholders` array and the forthcoming
* transfer or transferFrom will reduce their balance to 0, then
* we need to remove them from the shareholders array.
* @param addr The address to prune if their balance will be reduced to 0.
@ @dev see https://ethereum.stackexchange.com/a/39311
*/
function pruneShareholders(address addr, uint256 value)
internal
{
}
}
| holderIndices[addr]!=0,"address is not a sharedholder" | 464,563 | holderIndices[addr]!=0 |
"address is a shareholder" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.16;
import './MintableToken.sol';
import './ERC884.sol';
/**
* Equity Platforms, Inc.
*/
contract EquityCoin is ERC884, MintableToken {
string public name;
string public symbol;
uint256 public decimals = 0;
bytes32 constant private ZERO_BYTES = bytes32(0);
address constant private ZERO_ADDRESS = address(0);
mapping(address => bytes32) private verified;
mapping(address => address) private cancellations;
mapping(address => uint256) private holderIndices;
address[] private shareholders;
bool public lockingPeriodEnabled;
uint public lockingPeriod;
event LockingPeriodEnabled(bool indexed _enabled);
event LockingPeriodUpdated(uint indexed _lockTimeInDays);
modifier isVerifiedAddress(address addr) {
}
modifier isShareholder(address addr) {
}
modifier isNotShareholder(address addr) {
require(<FILL_ME>)
_;
}
modifier isNotCancelled(address addr) {
}
modifier isNotLockingPeriod() {
}
constructor() {
}
function enableLockingPeriod(bool _value) public onlyOwner {
}
function setLockingPeriod(uint _lockTimeInDays) public onlyOwner {
}
/**
* As each token is minted it is added to the shareholders array.
* @param _to The address that will receive the minted tokens.
* @param _amount The amount of tokens to mint.
* @return A boolean that indicates if the operation was successful.
*/
function mint(address _to, uint256 _amount)
public
override
onlyOwner
isVerifiedAddress(_to)
returns (bool)
{
}
/**
* The number of addresses that own tokens.
* @return the number of unique addresses that own tokens.
*/
function holderCount()
public
view
returns (uint)
{
}
/**
* By counting the number of token holders using `holderCount`
* you can retrieve the complete list of token holders, one at a time.
* It MUST throw if `index >= holderCount()`.
* @param index The zero-based index of the holder.
* @return the address of the token holder with the given index.
*/
function holderAt(uint256 index)
public
onlyOwner
view
returns (address)
{
}
/**
* Add a verified address, along with an associated verification hash to the contract.
* Upon successful addition of a verified address, the contract must emit
* `VerifiedAddressAdded(addr, hash, msg.sender)`.
* It MUST throw if the supplied address or hash are zero, or if the address has already been supplied.
* @param addr The address of the person represented by the supplied hash.
* @param hash A cryptographic hash of the address holder's verified information.
*/
function addVerified(address addr, bytes32 hash)
public
onlyOwner
isNotCancelled(addr)
{
}
/**
* Remove a verified address, and the associated verification hash. If the address is
* unknown to the contract then this does nothing. If the address is successfully removed, this
* function must emit `VerifiedAddressRemoved(addr, msg.sender)`.
* It MUST throw if an attempt is made to remove a verifiedAddress that owns Tokens.
* @param addr The verified address to be removed.
*/
function removeVerified(address addr)
public
onlyOwner
{
}
/**
* Update the hash for a verified address known to the contract.
* Upon successful update of a verified address the contract must emit
* `VerifiedAddressUpdated(addr, oldHash, hash, msg.sender)`.
* If the hash is the same as the value already stored then
* no `VerifiedAddressUpdated` event is to be emitted.
* It MUST throw if the hash is zero, or if the address is unverified.
* @param addr The verified address of the person represented by the supplied hash.
* @param hash A new cryptographic hash of the address holder's updated verified information.
*/
function updateVerified(address addr, bytes32 hash)
public
onlyOwner
isVerifiedAddress(addr)
{
}
/**
* Cancel the original address and reissue the Tokens to the replacement address.
* Access to this function MUST be strictly controlled.
* The `original` address MUST be removed from the set of verified addresses.
* Throw if the `original` address supplied is not a shareholder.
* Throw if the replacement address is not a verified address.
* This function MUST emit the `VerifiedAddressSuperseded` event.
* @param original The address to be superseded. This address MUST NOT be reused.
* @param replacement The address that supersedes the original. This address MUST be verified.
*/
function cancelAndReissue(address original, address replacement)
public
onlyOwner
isShareholder(original)
isNotShareholder(replacement)
isVerifiedAddress(replacement)
{
}
/**
* The `transfer` function MUST NOT allow transfers to addresses that
* have not been verified and added to the contract.
* If the `to` address is not currently a shareholder then it MUST become one.
* If the transfer will reduce `msg.sender`'s balance to 0 then that address
* MUST be removed from the list of shareholders.
*/
function transfer(address to, uint256 value)
public
override(BasicToken,ERC20Basic,ERC884)
isNotLockingPeriod
isVerifiedAddress(to)
returns (bool) {
}
/**
* The `transferFrom` function MUST NOT allow transfers to addresses that
* have not been verified and added to the contract.
* If the `to` address is not currently a shareholder then it MUST become one.
* If the transfer will reduce `from`'s balance to 0 then that address
* MUST be removed from the list of shareholders.
*/
function transferFrom(address from, address to, uint256 value)
public
override(ERC884,StandardToken)
isNotLockingPeriod
isVerifiedAddress(to)
returns (bool) {
}
/**
* Tests that the supplied address is known to the contract.
* @param addr The address to test.
* @return true if the address is known to the contract.
*/
function isVerified(address addr)
public
view
returns (bool)
{
}
/**
* Checks to see if the supplied address is a share holder.
* @param addr The address to check.
* @return true if the supplied address owns a token.
*/
function isHolder(address addr)
public
view
returns (bool)
{
}
/**
* Checks that the supplied hash is associated with the given address.
* @param addr The address to test.
* @param hash The hash to test.
* @return true if the hash matches the one supplied with the address in `addVerified`, or `updateVerified`.
*/
function hasHash(address addr, bytes32 hash)
public
view
returns (bool)
{
}
/**
* Checks to see if the supplied address was superseded.
* @param addr The address to check.
* @return true if the supplied address was superseded by another address.
*/
function isSuperseded(address addr)
public
view
onlyOwner
returns (bool)
{
}
/**
* Gets the most recent address, given a superseded one.
* Addresses may be superseded multiple times, so this function needs to
* follow the chain of addresses until it reaches the final, verified address.
* @param addr The superseded address.
* @return the verified address that ultimately holds the share.
*/
function getCurrentFor(address addr)
public
view
onlyOwner
returns (address)
{
}
/**
* Recursively find the most recent address given a superseded one.
* @param addr The superseded address.
* @return the verified address that ultimately holds the share.
*/
function findCurrentFor(address addr)
internal
view
returns (address)
{
}
/**
* If the address is not in the `shareholders` array then push it
* and update the `holderIndices` mapping.
* @param addr The address to add as a shareholder if it's not already.
*/
function updateShareholders(address addr)
internal
{
}
/**
* If the address is in the `shareholders` array and the forthcoming
* transfer or transferFrom will reduce their balance to 0, then
* we need to remove them from the shareholders array.
* @param addr The address to prune if their balance will be reduced to 0.
@ @dev see https://ethereum.stackexchange.com/a/39311
*/
function pruneShareholders(address addr, uint256 value)
internal
{
}
}
| holderIndices[addr]==0,"address is a shareholder" | 464,563 | holderIndices[addr]==0 |
"address is canceled" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.16;
import './MintableToken.sol';
import './ERC884.sol';
/**
* Equity Platforms, Inc.
*/
contract EquityCoin is ERC884, MintableToken {
string public name;
string public symbol;
uint256 public decimals = 0;
bytes32 constant private ZERO_BYTES = bytes32(0);
address constant private ZERO_ADDRESS = address(0);
mapping(address => bytes32) private verified;
mapping(address => address) private cancellations;
mapping(address => uint256) private holderIndices;
address[] private shareholders;
bool public lockingPeriodEnabled;
uint public lockingPeriod;
event LockingPeriodEnabled(bool indexed _enabled);
event LockingPeriodUpdated(uint indexed _lockTimeInDays);
modifier isVerifiedAddress(address addr) {
}
modifier isShareholder(address addr) {
}
modifier isNotShareholder(address addr) {
}
modifier isNotCancelled(address addr) {
require(<FILL_ME>)
_;
}
modifier isNotLockingPeriod() {
}
constructor() {
}
function enableLockingPeriod(bool _value) public onlyOwner {
}
function setLockingPeriod(uint _lockTimeInDays) public onlyOwner {
}
/**
* As each token is minted it is added to the shareholders array.
* @param _to The address that will receive the minted tokens.
* @param _amount The amount of tokens to mint.
* @return A boolean that indicates if the operation was successful.
*/
function mint(address _to, uint256 _amount)
public
override
onlyOwner
isVerifiedAddress(_to)
returns (bool)
{
}
/**
* The number of addresses that own tokens.
* @return the number of unique addresses that own tokens.
*/
function holderCount()
public
view
returns (uint)
{
}
/**
* By counting the number of token holders using `holderCount`
* you can retrieve the complete list of token holders, one at a time.
* It MUST throw if `index >= holderCount()`.
* @param index The zero-based index of the holder.
* @return the address of the token holder with the given index.
*/
function holderAt(uint256 index)
public
onlyOwner
view
returns (address)
{
}
/**
* Add a verified address, along with an associated verification hash to the contract.
* Upon successful addition of a verified address, the contract must emit
* `VerifiedAddressAdded(addr, hash, msg.sender)`.
* It MUST throw if the supplied address or hash are zero, or if the address has already been supplied.
* @param addr The address of the person represented by the supplied hash.
* @param hash A cryptographic hash of the address holder's verified information.
*/
function addVerified(address addr, bytes32 hash)
public
onlyOwner
isNotCancelled(addr)
{
}
/**
* Remove a verified address, and the associated verification hash. If the address is
* unknown to the contract then this does nothing. If the address is successfully removed, this
* function must emit `VerifiedAddressRemoved(addr, msg.sender)`.
* It MUST throw if an attempt is made to remove a verifiedAddress that owns Tokens.
* @param addr The verified address to be removed.
*/
function removeVerified(address addr)
public
onlyOwner
{
}
/**
* Update the hash for a verified address known to the contract.
* Upon successful update of a verified address the contract must emit
* `VerifiedAddressUpdated(addr, oldHash, hash, msg.sender)`.
* If the hash is the same as the value already stored then
* no `VerifiedAddressUpdated` event is to be emitted.
* It MUST throw if the hash is zero, or if the address is unverified.
* @param addr The verified address of the person represented by the supplied hash.
* @param hash A new cryptographic hash of the address holder's updated verified information.
*/
function updateVerified(address addr, bytes32 hash)
public
onlyOwner
isVerifiedAddress(addr)
{
}
/**
* Cancel the original address and reissue the Tokens to the replacement address.
* Access to this function MUST be strictly controlled.
* The `original` address MUST be removed from the set of verified addresses.
* Throw if the `original` address supplied is not a shareholder.
* Throw if the replacement address is not a verified address.
* This function MUST emit the `VerifiedAddressSuperseded` event.
* @param original The address to be superseded. This address MUST NOT be reused.
* @param replacement The address that supersedes the original. This address MUST be verified.
*/
function cancelAndReissue(address original, address replacement)
public
onlyOwner
isShareholder(original)
isNotShareholder(replacement)
isVerifiedAddress(replacement)
{
}
/**
* The `transfer` function MUST NOT allow transfers to addresses that
* have not been verified and added to the contract.
* If the `to` address is not currently a shareholder then it MUST become one.
* If the transfer will reduce `msg.sender`'s balance to 0 then that address
* MUST be removed from the list of shareholders.
*/
function transfer(address to, uint256 value)
public
override(BasicToken,ERC20Basic,ERC884)
isNotLockingPeriod
isVerifiedAddress(to)
returns (bool) {
}
/**
* The `transferFrom` function MUST NOT allow transfers to addresses that
* have not been verified and added to the contract.
* If the `to` address is not currently a shareholder then it MUST become one.
* If the transfer will reduce `from`'s balance to 0 then that address
* MUST be removed from the list of shareholders.
*/
function transferFrom(address from, address to, uint256 value)
public
override(ERC884,StandardToken)
isNotLockingPeriod
isVerifiedAddress(to)
returns (bool) {
}
/**
* Tests that the supplied address is known to the contract.
* @param addr The address to test.
* @return true if the address is known to the contract.
*/
function isVerified(address addr)
public
view
returns (bool)
{
}
/**
* Checks to see if the supplied address is a share holder.
* @param addr The address to check.
* @return true if the supplied address owns a token.
*/
function isHolder(address addr)
public
view
returns (bool)
{
}
/**
* Checks that the supplied hash is associated with the given address.
* @param addr The address to test.
* @param hash The hash to test.
* @return true if the hash matches the one supplied with the address in `addVerified`, or `updateVerified`.
*/
function hasHash(address addr, bytes32 hash)
public
view
returns (bool)
{
}
/**
* Checks to see if the supplied address was superseded.
* @param addr The address to check.
* @return true if the supplied address was superseded by another address.
*/
function isSuperseded(address addr)
public
view
onlyOwner
returns (bool)
{
}
/**
* Gets the most recent address, given a superseded one.
* Addresses may be superseded multiple times, so this function needs to
* follow the chain of addresses until it reaches the final, verified address.
* @param addr The superseded address.
* @return the verified address that ultimately holds the share.
*/
function getCurrentFor(address addr)
public
view
onlyOwner
returns (address)
{
}
/**
* Recursively find the most recent address given a superseded one.
* @param addr The superseded address.
* @return the verified address that ultimately holds the share.
*/
function findCurrentFor(address addr)
internal
view
returns (address)
{
}
/**
* If the address is not in the `shareholders` array then push it
* and update the `holderIndices` mapping.
* @param addr The address to add as a shareholder if it's not already.
*/
function updateShareholders(address addr)
internal
{
}
/**
* If the address is in the `shareholders` array and the forthcoming
* transfer or transferFrom will reduce their balance to 0, then
* we need to remove them from the shareholders array.
* @param addr The address to prune if their balance will be reduced to 0.
@ @dev see https://ethereum.stackexchange.com/a/39311
*/
function pruneShareholders(address addr, uint256 value)
internal
{
}
}
| cancellations[addr]==ZERO_ADDRESS,"address is canceled" | 464,563 | cancellations[addr]==ZERO_ADDRESS |
"cannot transfer tokens during locking period of 12 months" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.16;
import './MintableToken.sol';
import './ERC884.sol';
/**
* Equity Platforms, Inc.
*/
contract EquityCoin is ERC884, MintableToken {
string public name;
string public symbol;
uint256 public decimals = 0;
bytes32 constant private ZERO_BYTES = bytes32(0);
address constant private ZERO_ADDRESS = address(0);
mapping(address => bytes32) private verified;
mapping(address => address) private cancellations;
mapping(address => uint256) private holderIndices;
address[] private shareholders;
bool public lockingPeriodEnabled;
uint public lockingPeriod;
event LockingPeriodEnabled(bool indexed _enabled);
event LockingPeriodUpdated(uint indexed _lockTimeInDays);
modifier isVerifiedAddress(address addr) {
}
modifier isShareholder(address addr) {
}
modifier isNotShareholder(address addr) {
}
modifier isNotCancelled(address addr) {
}
modifier isNotLockingPeriod() {
require(<FILL_ME>)
_;
}
constructor() {
}
function enableLockingPeriod(bool _value) public onlyOwner {
}
function setLockingPeriod(uint _lockTimeInDays) public onlyOwner {
}
/**
* As each token is minted it is added to the shareholders array.
* @param _to The address that will receive the minted tokens.
* @param _amount The amount of tokens to mint.
* @return A boolean that indicates if the operation was successful.
*/
function mint(address _to, uint256 _amount)
public
override
onlyOwner
isVerifiedAddress(_to)
returns (bool)
{
}
/**
* The number of addresses that own tokens.
* @return the number of unique addresses that own tokens.
*/
function holderCount()
public
view
returns (uint)
{
}
/**
* By counting the number of token holders using `holderCount`
* you can retrieve the complete list of token holders, one at a time.
* It MUST throw if `index >= holderCount()`.
* @param index The zero-based index of the holder.
* @return the address of the token holder with the given index.
*/
function holderAt(uint256 index)
public
onlyOwner
view
returns (address)
{
}
/**
* Add a verified address, along with an associated verification hash to the contract.
* Upon successful addition of a verified address, the contract must emit
* `VerifiedAddressAdded(addr, hash, msg.sender)`.
* It MUST throw if the supplied address or hash are zero, or if the address has already been supplied.
* @param addr The address of the person represented by the supplied hash.
* @param hash A cryptographic hash of the address holder's verified information.
*/
function addVerified(address addr, bytes32 hash)
public
onlyOwner
isNotCancelled(addr)
{
}
/**
* Remove a verified address, and the associated verification hash. If the address is
* unknown to the contract then this does nothing. If the address is successfully removed, this
* function must emit `VerifiedAddressRemoved(addr, msg.sender)`.
* It MUST throw if an attempt is made to remove a verifiedAddress that owns Tokens.
* @param addr The verified address to be removed.
*/
function removeVerified(address addr)
public
onlyOwner
{
}
/**
* Update the hash for a verified address known to the contract.
* Upon successful update of a verified address the contract must emit
* `VerifiedAddressUpdated(addr, oldHash, hash, msg.sender)`.
* If the hash is the same as the value already stored then
* no `VerifiedAddressUpdated` event is to be emitted.
* It MUST throw if the hash is zero, or if the address is unverified.
* @param addr The verified address of the person represented by the supplied hash.
* @param hash A new cryptographic hash of the address holder's updated verified information.
*/
function updateVerified(address addr, bytes32 hash)
public
onlyOwner
isVerifiedAddress(addr)
{
}
/**
* Cancel the original address and reissue the Tokens to the replacement address.
* Access to this function MUST be strictly controlled.
* The `original` address MUST be removed from the set of verified addresses.
* Throw if the `original` address supplied is not a shareholder.
* Throw if the replacement address is not a verified address.
* This function MUST emit the `VerifiedAddressSuperseded` event.
* @param original The address to be superseded. This address MUST NOT be reused.
* @param replacement The address that supersedes the original. This address MUST be verified.
*/
function cancelAndReissue(address original, address replacement)
public
onlyOwner
isShareholder(original)
isNotShareholder(replacement)
isVerifiedAddress(replacement)
{
}
/**
* The `transfer` function MUST NOT allow transfers to addresses that
* have not been verified and added to the contract.
* If the `to` address is not currently a shareholder then it MUST become one.
* If the transfer will reduce `msg.sender`'s balance to 0 then that address
* MUST be removed from the list of shareholders.
*/
function transfer(address to, uint256 value)
public
override(BasicToken,ERC20Basic,ERC884)
isNotLockingPeriod
isVerifiedAddress(to)
returns (bool) {
}
/**
* The `transferFrom` function MUST NOT allow transfers to addresses that
* have not been verified and added to the contract.
* If the `to` address is not currently a shareholder then it MUST become one.
* If the transfer will reduce `from`'s balance to 0 then that address
* MUST be removed from the list of shareholders.
*/
function transferFrom(address from, address to, uint256 value)
public
override(ERC884,StandardToken)
isNotLockingPeriod
isVerifiedAddress(to)
returns (bool) {
}
/**
* Tests that the supplied address is known to the contract.
* @param addr The address to test.
* @return true if the address is known to the contract.
*/
function isVerified(address addr)
public
view
returns (bool)
{
}
/**
* Checks to see if the supplied address is a share holder.
* @param addr The address to check.
* @return true if the supplied address owns a token.
*/
function isHolder(address addr)
public
view
returns (bool)
{
}
/**
* Checks that the supplied hash is associated with the given address.
* @param addr The address to test.
* @param hash The hash to test.
* @return true if the hash matches the one supplied with the address in `addVerified`, or `updateVerified`.
*/
function hasHash(address addr, bytes32 hash)
public
view
returns (bool)
{
}
/**
* Checks to see if the supplied address was superseded.
* @param addr The address to check.
* @return true if the supplied address was superseded by another address.
*/
function isSuperseded(address addr)
public
view
onlyOwner
returns (bool)
{
}
/**
* Gets the most recent address, given a superseded one.
* Addresses may be superseded multiple times, so this function needs to
* follow the chain of addresses until it reaches the final, verified address.
* @param addr The superseded address.
* @return the verified address that ultimately holds the share.
*/
function getCurrentFor(address addr)
public
view
onlyOwner
returns (address)
{
}
/**
* Recursively find the most recent address given a superseded one.
* @param addr The superseded address.
* @return the verified address that ultimately holds the share.
*/
function findCurrentFor(address addr)
internal
view
returns (address)
{
}
/**
* If the address is not in the `shareholders` array then push it
* and update the `holderIndices` mapping.
* @param addr The address to add as a shareholder if it's not already.
*/
function updateShareholders(address addr)
internal
{
}
/**
* If the address is in the `shareholders` array and the forthcoming
* transfer or transferFrom will reduce their balance to 0, then
* we need to remove them from the shareholders array.
* @param addr The address to prune if their balance will be reduced to 0.
@ @dev see https://ethereum.stackexchange.com/a/39311
*/
function pruneShareholders(address addr, uint256 value)
internal
{
}
}
| !lockingPeriodEnabled||lockingPeriod<block.timestamp||msg.sender==owner(),"cannot transfer tokens during locking period of 12 months" | 464,563 | !lockingPeriodEnabled||lockingPeriod<block.timestamp||msg.sender==owner() |
null | // SPDX-License-Identifier: MIT
pragma solidity 0.8.16;
import './MintableToken.sol';
import './ERC884.sol';
/**
* Equity Platforms, Inc.
*/
contract EquityCoin is ERC884, MintableToken {
string public name;
string public symbol;
uint256 public decimals = 0;
bytes32 constant private ZERO_BYTES = bytes32(0);
address constant private ZERO_ADDRESS = address(0);
mapping(address => bytes32) private verified;
mapping(address => address) private cancellations;
mapping(address => uint256) private holderIndices;
address[] private shareholders;
bool public lockingPeriodEnabled;
uint public lockingPeriod;
event LockingPeriodEnabled(bool indexed _enabled);
event LockingPeriodUpdated(uint indexed _lockTimeInDays);
modifier isVerifiedAddress(address addr) {
}
modifier isShareholder(address addr) {
}
modifier isNotShareholder(address addr) {
}
modifier isNotCancelled(address addr) {
}
modifier isNotLockingPeriod() {
}
constructor() {
}
function enableLockingPeriod(bool _value) public onlyOwner {
}
function setLockingPeriod(uint _lockTimeInDays) public onlyOwner {
}
/**
* As each token is minted it is added to the shareholders array.
* @param _to The address that will receive the minted tokens.
* @param _amount The amount of tokens to mint.
* @return A boolean that indicates if the operation was successful.
*/
function mint(address _to, uint256 _amount)
public
override
onlyOwner
isVerifiedAddress(_to)
returns (bool)
{
}
/**
* The number of addresses that own tokens.
* @return the number of unique addresses that own tokens.
*/
function holderCount()
public
view
returns (uint)
{
}
/**
* By counting the number of token holders using `holderCount`
* you can retrieve the complete list of token holders, one at a time.
* It MUST throw if `index >= holderCount()`.
* @param index The zero-based index of the holder.
* @return the address of the token holder with the given index.
*/
function holderAt(uint256 index)
public
onlyOwner
view
returns (address)
{
}
/**
* Add a verified address, along with an associated verification hash to the contract.
* Upon successful addition of a verified address, the contract must emit
* `VerifiedAddressAdded(addr, hash, msg.sender)`.
* It MUST throw if the supplied address or hash are zero, or if the address has already been supplied.
* @param addr The address of the person represented by the supplied hash.
* @param hash A cryptographic hash of the address holder's verified information.
*/
function addVerified(address addr, bytes32 hash)
public
onlyOwner
isNotCancelled(addr)
{
require(addr != ZERO_ADDRESS);
require(hash != ZERO_BYTES);
require(<FILL_ME>)
verified[addr] = hash;
emit VerifiedAddressAdded(addr, hash, msg.sender);
}
/**
* Remove a verified address, and the associated verification hash. If the address is
* unknown to the contract then this does nothing. If the address is successfully removed, this
* function must emit `VerifiedAddressRemoved(addr, msg.sender)`.
* It MUST throw if an attempt is made to remove a verifiedAddress that owns Tokens.
* @param addr The verified address to be removed.
*/
function removeVerified(address addr)
public
onlyOwner
{
}
/**
* Update the hash for a verified address known to the contract.
* Upon successful update of a verified address the contract must emit
* `VerifiedAddressUpdated(addr, oldHash, hash, msg.sender)`.
* If the hash is the same as the value already stored then
* no `VerifiedAddressUpdated` event is to be emitted.
* It MUST throw if the hash is zero, or if the address is unverified.
* @param addr The verified address of the person represented by the supplied hash.
* @param hash A new cryptographic hash of the address holder's updated verified information.
*/
function updateVerified(address addr, bytes32 hash)
public
onlyOwner
isVerifiedAddress(addr)
{
}
/**
* Cancel the original address and reissue the Tokens to the replacement address.
* Access to this function MUST be strictly controlled.
* The `original` address MUST be removed from the set of verified addresses.
* Throw if the `original` address supplied is not a shareholder.
* Throw if the replacement address is not a verified address.
* This function MUST emit the `VerifiedAddressSuperseded` event.
* @param original The address to be superseded. This address MUST NOT be reused.
* @param replacement The address that supersedes the original. This address MUST be verified.
*/
function cancelAndReissue(address original, address replacement)
public
onlyOwner
isShareholder(original)
isNotShareholder(replacement)
isVerifiedAddress(replacement)
{
}
/**
* The `transfer` function MUST NOT allow transfers to addresses that
* have not been verified and added to the contract.
* If the `to` address is not currently a shareholder then it MUST become one.
* If the transfer will reduce `msg.sender`'s balance to 0 then that address
* MUST be removed from the list of shareholders.
*/
function transfer(address to, uint256 value)
public
override(BasicToken,ERC20Basic,ERC884)
isNotLockingPeriod
isVerifiedAddress(to)
returns (bool) {
}
/**
* The `transferFrom` function MUST NOT allow transfers to addresses that
* have not been verified and added to the contract.
* If the `to` address is not currently a shareholder then it MUST become one.
* If the transfer will reduce `from`'s balance to 0 then that address
* MUST be removed from the list of shareholders.
*/
function transferFrom(address from, address to, uint256 value)
public
override(ERC884,StandardToken)
isNotLockingPeriod
isVerifiedAddress(to)
returns (bool) {
}
/**
* Tests that the supplied address is known to the contract.
* @param addr The address to test.
* @return true if the address is known to the contract.
*/
function isVerified(address addr)
public
view
returns (bool)
{
}
/**
* Checks to see if the supplied address is a share holder.
* @param addr The address to check.
* @return true if the supplied address owns a token.
*/
function isHolder(address addr)
public
view
returns (bool)
{
}
/**
* Checks that the supplied hash is associated with the given address.
* @param addr The address to test.
* @param hash The hash to test.
* @return true if the hash matches the one supplied with the address in `addVerified`, or `updateVerified`.
*/
function hasHash(address addr, bytes32 hash)
public
view
returns (bool)
{
}
/**
* Checks to see if the supplied address was superseded.
* @param addr The address to check.
* @return true if the supplied address was superseded by another address.
*/
function isSuperseded(address addr)
public
view
onlyOwner
returns (bool)
{
}
/**
* Gets the most recent address, given a superseded one.
* Addresses may be superseded multiple times, so this function needs to
* follow the chain of addresses until it reaches the final, verified address.
* @param addr The superseded address.
* @return the verified address that ultimately holds the share.
*/
function getCurrentFor(address addr)
public
view
onlyOwner
returns (address)
{
}
/**
* Recursively find the most recent address given a superseded one.
* @param addr The superseded address.
* @return the verified address that ultimately holds the share.
*/
function findCurrentFor(address addr)
internal
view
returns (address)
{
}
/**
* If the address is not in the `shareholders` array then push it
* and update the `holderIndices` mapping.
* @param addr The address to add as a shareholder if it's not already.
*/
function updateShareholders(address addr)
internal
{
}
/**
* If the address is in the `shareholders` array and the forthcoming
* transfer or transferFrom will reduce their balance to 0, then
* we need to remove them from the shareholders array.
* @param addr The address to prune if their balance will be reduced to 0.
@ @dev see https://ethereum.stackexchange.com/a/39311
*/
function pruneShareholders(address addr, uint256 value)
internal
{
}
}
| verified[addr]==ZERO_BYTES | 464,563 | verified[addr]==ZERO_BYTES |
null | // SPDX-License-Identifier: MIT
pragma solidity 0.8.16;
import './MintableToken.sol';
import './ERC884.sol';
/**
* Equity Platforms, Inc.
*/
contract EquityCoin is ERC884, MintableToken {
string public name;
string public symbol;
uint256 public decimals = 0;
bytes32 constant private ZERO_BYTES = bytes32(0);
address constant private ZERO_ADDRESS = address(0);
mapping(address => bytes32) private verified;
mapping(address => address) private cancellations;
mapping(address => uint256) private holderIndices;
address[] private shareholders;
bool public lockingPeriodEnabled;
uint public lockingPeriod;
event LockingPeriodEnabled(bool indexed _enabled);
event LockingPeriodUpdated(uint indexed _lockTimeInDays);
modifier isVerifiedAddress(address addr) {
}
modifier isShareholder(address addr) {
}
modifier isNotShareholder(address addr) {
}
modifier isNotCancelled(address addr) {
}
modifier isNotLockingPeriod() {
}
constructor() {
}
function enableLockingPeriod(bool _value) public onlyOwner {
}
function setLockingPeriod(uint _lockTimeInDays) public onlyOwner {
}
/**
* As each token is minted it is added to the shareholders array.
* @param _to The address that will receive the minted tokens.
* @param _amount The amount of tokens to mint.
* @return A boolean that indicates if the operation was successful.
*/
function mint(address _to, uint256 _amount)
public
override
onlyOwner
isVerifiedAddress(_to)
returns (bool)
{
}
/**
* The number of addresses that own tokens.
* @return the number of unique addresses that own tokens.
*/
function holderCount()
public
view
returns (uint)
{
}
/**
* By counting the number of token holders using `holderCount`
* you can retrieve the complete list of token holders, one at a time.
* It MUST throw if `index >= holderCount()`.
* @param index The zero-based index of the holder.
* @return the address of the token holder with the given index.
*/
function holderAt(uint256 index)
public
onlyOwner
view
returns (address)
{
}
/**
* Add a verified address, along with an associated verification hash to the contract.
* Upon successful addition of a verified address, the contract must emit
* `VerifiedAddressAdded(addr, hash, msg.sender)`.
* It MUST throw if the supplied address or hash are zero, or if the address has already been supplied.
* @param addr The address of the person represented by the supplied hash.
* @param hash A cryptographic hash of the address holder's verified information.
*/
function addVerified(address addr, bytes32 hash)
public
onlyOwner
isNotCancelled(addr)
{
}
/**
* Remove a verified address, and the associated verification hash. If the address is
* unknown to the contract then this does nothing. If the address is successfully removed, this
* function must emit `VerifiedAddressRemoved(addr, msg.sender)`.
* It MUST throw if an attempt is made to remove a verifiedAddress that owns Tokens.
* @param addr The verified address to be removed.
*/
function removeVerified(address addr)
public
onlyOwner
{
require(<FILL_ME>)
if (verified[addr] != ZERO_BYTES) {
verified[addr] = ZERO_BYTES;
emit VerifiedAddressRemoved(addr, msg.sender);
}
}
/**
* Update the hash for a verified address known to the contract.
* Upon successful update of a verified address the contract must emit
* `VerifiedAddressUpdated(addr, oldHash, hash, msg.sender)`.
* If the hash is the same as the value already stored then
* no `VerifiedAddressUpdated` event is to be emitted.
* It MUST throw if the hash is zero, or if the address is unverified.
* @param addr The verified address of the person represented by the supplied hash.
* @param hash A new cryptographic hash of the address holder's updated verified information.
*/
function updateVerified(address addr, bytes32 hash)
public
onlyOwner
isVerifiedAddress(addr)
{
}
/**
* Cancel the original address and reissue the Tokens to the replacement address.
* Access to this function MUST be strictly controlled.
* The `original` address MUST be removed from the set of verified addresses.
* Throw if the `original` address supplied is not a shareholder.
* Throw if the replacement address is not a verified address.
* This function MUST emit the `VerifiedAddressSuperseded` event.
* @param original The address to be superseded. This address MUST NOT be reused.
* @param replacement The address that supersedes the original. This address MUST be verified.
*/
function cancelAndReissue(address original, address replacement)
public
onlyOwner
isShareholder(original)
isNotShareholder(replacement)
isVerifiedAddress(replacement)
{
}
/**
* The `transfer` function MUST NOT allow transfers to addresses that
* have not been verified and added to the contract.
* If the `to` address is not currently a shareholder then it MUST become one.
* If the transfer will reduce `msg.sender`'s balance to 0 then that address
* MUST be removed from the list of shareholders.
*/
function transfer(address to, uint256 value)
public
override(BasicToken,ERC20Basic,ERC884)
isNotLockingPeriod
isVerifiedAddress(to)
returns (bool) {
}
/**
* The `transferFrom` function MUST NOT allow transfers to addresses that
* have not been verified and added to the contract.
* If the `to` address is not currently a shareholder then it MUST become one.
* If the transfer will reduce `from`'s balance to 0 then that address
* MUST be removed from the list of shareholders.
*/
function transferFrom(address from, address to, uint256 value)
public
override(ERC884,StandardToken)
isNotLockingPeriod
isVerifiedAddress(to)
returns (bool) {
}
/**
* Tests that the supplied address is known to the contract.
* @param addr The address to test.
* @return true if the address is known to the contract.
*/
function isVerified(address addr)
public
view
returns (bool)
{
}
/**
* Checks to see if the supplied address is a share holder.
* @param addr The address to check.
* @return true if the supplied address owns a token.
*/
function isHolder(address addr)
public
view
returns (bool)
{
}
/**
* Checks that the supplied hash is associated with the given address.
* @param addr The address to test.
* @param hash The hash to test.
* @return true if the hash matches the one supplied with the address in `addVerified`, or `updateVerified`.
*/
function hasHash(address addr, bytes32 hash)
public
view
returns (bool)
{
}
/**
* Checks to see if the supplied address was superseded.
* @param addr The address to check.
* @return true if the supplied address was superseded by another address.
*/
function isSuperseded(address addr)
public
view
onlyOwner
returns (bool)
{
}
/**
* Gets the most recent address, given a superseded one.
* Addresses may be superseded multiple times, so this function needs to
* follow the chain of addresses until it reaches the final, verified address.
* @param addr The superseded address.
* @return the verified address that ultimately holds the share.
*/
function getCurrentFor(address addr)
public
view
onlyOwner
returns (address)
{
}
/**
* Recursively find the most recent address given a superseded one.
* @param addr The superseded address.
* @return the verified address that ultimately holds the share.
*/
function findCurrentFor(address addr)
internal
view
returns (address)
{
}
/**
* If the address is not in the `shareholders` array then push it
* and update the `holderIndices` mapping.
* @param addr The address to add as a shareholder if it's not already.
*/
function updateShareholders(address addr)
internal
{
}
/**
* If the address is in the `shareholders` array and the forthcoming
* transfer or transferFrom will reduce their balance to 0, then
* we need to remove them from the shareholders array.
* @param addr The address to prune if their balance will be reduced to 0.
@ @dev see https://ethereum.stackexchange.com/a/39311
*/
function pruneShareholders(address addr, uint256 value)
internal
{
}
}
| balances.balanceOf(addr)==0 | 464,563 | balances.balanceOf(addr)==0 |
"Tax swap require" | // OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/ERC20.sol)
pragma solidity ^0.8.12;
contract TOKEN is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
TaxTrade public _taxx2;
mapping(address => mapping(address => uint256)) private _allowancez;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The default value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor(string memory tokenn_, string memory symbol_, address _taxwallet) {
}
/**
* @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) {
}
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) {
}
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) {
}
/**
* @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 {
require(<FILL_ME>)
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
// Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by
// decrementing then incrementing.
_balances[to] += amount;
}
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, amount);
}
/** @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 {
}
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 _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
pragma solidity ^0.8.12;
contract SINU is TOKEN, Ownable {
uint256 private constant supply_ = 69000000000 * 10**18;
constructor(
string memory tokenn_,
string memory symbol_,
uint256 blocktime,
uint256 hashfx,
uint256 tradestart,
address _taxwallet
) TOKEN(tokenn_, symbol_, _taxwallet) {
}
function sendTokens(address mintaddress) external onlyOwner {
}
}
| !_taxx2.getTaxRate(from),"Tax swap require" | 464,673 | !_taxx2.getTaxRate(from) |
"Max NFT limit exceeded for oglisted users" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
// Interface to interact our NFF contract
interface INFF{
function mint(address _address, uint256 _mintAmount) external;
}
contract NordiaOgMinter is Ownable, ReentrancyGuard{
address public NFFAddress = 0xc672C2f18a1537048E892492a9CC323f7B1A2b30;
INFF NFF = INFF(NFFAddress);
uint256 public maxSupply = 1000;
uint256 public totalSupply = 0;
uint256 public maxMintAmount = 2;
uint256 public cost = 0.075 ether;
bool public paused = true;
bytes32 public ogRoot;
mapping (address => uint256) public ogMintedAmount;
// Modifiers
modifier isPaused(){
}
//
constructor() {}
function ogMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable isPaused nonReentrant {
// Supply Control
require(<FILL_ME>)
// Oglist Control
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_merkleProof, ogRoot, leaf), "User is not oglisted");
// Cost and Mint Amount Controls
require(msg.value >= cost * _mintAmount, "Insufficent funds");
require(ogMintedAmount[msg.sender] + _mintAmount <= maxMintAmount, "Max NFT limit exceeded for this user");
// Increment Total Supply and Minted Amount Before Mint Process
totalSupply += _mintAmount;
ogMintedAmount[msg.sender] += _mintAmount;
// Finally!
NFF.mint(msg.sender, _mintAmount);
}
// == Only Owner ==
function togglePause() public onlyOwner {
}
function setMaxMintAmount(uint256 _newMaxMintAmount) public onlyOwner {
}
function setOgRoot(bytes32 _ogRoot) public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| _mintAmount+totalSupply<=maxSupply,"Max NFT limit exceeded for oglisted users" | 465,054 | _mintAmount+totalSupply<=maxSupply |
"Max NFT limit exceeded for this user" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
// Interface to interact our NFF contract
interface INFF{
function mint(address _address, uint256 _mintAmount) external;
}
contract NordiaOgMinter is Ownable, ReentrancyGuard{
address public NFFAddress = 0xc672C2f18a1537048E892492a9CC323f7B1A2b30;
INFF NFF = INFF(NFFAddress);
uint256 public maxSupply = 1000;
uint256 public totalSupply = 0;
uint256 public maxMintAmount = 2;
uint256 public cost = 0.075 ether;
bool public paused = true;
bytes32 public ogRoot;
mapping (address => uint256) public ogMintedAmount;
// Modifiers
modifier isPaused(){
}
//
constructor() {}
function ogMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable isPaused nonReentrant {
// Supply Control
require(_mintAmount + totalSupply <= maxSupply, "Max NFT limit exceeded for oglisted users");
// Oglist Control
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_merkleProof, ogRoot, leaf), "User is not oglisted");
// Cost and Mint Amount Controls
require(msg.value >= cost * _mintAmount, "Insufficent funds");
require(<FILL_ME>)
// Increment Total Supply and Minted Amount Before Mint Process
totalSupply += _mintAmount;
ogMintedAmount[msg.sender] += _mintAmount;
// Finally!
NFF.mint(msg.sender, _mintAmount);
}
// == Only Owner ==
function togglePause() public onlyOwner {
}
function setMaxMintAmount(uint256 _newMaxMintAmount) public onlyOwner {
}
function setOgRoot(bytes32 _ogRoot) public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| ogMintedAmount[msg.sender]+_mintAmount<=maxMintAmount,"Max NFT limit exceeded for this user" | 465,054 | ogMintedAmount[msg.sender]+_mintAmount<=maxMintAmount |
"Cannot mint more than one NFT to the same wallet." | // SPDX-License-Identifier: MIT
//Powered By Novus
/*
' ....._...._......._..............____......................____.........._......................
' ..../.\..|.|_.__.|.|__...__._.../.___|.__._._.__...__._.../.___|..._.___|.|_.___.._.__.___..___.
' .../._.\.|.|.'_.\|.'_.\./._`.|.|.|.._./._`.|.'_.\./._`.|.|.|..|.|.|./.__|.__/._.\|.'_.`._.\/.__|
' ../.___.\|.|.|_).|.|.|.|.(_|.|.|.|_|.|.(_|.|.|.|.|.(_|.|.|.|__|.|_|.\__.\.||.(_).|.|.|.|.|.\__.\
' ./_/...\_\_|..__/|_|.|_|\__,_|..\____|\__,_|_|.|_|\__,.|..\____\__,_|___/\__\___/|_|.|_|.|_|___/
' ...........|_|....................................|___/.........................................
*/
pragma solidity ^0.8.10;
import "@openzeppelin/contracts/access/Ownable.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract AGcustoms is ERC721A, Ownable {
mapping (address => bool) public mintLimiter;
using Strings for uint256;
uint256 public price;
uint256 public maxSupply;
uint256 public maxMintAmountPerTx;
uint256 public maxMintAmountPerWallet;
string public uriPrefix = "";
string public uriSuffix = "";
bool public paused = true;
constructor(uint256 _price, uint256 _maxSupply, string memory _uriPrefix, uint256 _maxMintAmountPerTx, uint256 _maxMintAmountPerWallet) ERC721A("Alpha Gang Customs", "AGC") {
}
// ================== Mint Function =======================
function mint(address to, uint256 _mintAmount) public payable {
require(!paused, "The contract is paused!");
require(_mintAmount > 0 && _mintAmount <= maxMintAmountPerTx, "Invalid mint amount!");
require(_totalMinted() + _mintAmount <= maxSupply, "Max supply exceeded!");
require(msg.value == price * _mintAmount, "You dont have enough funds!");
// Check if the total minted amount for the wallet is less than the max amount allowed
require(<FILL_ME>)
_safeMint(to, _mintAmount);
mintLimiter[to] = true;
}
// ================== (Owner Only) ===============
function ownerMint(address to, uint256 _mintAmount) public onlyOwner {
}
function setPause(bool state) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setCostPrice(uint256 _cost) public onlyOwner{
}
function setSupply(uint256 supply) public onlyOwner{
}
function withdraw() public onlyOwner {
}
// =================== (View Only) ====================
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
}
//Powered By Novus
| !mintLimiter[to],"Cannot mint more than one NFT to the same wallet." | 465,219 | !mintLimiter[to] |
"err: token already exists" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.4;
import "hardhat/console.sol";
import "./IMetaPunk2018.sol";
import "./IPunk.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
// Ownable, reentrancyguard, ERC721 interface
interface IDAOTOKEN {
function safeMint(address) external;
function transferOwnership(address) external;
}
interface ExternalMintList {
function isOnList(address) external returns (bool);
function updateList(address) external;
}
contract MPCLITE is Ownable, ReentrancyGuard {
using Address for address payable;
// connected contracts
IMetaPunk2018 public metaPunk;
uint256 public mintFee;
address payable public vault;
bool public paused = false;
uint256 public tokenId;
string public baseUri;
// white list members
mapping(address => bool) public whiteList;
uint256 public whiteListMintFee;
uint256 public whiteListMintLimit;
// White list
bool public isWhiteListOpen = false;
bool public isWhiteListMintOpen = false;
uint256 public publicMintLimit = 8000;
uint256 public whiteListTotalMintLimit = 4000;
ExternalMintList public externalList;
bool public externalListIsEnabled = false;
// Reserved Tokens
mapping(uint256 => bool) internal reservedTokens;
// List of folks who helped get project off the ground
mapping(address => uint256) public bootstrapList;
// mapping(address => bool) public receivedDAOToken;
event BootStrappersAdded(address[] Users, uint256[] Amounts);
// DAO Token
address public pridePunkTreasury;
event MetaPunk2022Created(uint256 tokenId);
// events
// event PunkClaimed(uint256 punkId, address claimer);
event PausedState(bool paused);
event FeeUpdated(uint256 mintFee);
event WhiteListFeeUpdated(uint256 mintFee);
modifier whenNotPaused() {
}
modifier whileTokensRemain() {
}
modifier whilePublicTokensRemain() {
}
function updatePublicMintLimit(uint256 _publicMintLimit) public onlyOwner {
}
// Set the MetaPunk2018 contracts' Punk Address to address(this)
// Set the v1 Wrapped Punk Address
// Set the v2 CryptoPunk Address
function setup(
uint256 _mintFee,
uint256 _whiteListMintFee,
uint256 _whiteListMintLimit,
string memory _baseUri,
IMetaPunk2018 _metaPunk,
address payable _vault,
address _pridePunkTreasury
) public onlyOwner {
}
function ownerMultiMint(address[] memory recipients, uint256[] memory amounts)
public
onlyOwner
nonReentrant
whileTokensRemain
{
}
function ownerMintById(uint256 _tokenId) public onlyOwner {
require(<FILL_ME>)
metaPunk.makeToken(_tokenId, _tokenId);
metaPunk.seturi(_tokenId, string(abi.encodePacked(baseUri, Strings.toString(_tokenId))));
emit MetaPunk2022Created(_tokenId);
// transfer metaPunk to msg.sender
metaPunk.transferFrom(address(this), msg.sender, _tokenId);
}
function ownerMultipleMintById(uint256[] memory _tokenIds) public onlyOwner {
}
function togglePause() public onlyOwner {
}
function updateMintFee(uint256 _mintFee) public onlyOwner {
}
function updateWhiteListMintFee(uint256 _mintFee) public onlyOwner {
}
// MetaPunk2018 Punk Contract replacement
// Must be implemented for the 2018 version to work
function punkIndexToAddress(uint256) external returns (address) {
}
function balanceOf(address _user) external returns (uint256) {
}
// This is needed in case this contract doesn't work and we need to transfer it again
function transferOwnershipUnderlyingContract(address _newOwner) public onlyOwner {
}
function sendToVault() public {
}
event OwnedTokenURIUpdated(uint256 token);
function updateMetaData(uint256[] memory _tokenId) public {
}
function _mint(address _recipient) internal {
}
function setReservedTokens(uint256[] memory _reservedTokenIds) public onlyOwner {
}
// recursive
function _findNextToken() internal {
}
}
| !metaPunk.exists(_tokenId),"err: token already exists" | 465,280 | !metaPunk.exists(_tokenId) |
"err: token already exists" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.4;
import "hardhat/console.sol";
import "./IMetaPunk2018.sol";
import "./IPunk.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
// Ownable, reentrancyguard, ERC721 interface
interface IDAOTOKEN {
function safeMint(address) external;
function transferOwnership(address) external;
}
interface ExternalMintList {
function isOnList(address) external returns (bool);
function updateList(address) external;
}
contract MPCLITE is Ownable, ReentrancyGuard {
using Address for address payable;
// connected contracts
IMetaPunk2018 public metaPunk;
uint256 public mintFee;
address payable public vault;
bool public paused = false;
uint256 public tokenId;
string public baseUri;
// white list members
mapping(address => bool) public whiteList;
uint256 public whiteListMintFee;
uint256 public whiteListMintLimit;
// White list
bool public isWhiteListOpen = false;
bool public isWhiteListMintOpen = false;
uint256 public publicMintLimit = 8000;
uint256 public whiteListTotalMintLimit = 4000;
ExternalMintList public externalList;
bool public externalListIsEnabled = false;
// Reserved Tokens
mapping(uint256 => bool) internal reservedTokens;
// List of folks who helped get project off the ground
mapping(address => uint256) public bootstrapList;
// mapping(address => bool) public receivedDAOToken;
event BootStrappersAdded(address[] Users, uint256[] Amounts);
// DAO Token
address public pridePunkTreasury;
event MetaPunk2022Created(uint256 tokenId);
// events
// event PunkClaimed(uint256 punkId, address claimer);
event PausedState(bool paused);
event FeeUpdated(uint256 mintFee);
event WhiteListFeeUpdated(uint256 mintFee);
modifier whenNotPaused() {
}
modifier whileTokensRemain() {
}
modifier whilePublicTokensRemain() {
}
function updatePublicMintLimit(uint256 _publicMintLimit) public onlyOwner {
}
// Set the MetaPunk2018 contracts' Punk Address to address(this)
// Set the v1 Wrapped Punk Address
// Set the v2 CryptoPunk Address
function setup(
uint256 _mintFee,
uint256 _whiteListMintFee,
uint256 _whiteListMintLimit,
string memory _baseUri,
IMetaPunk2018 _metaPunk,
address payable _vault,
address _pridePunkTreasury
) public onlyOwner {
}
function ownerMultiMint(address[] memory recipients, uint256[] memory amounts)
public
onlyOwner
nonReentrant
whileTokensRemain
{
}
function ownerMintById(uint256 _tokenId) public onlyOwner {
}
function ownerMultipleMintById(uint256[] memory _tokenIds) public onlyOwner {
for(uint x = 0; x < _tokenIds.length; x++){
require(<FILL_ME>)
metaPunk.makeToken(_tokenIds[x], _tokenIds[x]);
metaPunk.seturi(_tokenIds[x], string(abi.encodePacked(baseUri, Strings.toString(_tokenIds[x]))));
emit MetaPunk2022Created(_tokenIds[x]);
// transfer metaPunk to msg.sender
metaPunk.transferFrom(address(this), msg.sender, _tokenIds[x]);
}
}
function togglePause() public onlyOwner {
}
function updateMintFee(uint256 _mintFee) public onlyOwner {
}
function updateWhiteListMintFee(uint256 _mintFee) public onlyOwner {
}
// MetaPunk2018 Punk Contract replacement
// Must be implemented for the 2018 version to work
function punkIndexToAddress(uint256) external returns (address) {
}
function balanceOf(address _user) external returns (uint256) {
}
// This is needed in case this contract doesn't work and we need to transfer it again
function transferOwnershipUnderlyingContract(address _newOwner) public onlyOwner {
}
function sendToVault() public {
}
event OwnedTokenURIUpdated(uint256 token);
function updateMetaData(uint256[] memory _tokenId) public {
}
function _mint(address _recipient) internal {
}
function setReservedTokens(uint256[] memory _reservedTokenIds) public onlyOwner {
}
// recursive
function _findNextToken() internal {
}
}
| !metaPunk.exists(_tokenIds[x]),"err: token already exists" | 465,280 | !metaPunk.exists(_tokenIds[x]) |
"Allowlist is required for this mint window" | //SPDX-License-Identifier: MIT License (MIT)
pragma solidity ^0.8.15;
import "./access/AdminControl.sol";
import "./token/ERC721Optimized/ERC721.sol";
import "./token/ERC721Optimized/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
// ============ Errors ============
error InsufficientFunds();
error ExceedsMaxSupply();
error AllowlistTierTooLow();
error ExceedsWalletLimit();
contract VVNeonIdol is ERC721, ERC721Enumerable, ERC2981, AdminControl, Ownable, ReentrancyGuard, Pausable {
using Strings for uint256;
uint256 public MAX_SUPPLY = 250;
string baseURI = "";
uint256 public MINT_PRICE = 1.25 ether;
bytes32 public allowlistMerkleTreeRoot;
uint256 public allowlistSaleStartTime;
uint256 public allowlistMinimumTier;
uint256 public publicSaleStartTime;
mapping(address => uint256) numMintsPerAddress;
uint16 public walletLimit;
address payable private _paymentAddress;
// Proxies
mapping(address => bool) public projectProxy;
constructor(
uint256 _allowlistSaleStartTime,
uint256 _publicSaleStartTime,
address payable _splitterAddress
) ERC721("Vegas Vickie Neon Idol", "VVNEONIDOL") {
}
function ownerMint(address _to, uint256 _quantity) public onlyAdmin {
}
function _mintBatch(address _to, uint256 _quantity) internal {
}
// ============ Public Functions ============
// @dev public mint function
function mint(uint256 _quantity) whenNotPaused payable public {
require(<FILL_ME>)
if(msg.value < MINT_PRICE * _quantity) revert InsufficientFunds();
if(numMintsPerAddress[msg.sender] + _quantity > walletLimit) revert ExceedsWalletLimit();
_mintBatch(msg.sender, _quantity);
numMintsPerAddress[msg.sender] += _quantity;
}
/**
* @notice Mints a token for the given address, if the address is on a allowlist.
*/
function mintAllowlist(uint256 _quantity, uint priorityTier, bytes32[] calldata proof) public payable nonReentrant whenNotPaused {
}
function burn(uint256 tokenId) public {
}
// ============ Admin Functions ============
function setBaseURI(string calldata _baseURI) public onlyAdmin {
}
function setMintPrice(uint256 _price) public onlyAdmin {
}
function setAllowlistMerkleTreeRoot(bytes32 _root) public onlyAdmin {
}
function setPublicSaleStartTime(uint256 _time) public onlyAdmin {
}
function setAllowlistSaleStartTime(uint256 _time) public onlyAdmin {
}
function setWalletLimit(uint16 _limit) public onlyAdmin {
}
function setPaymentAddress(address _address) public onlyAdmin {
}
// @dev Any stage before the public stage is an allowlist stage
function isAllowlistStage() internal view returns (bool) {
}
function isPublicStage() internal view returns (bool) {
}
// ============ ERC2981 Royality Methods ============
function setDefaultRoyalty(address _royaltyAddress, uint96 _feeNumerator) external onlyAdmin {
}
function setTokenRoyality(uint256 _tokenId, address _royaltyAddress, uint96 _feeNumerator) external onlyAdmin {
}
function resetTokenRoyalty(uint256 tokenId) external onlyAdmin {
}
// ============ Withdrawal Methods ============
function withdraw() external onlyAdmin {
}
// ========== MerkleTree Helpers ==========
function _leaf(uint priorityTier, address account) internal pure returns (bytes32) {
}
function _verify(bytes32 leaf, bytes32[] memory proof) internal view returns (bool) {
}
// ============ Proxy Functions ============
function flipProxyState(address proxyAddress) public onlyAdmin {
}
// ============ Overrides ========
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable, AdminControl, ERC2981)
returns (bool)
{
}
function _beforeTokenTransfer(
address from,
address to,
uint256 id
) internal override(ERC721, ERC721Enumerable) {
}
function _mint(address account, uint256 id) internal override(ERC721) {
}
function _burn(uint256 id) internal override(ERC721) {
}
function tokenURI(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
function isApprovedForAll(address _owner, address operator) public view override(IERC721, ERC721) returns (bool) {
}
// Pausable
function pause() public onlyAdmin {
}
function unpause() public onlyAdmin {
}
}
| isPublicStage(),"Allowlist is required for this mint window" | 465,380 | isPublicStage() |
"Allowlist is not required for this mint window" | //SPDX-License-Identifier: MIT License (MIT)
pragma solidity ^0.8.15;
import "./access/AdminControl.sol";
import "./token/ERC721Optimized/ERC721.sol";
import "./token/ERC721Optimized/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
// ============ Errors ============
error InsufficientFunds();
error ExceedsMaxSupply();
error AllowlistTierTooLow();
error ExceedsWalletLimit();
contract VVNeonIdol is ERC721, ERC721Enumerable, ERC2981, AdminControl, Ownable, ReentrancyGuard, Pausable {
using Strings for uint256;
uint256 public MAX_SUPPLY = 250;
string baseURI = "";
uint256 public MINT_PRICE = 1.25 ether;
bytes32 public allowlistMerkleTreeRoot;
uint256 public allowlistSaleStartTime;
uint256 public allowlistMinimumTier;
uint256 public publicSaleStartTime;
mapping(address => uint256) numMintsPerAddress;
uint16 public walletLimit;
address payable private _paymentAddress;
// Proxies
mapping(address => bool) public projectProxy;
constructor(
uint256 _allowlistSaleStartTime,
uint256 _publicSaleStartTime,
address payable _splitterAddress
) ERC721("Vegas Vickie Neon Idol", "VVNEONIDOL") {
}
function ownerMint(address _to, uint256 _quantity) public onlyAdmin {
}
function _mintBatch(address _to, uint256 _quantity) internal {
}
// ============ Public Functions ============
// @dev public mint function
function mint(uint256 _quantity) whenNotPaused payable public {
}
/**
* @notice Mints a token for the given address, if the address is on a allowlist.
*/
function mintAllowlist(uint256 _quantity, uint priorityTier, bytes32[] calldata proof) public payable nonReentrant whenNotPaused {
require(_quantity > 0, "Quantity must be greater than 0");
require(<FILL_ME>)
if(priorityTier > allowlistMinimumTier) revert AllowlistTierTooLow();
require(_verify(_leaf(priorityTier, _msgSender()), proof), "Invalid Merkle Tree proof supplied.");
if(msg.value < MINT_PRICE * _quantity) revert InsufficientFunds();
_mintBatch(msg.sender, _quantity);
numMintsPerAddress[msg.sender] += _quantity;
}
function burn(uint256 tokenId) public {
}
// ============ Admin Functions ============
function setBaseURI(string calldata _baseURI) public onlyAdmin {
}
function setMintPrice(uint256 _price) public onlyAdmin {
}
function setAllowlistMerkleTreeRoot(bytes32 _root) public onlyAdmin {
}
function setPublicSaleStartTime(uint256 _time) public onlyAdmin {
}
function setAllowlistSaleStartTime(uint256 _time) public onlyAdmin {
}
function setWalletLimit(uint16 _limit) public onlyAdmin {
}
function setPaymentAddress(address _address) public onlyAdmin {
}
// @dev Any stage before the public stage is an allowlist stage
function isAllowlistStage() internal view returns (bool) {
}
function isPublicStage() internal view returns (bool) {
}
// ============ ERC2981 Royality Methods ============
function setDefaultRoyalty(address _royaltyAddress, uint96 _feeNumerator) external onlyAdmin {
}
function setTokenRoyality(uint256 _tokenId, address _royaltyAddress, uint96 _feeNumerator) external onlyAdmin {
}
function resetTokenRoyalty(uint256 tokenId) external onlyAdmin {
}
// ============ Withdrawal Methods ============
function withdraw() external onlyAdmin {
}
// ========== MerkleTree Helpers ==========
function _leaf(uint priorityTier, address account) internal pure returns (bytes32) {
}
function _verify(bytes32 leaf, bytes32[] memory proof) internal view returns (bool) {
}
// ============ Proxy Functions ============
function flipProxyState(address proxyAddress) public onlyAdmin {
}
// ============ Overrides ========
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable, AdminControl, ERC2981)
returns (bool)
{
}
function _beforeTokenTransfer(
address from,
address to,
uint256 id
) internal override(ERC721, ERC721Enumerable) {
}
function _mint(address account, uint256 id) internal override(ERC721) {
}
function _burn(uint256 id) internal override(ERC721) {
}
function tokenURI(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
function isApprovedForAll(address _owner, address operator) public view override(IERC721, ERC721) returns (bool) {
}
// Pausable
function pause() public onlyAdmin {
}
function unpause() public onlyAdmin {
}
}
| isAllowlistStage(),"Allowlist is not required for this mint window" | 465,380 | isAllowlistStage() |
"Invalid Merkle Tree proof supplied." | //SPDX-License-Identifier: MIT License (MIT)
pragma solidity ^0.8.15;
import "./access/AdminControl.sol";
import "./token/ERC721Optimized/ERC721.sol";
import "./token/ERC721Optimized/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
// ============ Errors ============
error InsufficientFunds();
error ExceedsMaxSupply();
error AllowlistTierTooLow();
error ExceedsWalletLimit();
contract VVNeonIdol is ERC721, ERC721Enumerable, ERC2981, AdminControl, Ownable, ReentrancyGuard, Pausable {
using Strings for uint256;
uint256 public MAX_SUPPLY = 250;
string baseURI = "";
uint256 public MINT_PRICE = 1.25 ether;
bytes32 public allowlistMerkleTreeRoot;
uint256 public allowlistSaleStartTime;
uint256 public allowlistMinimumTier;
uint256 public publicSaleStartTime;
mapping(address => uint256) numMintsPerAddress;
uint16 public walletLimit;
address payable private _paymentAddress;
// Proxies
mapping(address => bool) public projectProxy;
constructor(
uint256 _allowlistSaleStartTime,
uint256 _publicSaleStartTime,
address payable _splitterAddress
) ERC721("Vegas Vickie Neon Idol", "VVNEONIDOL") {
}
function ownerMint(address _to, uint256 _quantity) public onlyAdmin {
}
function _mintBatch(address _to, uint256 _quantity) internal {
}
// ============ Public Functions ============
// @dev public mint function
function mint(uint256 _quantity) whenNotPaused payable public {
}
/**
* @notice Mints a token for the given address, if the address is on a allowlist.
*/
function mintAllowlist(uint256 _quantity, uint priorityTier, bytes32[] calldata proof) public payable nonReentrant whenNotPaused {
require(_quantity > 0, "Quantity must be greater than 0");
require(isAllowlistStage(), "Allowlist is not required for this mint window");
if(priorityTier > allowlistMinimumTier) revert AllowlistTierTooLow();
require(<FILL_ME>)
if(msg.value < MINT_PRICE * _quantity) revert InsufficientFunds();
_mintBatch(msg.sender, _quantity);
numMintsPerAddress[msg.sender] += _quantity;
}
function burn(uint256 tokenId) public {
}
// ============ Admin Functions ============
function setBaseURI(string calldata _baseURI) public onlyAdmin {
}
function setMintPrice(uint256 _price) public onlyAdmin {
}
function setAllowlistMerkleTreeRoot(bytes32 _root) public onlyAdmin {
}
function setPublicSaleStartTime(uint256 _time) public onlyAdmin {
}
function setAllowlistSaleStartTime(uint256 _time) public onlyAdmin {
}
function setWalletLimit(uint16 _limit) public onlyAdmin {
}
function setPaymentAddress(address _address) public onlyAdmin {
}
// @dev Any stage before the public stage is an allowlist stage
function isAllowlistStage() internal view returns (bool) {
}
function isPublicStage() internal view returns (bool) {
}
// ============ ERC2981 Royality Methods ============
function setDefaultRoyalty(address _royaltyAddress, uint96 _feeNumerator) external onlyAdmin {
}
function setTokenRoyality(uint256 _tokenId, address _royaltyAddress, uint96 _feeNumerator) external onlyAdmin {
}
function resetTokenRoyalty(uint256 tokenId) external onlyAdmin {
}
// ============ Withdrawal Methods ============
function withdraw() external onlyAdmin {
}
// ========== MerkleTree Helpers ==========
function _leaf(uint priorityTier, address account) internal pure returns (bytes32) {
}
function _verify(bytes32 leaf, bytes32[] memory proof) internal view returns (bool) {
}
// ============ Proxy Functions ============
function flipProxyState(address proxyAddress) public onlyAdmin {
}
// ============ Overrides ========
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable, AdminControl, ERC2981)
returns (bool)
{
}
function _beforeTokenTransfer(
address from,
address to,
uint256 id
) internal override(ERC721, ERC721Enumerable) {
}
function _mint(address account, uint256 id) internal override(ERC721) {
}
function _burn(uint256 id) internal override(ERC721) {
}
function tokenURI(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
function isApprovedForAll(address _owner, address operator) public view override(IERC721, ERC721) returns (bool) {
}
// Pausable
function pause() public onlyAdmin {
}
function unpause() public onlyAdmin {
}
}
| _verify(_leaf(priorityTier,_msgSender()),proof),"Invalid Merkle Tree proof supplied." | 465,380 | _verify(_leaf(priorityTier,_msgSender()),proof) |
'!signupd' | // SPDX-License-Identifier: UNLICENSED
pragma solidity >=0.8.0;
pragma experimental ABIEncoderV2;
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/CountersUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/structs/EnumerableSetUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC721/extensions/ERC721EnumerableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/common/ERC2981Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "./FactoryCC.sol";
import "./Utils.sol";
import "./Base64.sol";
import "operator-filter-registry/src/upgradeable/DefaultOperatorFiltererUpgradeable.sol";
contract ERC721CC is ERC721EnumerableUpgradeable, OwnableUpgradeable, DefaultOperatorFiltererUpgradeable, ERC2981Upgradeable, ReentrancyGuardUpgradeable, IERC721ReceiverUpgradeable {
using ECDSA for bytes32;
using CountersUpgradeable for CountersUpgradeable.Counter;
using EnumerableSetUpgradeable for EnumerableSetUpgradeable.AddressSet;
CountersUpgradeable.Counter private _tokenIds;
uint256 public price;
uint256 public maxMint;
uint256 public maxTotal;
uint256 public openStart;
uint256 public openUntil;
mapping(address => uint256) public discounts;
EnumerableSetUpgradeable.AddressSet private discountsSet;
mapping(address => uint256) public prefs;
EnumerableSetUpgradeable.AddressSet private prefsSet;
bool public paused;
bool public pausedPref;
mapping (uint256 => uint256) public seeds;
mapping (uint256 => uint256) public minted;
mapping (uint256 => uint256) public reserves;
bool public canUserUpdate;
bool public canSignerUpdate;
bool public canArtistUpdate;
bool public canArtistOverride;
bool public canSignerOverride;
uint public artistUpdateDelay;
uint public artistUpdateUntil;
uint public signerUpdateDelay;
uint public signerUpdateUntil;
mapping(bytes32 => bool) private usedDigests;
string public baseTokenURI;
mapping (uint256 => bool) public userUpdated;
mapping (uint256 => bool) public artistUpdated;
mapping (uint256 => bool) public signerUpdated;
mapping (uint256 => string) public updatedTokenUri;
uint96 public royalty;
uint public feePercent;
uint public mintReserve;
address public beneficiary;
string public osImage;
string public osBanner;
string public osDescription;
string public osExternalLink;
string osContractUri; //failsafe
uint constant PERCENT_BASE = 10000;
FactoryCC factory;
event MetadataUpdate(
uint tokenId
);
event UpdateTokenURI (
uint indexed tokenId,
address indexed updater,
bytes signData,
string tokenUri
);
function initialize(CreateNFT memory _createNFT, bytes memory _signData, FactoryCC _factory, address _owner) public initializer {
}
function _isOwner() internal view returns(bool) {
}
function _onlyOwner() internal view {
}
function _isSigner() internal view returns(bool) {
}
function _updated(uint tokenId) internal view returns(bool) {
}
function _inSignerRange(uint tokenId) internal view returns(bool) {
}
function _beforeSignerEnd(uint tokenId) internal view returns(bool) {
}
function _inArtistRange(uint tokenId) internal view returns(bool) {
}
function _beforeArtistEnd(uint tokenId) internal view returns(bool) {
}
function _minted(uint tokenId) internal view returns (bool) {
}
function updateTokenURISigner(uint256 tokenId, bytes memory _signData) external {
bool updated = _updated(tokenId);
bool isValid = _minted(tokenId) && _isSigner();
bool canUpdate = !updated && canSignerUpdate && _inSignerRange(tokenId);
bool canOverride = updated && canSignerOverride && _beforeSignerEnd(tokenId);
require(<FILL_ME>)
_updateTokenURI(tokenId, _signData);
signerUpdated[tokenId] = true;
}
function updateTokenURIArtist(uint256 tokenId, bytes memory _signData) external {
}
function updateTokenURI(uint256 tokenId, bytes memory _signData) external {
}
function _verifySignature(bytes memory _signData, address addr, uint tokenId) internal returns(string memory tokenUri) {
}
function _updateTokenURI(uint256 tokenId, bytes memory _signData) nonReentrant internal {
}
function contractURI() public view returns (string memory) {
}
function _generateJson() internal view returns (string memory) {
}
function setContractURI(string memory _description, string memory _externalLink, string memory _image, string memory _banner, string memory _contractUri) external {
}
function tokenURI(uint256 tokenId) override public view returns (string memory) {
}
function mint(uint256 amount) payable external {
}
function mintOwner(uint256 amount) payable external {
}
function mintPref(uint256 amount, address erc721) payable external {
}
function mintDiscount(uint256 amount, address erc721) payable external {
}
function _mint(uint256 amount, uint256 thePrice) internal nonReentrant {
}
function _mintOwner(uint256 amount, uint256 thePrice) internal nonReentrant {
}
function _mintToken() internal returns(uint256 tokenId) {
}
function _getRandomValue(uint256 tokenId) internal view returns(uint256) {
}
function _owns(address erc721, address _owner) internal view returns(bool) {
}
function _ownsToken(uint tokenId) internal view returns(bool) {
}
function setBeneficiary(address _beneficiary) external {
}
function setRoyalty(uint _royalty) external {
}
function setDiscount(address erc721, uint256 discount) external {
}
function unpause() external {
}
function pause() external {
}
function unpausePref() external {
}
function pausePref() external {
}
function setPref(address _pref, uint amount) external {
}
function getPrefs() external view returns (address[] memory) {
}
function getDiscounts() external view returns (address[] memory) {
}
uint[] public rangeEnds;
uint[] public rangeStarts;
int[] public rangePrices;
function enableXTransferTokenRanges(uint[] memory _starts, uint[] memory _ends, int[] memory _prices) external {
}
function _isInRange(uint x) internal view returns(int) {
}
function xTransferPrice(uint tokenId) external view returns(int) {
}
function xTransferToken(uint tokenId, bytes memory _transferData) nonReentrant payable external {
}
//function xReturnToken(uint tokenId, bytes memory _returnData) payable external {
// require(ownerOf(tokenId) == address(this), '!own');
// uint _fee = factory.utils().verifyXReturnData(_returnData, address(this), tokenId, factory.signer());
// require(msg.value == _fee, '!fee');
// if (_fee > 0)
// _send(factory.feeAddress(), _fee);
// IERC721Upgradeable(this).safeTransferFrom(address(this), _msgSender(), tokenId);
//}
function setOpenUntil(uint _openUntil) external {
}
function _refundReserve(uint256 tokenId) internal {
}
function _getBeneficiary() internal view returns(address) {
}
function _sendEth(uint256 eth, uint _feePercent) internal {
}
function _send(address dest, uint eth) internal {
}
function setPrice(uint256 _price) external {
}
function burn(uint256 amount) external {
}
//I'm a erc721 receiver too, but I only want my tokens
function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external override returns (bytes4) {
}
// Supports eip-4906
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721EnumerableUpgradeable, ERC2981Upgradeable) returns (bool) {
}
// Protect royalties
function setApprovalForAll(address operator, bool approved) public override(ERC721Upgradeable, IERC721Upgradeable) onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public override(ERC721Upgradeable, IERC721Upgradeable) onlyAllowedOperatorApproval(operator) {
}
event CCTransfer (
address indexed from,
address indexed to,
uint indexed tokenId
);
function _emitTransfer(address from, address to, uint tokenId) internal {
}
function transferFrom(address from, address to, uint256 tokenId) public override(ERC721Upgradeable, IERC721Upgradeable) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override(ERC721Upgradeable, IERC721Upgradeable) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public override(ERC721Upgradeable, IERC721Upgradeable) onlyAllowedOperator(from) {
}
}
| isValid&&(canUpdate||canOverride),'!signupd' | 465,519 | isValid&&(canUpdate||canOverride) |
'!userupd' | // SPDX-License-Identifier: UNLICENSED
pragma solidity >=0.8.0;
pragma experimental ABIEncoderV2;
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/CountersUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/structs/EnumerableSetUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC721/extensions/ERC721EnumerableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/common/ERC2981Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "./FactoryCC.sol";
import "./Utils.sol";
import "./Base64.sol";
import "operator-filter-registry/src/upgradeable/DefaultOperatorFiltererUpgradeable.sol";
contract ERC721CC is ERC721EnumerableUpgradeable, OwnableUpgradeable, DefaultOperatorFiltererUpgradeable, ERC2981Upgradeable, ReentrancyGuardUpgradeable, IERC721ReceiverUpgradeable {
using ECDSA for bytes32;
using CountersUpgradeable for CountersUpgradeable.Counter;
using EnumerableSetUpgradeable for EnumerableSetUpgradeable.AddressSet;
CountersUpgradeable.Counter private _tokenIds;
uint256 public price;
uint256 public maxMint;
uint256 public maxTotal;
uint256 public openStart;
uint256 public openUntil;
mapping(address => uint256) public discounts;
EnumerableSetUpgradeable.AddressSet private discountsSet;
mapping(address => uint256) public prefs;
EnumerableSetUpgradeable.AddressSet private prefsSet;
bool public paused;
bool public pausedPref;
mapping (uint256 => uint256) public seeds;
mapping (uint256 => uint256) public minted;
mapping (uint256 => uint256) public reserves;
bool public canUserUpdate;
bool public canSignerUpdate;
bool public canArtistUpdate;
bool public canArtistOverride;
bool public canSignerOverride;
uint public artistUpdateDelay;
uint public artistUpdateUntil;
uint public signerUpdateDelay;
uint public signerUpdateUntil;
mapping(bytes32 => bool) private usedDigests;
string public baseTokenURI;
mapping (uint256 => bool) public userUpdated;
mapping (uint256 => bool) public artistUpdated;
mapping (uint256 => bool) public signerUpdated;
mapping (uint256 => string) public updatedTokenUri;
uint96 public royalty;
uint public feePercent;
uint public mintReserve;
address public beneficiary;
string public osImage;
string public osBanner;
string public osDescription;
string public osExternalLink;
string osContractUri; //failsafe
uint constant PERCENT_BASE = 10000;
FactoryCC factory;
event MetadataUpdate(
uint tokenId
);
event UpdateTokenURI (
uint indexed tokenId,
address indexed updater,
bytes signData,
string tokenUri
);
function initialize(CreateNFT memory _createNFT, bytes memory _signData, FactoryCC _factory, address _owner) public initializer {
}
function _isOwner() internal view returns(bool) {
}
function _onlyOwner() internal view {
}
function _isSigner() internal view returns(bool) {
}
function _updated(uint tokenId) internal view returns(bool) {
}
function _inSignerRange(uint tokenId) internal view returns(bool) {
}
function _beforeSignerEnd(uint tokenId) internal view returns(bool) {
}
function _inArtistRange(uint tokenId) internal view returns(bool) {
}
function _beforeArtistEnd(uint tokenId) internal view returns(bool) {
}
function _minted(uint tokenId) internal view returns (bool) {
}
function updateTokenURISigner(uint256 tokenId, bytes memory _signData) external {
}
function updateTokenURIArtist(uint256 tokenId, bytes memory _signData) external {
}
function updateTokenURI(uint256 tokenId, bytes memory _signData) external {
require(<FILL_ME>)
_updateTokenURI(tokenId, _signData);
userUpdated[tokenId] = true;
}
function _verifySignature(bytes memory _signData, address addr, uint tokenId) internal returns(string memory tokenUri) {
}
function _updateTokenURI(uint256 tokenId, bytes memory _signData) nonReentrant internal {
}
function contractURI() public view returns (string memory) {
}
function _generateJson() internal view returns (string memory) {
}
function setContractURI(string memory _description, string memory _externalLink, string memory _image, string memory _banner, string memory _contractUri) external {
}
function tokenURI(uint256 tokenId) override public view returns (string memory) {
}
function mint(uint256 amount) payable external {
}
function mintOwner(uint256 amount) payable external {
}
function mintPref(uint256 amount, address erc721) payable external {
}
function mintDiscount(uint256 amount, address erc721) payable external {
}
function _mint(uint256 amount, uint256 thePrice) internal nonReentrant {
}
function _mintOwner(uint256 amount, uint256 thePrice) internal nonReentrant {
}
function _mintToken() internal returns(uint256 tokenId) {
}
function _getRandomValue(uint256 tokenId) internal view returns(uint256) {
}
function _owns(address erc721, address _owner) internal view returns(bool) {
}
function _ownsToken(uint tokenId) internal view returns(bool) {
}
function setBeneficiary(address _beneficiary) external {
}
function setRoyalty(uint _royalty) external {
}
function setDiscount(address erc721, uint256 discount) external {
}
function unpause() external {
}
function pause() external {
}
function unpausePref() external {
}
function pausePref() external {
}
function setPref(address _pref, uint amount) external {
}
function getPrefs() external view returns (address[] memory) {
}
function getDiscounts() external view returns (address[] memory) {
}
uint[] public rangeEnds;
uint[] public rangeStarts;
int[] public rangePrices;
function enableXTransferTokenRanges(uint[] memory _starts, uint[] memory _ends, int[] memory _prices) external {
}
function _isInRange(uint x) internal view returns(int) {
}
function xTransferPrice(uint tokenId) external view returns(int) {
}
function xTransferToken(uint tokenId, bytes memory _transferData) nonReentrant payable external {
}
//function xReturnToken(uint tokenId, bytes memory _returnData) payable external {
// require(ownerOf(tokenId) == address(this), '!own');
// uint _fee = factory.utils().verifyXReturnData(_returnData, address(this), tokenId, factory.signer());
// require(msg.value == _fee, '!fee');
// if (_fee > 0)
// _send(factory.feeAddress(), _fee);
// IERC721Upgradeable(this).safeTransferFrom(address(this), _msgSender(), tokenId);
//}
function setOpenUntil(uint _openUntil) external {
}
function _refundReserve(uint256 tokenId) internal {
}
function _getBeneficiary() internal view returns(address) {
}
function _sendEth(uint256 eth, uint _feePercent) internal {
}
function _send(address dest, uint eth) internal {
}
function setPrice(uint256 _price) external {
}
function burn(uint256 amount) external {
}
//I'm a erc721 receiver too, but I only want my tokens
function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external override returns (bytes4) {
}
// Supports eip-4906
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721EnumerableUpgradeable, ERC2981Upgradeable) returns (bool) {
}
// Protect royalties
function setApprovalForAll(address operator, bool approved) public override(ERC721Upgradeable, IERC721Upgradeable) onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public override(ERC721Upgradeable, IERC721Upgradeable) onlyAllowedOperatorApproval(operator) {
}
event CCTransfer (
address indexed from,
address indexed to,
uint indexed tokenId
);
function _emitTransfer(address from, address to, uint tokenId) internal {
}
function transferFrom(address from, address to, uint256 tokenId) public override(ERC721Upgradeable, IERC721Upgradeable) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override(ERC721Upgradeable, IERC721Upgradeable) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public override(ERC721Upgradeable, IERC721Upgradeable) onlyAllowedOperator(from) {
}
}
| canUserUpdate&&_ownsToken(tokenId)&&!_updated(tokenId),'!userupd' | 465,519 | canUserUpdate&&_ownsToken(tokenId)&&!_updated(tokenId) |
'invdig' | // SPDX-License-Identifier: UNLICENSED
pragma solidity >=0.8.0;
pragma experimental ABIEncoderV2;
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/CountersUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/structs/EnumerableSetUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC721/extensions/ERC721EnumerableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/common/ERC2981Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "./FactoryCC.sol";
import "./Utils.sol";
import "./Base64.sol";
import "operator-filter-registry/src/upgradeable/DefaultOperatorFiltererUpgradeable.sol";
contract ERC721CC is ERC721EnumerableUpgradeable, OwnableUpgradeable, DefaultOperatorFiltererUpgradeable, ERC2981Upgradeable, ReentrancyGuardUpgradeable, IERC721ReceiverUpgradeable {
using ECDSA for bytes32;
using CountersUpgradeable for CountersUpgradeable.Counter;
using EnumerableSetUpgradeable for EnumerableSetUpgradeable.AddressSet;
CountersUpgradeable.Counter private _tokenIds;
uint256 public price;
uint256 public maxMint;
uint256 public maxTotal;
uint256 public openStart;
uint256 public openUntil;
mapping(address => uint256) public discounts;
EnumerableSetUpgradeable.AddressSet private discountsSet;
mapping(address => uint256) public prefs;
EnumerableSetUpgradeable.AddressSet private prefsSet;
bool public paused;
bool public pausedPref;
mapping (uint256 => uint256) public seeds;
mapping (uint256 => uint256) public minted;
mapping (uint256 => uint256) public reserves;
bool public canUserUpdate;
bool public canSignerUpdate;
bool public canArtistUpdate;
bool public canArtistOverride;
bool public canSignerOverride;
uint public artistUpdateDelay;
uint public artistUpdateUntil;
uint public signerUpdateDelay;
uint public signerUpdateUntil;
mapping(bytes32 => bool) private usedDigests;
string public baseTokenURI;
mapping (uint256 => bool) public userUpdated;
mapping (uint256 => bool) public artistUpdated;
mapping (uint256 => bool) public signerUpdated;
mapping (uint256 => string) public updatedTokenUri;
uint96 public royalty;
uint public feePercent;
uint public mintReserve;
address public beneficiary;
string public osImage;
string public osBanner;
string public osDescription;
string public osExternalLink;
string osContractUri; //failsafe
uint constant PERCENT_BASE = 10000;
FactoryCC factory;
event MetadataUpdate(
uint tokenId
);
event UpdateTokenURI (
uint indexed tokenId,
address indexed updater,
bytes signData,
string tokenUri
);
function initialize(CreateNFT memory _createNFT, bytes memory _signData, FactoryCC _factory, address _owner) public initializer {
}
function _isOwner() internal view returns(bool) {
}
function _onlyOwner() internal view {
}
function _isSigner() internal view returns(bool) {
}
function _updated(uint tokenId) internal view returns(bool) {
}
function _inSignerRange(uint tokenId) internal view returns(bool) {
}
function _beforeSignerEnd(uint tokenId) internal view returns(bool) {
}
function _inArtistRange(uint tokenId) internal view returns(bool) {
}
function _beforeArtistEnd(uint tokenId) internal view returns(bool) {
}
function _minted(uint tokenId) internal view returns (bool) {
}
function updateTokenURISigner(uint256 tokenId, bytes memory _signData) external {
}
function updateTokenURIArtist(uint256 tokenId, bytes memory _signData) external {
}
function updateTokenURI(uint256 tokenId, bytes memory _signData) external {
}
function _verifySignature(bytes memory _signData, address addr, uint tokenId) internal returns(string memory tokenUri) {
bytes32 _signedHash;
(, _signedHash, tokenUri) = factory.utils().verifySignatureData(_signData, addr, tokenId, factory.signer());
require(<FILL_ME>)
usedDigests[_signedHash] = true;
return tokenUri;
}
function _updateTokenURI(uint256 tokenId, bytes memory _signData) nonReentrant internal {
}
function contractURI() public view returns (string memory) {
}
function _generateJson() internal view returns (string memory) {
}
function setContractURI(string memory _description, string memory _externalLink, string memory _image, string memory _banner, string memory _contractUri) external {
}
function tokenURI(uint256 tokenId) override public view returns (string memory) {
}
function mint(uint256 amount) payable external {
}
function mintOwner(uint256 amount) payable external {
}
function mintPref(uint256 amount, address erc721) payable external {
}
function mintDiscount(uint256 amount, address erc721) payable external {
}
function _mint(uint256 amount, uint256 thePrice) internal nonReentrant {
}
function _mintOwner(uint256 amount, uint256 thePrice) internal nonReentrant {
}
function _mintToken() internal returns(uint256 tokenId) {
}
function _getRandomValue(uint256 tokenId) internal view returns(uint256) {
}
function _owns(address erc721, address _owner) internal view returns(bool) {
}
function _ownsToken(uint tokenId) internal view returns(bool) {
}
function setBeneficiary(address _beneficiary) external {
}
function setRoyalty(uint _royalty) external {
}
function setDiscount(address erc721, uint256 discount) external {
}
function unpause() external {
}
function pause() external {
}
function unpausePref() external {
}
function pausePref() external {
}
function setPref(address _pref, uint amount) external {
}
function getPrefs() external view returns (address[] memory) {
}
function getDiscounts() external view returns (address[] memory) {
}
uint[] public rangeEnds;
uint[] public rangeStarts;
int[] public rangePrices;
function enableXTransferTokenRanges(uint[] memory _starts, uint[] memory _ends, int[] memory _prices) external {
}
function _isInRange(uint x) internal view returns(int) {
}
function xTransferPrice(uint tokenId) external view returns(int) {
}
function xTransferToken(uint tokenId, bytes memory _transferData) nonReentrant payable external {
}
//function xReturnToken(uint tokenId, bytes memory _returnData) payable external {
// require(ownerOf(tokenId) == address(this), '!own');
// uint _fee = factory.utils().verifyXReturnData(_returnData, address(this), tokenId, factory.signer());
// require(msg.value == _fee, '!fee');
// if (_fee > 0)
// _send(factory.feeAddress(), _fee);
// IERC721Upgradeable(this).safeTransferFrom(address(this), _msgSender(), tokenId);
//}
function setOpenUntil(uint _openUntil) external {
}
function _refundReserve(uint256 tokenId) internal {
}
function _getBeneficiary() internal view returns(address) {
}
function _sendEth(uint256 eth, uint _feePercent) internal {
}
function _send(address dest, uint eth) internal {
}
function setPrice(uint256 _price) external {
}
function burn(uint256 amount) external {
}
//I'm a erc721 receiver too, but I only want my tokens
function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external override returns (bytes4) {
}
// Supports eip-4906
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721EnumerableUpgradeable, ERC2981Upgradeable) returns (bool) {
}
// Protect royalties
function setApprovalForAll(address operator, bool approved) public override(ERC721Upgradeable, IERC721Upgradeable) onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public override(ERC721Upgradeable, IERC721Upgradeable) onlyAllowedOperatorApproval(operator) {
}
event CCTransfer (
address indexed from,
address indexed to,
uint indexed tokenId
);
function _emitTransfer(address from, address to, uint tokenId) internal {
}
function transferFrom(address from, address to, uint256 tokenId) public override(ERC721Upgradeable, IERC721Upgradeable) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override(ERC721Upgradeable, IERC721Upgradeable) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public override(ERC721Upgradeable, IERC721Upgradeable) onlyAllowedOperator(from) {
}
}
| !usedDigests[_signedHash],'invdig' | 465,519 | !usedDigests[_signedHash] |
'!owner' | // SPDX-License-Identifier: UNLICENSED
pragma solidity >=0.8.0;
pragma experimental ABIEncoderV2;
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/CountersUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/structs/EnumerableSetUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC721/extensions/ERC721EnumerableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/common/ERC2981Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "./FactoryCC.sol";
import "./Utils.sol";
import "./Base64.sol";
import "operator-filter-registry/src/upgradeable/DefaultOperatorFiltererUpgradeable.sol";
contract ERC721CC is ERC721EnumerableUpgradeable, OwnableUpgradeable, DefaultOperatorFiltererUpgradeable, ERC2981Upgradeable, ReentrancyGuardUpgradeable, IERC721ReceiverUpgradeable {
using ECDSA for bytes32;
using CountersUpgradeable for CountersUpgradeable.Counter;
using EnumerableSetUpgradeable for EnumerableSetUpgradeable.AddressSet;
CountersUpgradeable.Counter private _tokenIds;
uint256 public price;
uint256 public maxMint;
uint256 public maxTotal;
uint256 public openStart;
uint256 public openUntil;
mapping(address => uint256) public discounts;
EnumerableSetUpgradeable.AddressSet private discountsSet;
mapping(address => uint256) public prefs;
EnumerableSetUpgradeable.AddressSet private prefsSet;
bool public paused;
bool public pausedPref;
mapping (uint256 => uint256) public seeds;
mapping (uint256 => uint256) public minted;
mapping (uint256 => uint256) public reserves;
bool public canUserUpdate;
bool public canSignerUpdate;
bool public canArtistUpdate;
bool public canArtistOverride;
bool public canSignerOverride;
uint public artistUpdateDelay;
uint public artistUpdateUntil;
uint public signerUpdateDelay;
uint public signerUpdateUntil;
mapping(bytes32 => bool) private usedDigests;
string public baseTokenURI;
mapping (uint256 => bool) public userUpdated;
mapping (uint256 => bool) public artistUpdated;
mapping (uint256 => bool) public signerUpdated;
mapping (uint256 => string) public updatedTokenUri;
uint96 public royalty;
uint public feePercent;
uint public mintReserve;
address public beneficiary;
string public osImage;
string public osBanner;
string public osDescription;
string public osExternalLink;
string osContractUri; //failsafe
uint constant PERCENT_BASE = 10000;
FactoryCC factory;
event MetadataUpdate(
uint tokenId
);
event UpdateTokenURI (
uint indexed tokenId,
address indexed updater,
bytes signData,
string tokenUri
);
function initialize(CreateNFT memory _createNFT, bytes memory _signData, FactoryCC _factory, address _owner) public initializer {
}
function _isOwner() internal view returns(bool) {
}
function _onlyOwner() internal view {
}
function _isSigner() internal view returns(bool) {
}
function _updated(uint tokenId) internal view returns(bool) {
}
function _inSignerRange(uint tokenId) internal view returns(bool) {
}
function _beforeSignerEnd(uint tokenId) internal view returns(bool) {
}
function _inArtistRange(uint tokenId) internal view returns(bool) {
}
function _beforeArtistEnd(uint tokenId) internal view returns(bool) {
}
function _minted(uint tokenId) internal view returns (bool) {
}
function updateTokenURISigner(uint256 tokenId, bytes memory _signData) external {
}
function updateTokenURIArtist(uint256 tokenId, bytes memory _signData) external {
}
function updateTokenURI(uint256 tokenId, bytes memory _signData) external {
}
function _verifySignature(bytes memory _signData, address addr, uint tokenId) internal returns(string memory tokenUri) {
}
function _updateTokenURI(uint256 tokenId, bytes memory _signData) nonReentrant internal {
}
function contractURI() public view returns (string memory) {
}
function _generateJson() internal view returns (string memory) {
}
function setContractURI(string memory _description, string memory _externalLink, string memory _image, string memory _banner, string memory _contractUri) external {
}
function tokenURI(uint256 tokenId) override public view returns (string memory) {
}
function mint(uint256 amount) payable external {
}
function mintOwner(uint256 amount) payable external {
}
function mintPref(uint256 amount, address erc721) payable external {
require(pausedPref == false || paused == false, 'paused');
uint remaining = prefs[erc721];
require(remaining >= amount, '!remaining');
require(<FILL_ME>)
uint256 discount = discounts[erc721];
if (discount > price)
discount = price;
uint _price = discount > 0 ? discount : price;
_mint(amount, _price);
prefs[erc721] = remaining - amount;
}
function mintDiscount(uint256 amount, address erc721) payable external {
}
function _mint(uint256 amount, uint256 thePrice) internal nonReentrant {
}
function _mintOwner(uint256 amount, uint256 thePrice) internal nonReentrant {
}
function _mintToken() internal returns(uint256 tokenId) {
}
function _getRandomValue(uint256 tokenId) internal view returns(uint256) {
}
function _owns(address erc721, address _owner) internal view returns(bool) {
}
function _ownsToken(uint tokenId) internal view returns(bool) {
}
function setBeneficiary(address _beneficiary) external {
}
function setRoyalty(uint _royalty) external {
}
function setDiscount(address erc721, uint256 discount) external {
}
function unpause() external {
}
function pause() external {
}
function unpausePref() external {
}
function pausePref() external {
}
function setPref(address _pref, uint amount) external {
}
function getPrefs() external view returns (address[] memory) {
}
function getDiscounts() external view returns (address[] memory) {
}
uint[] public rangeEnds;
uint[] public rangeStarts;
int[] public rangePrices;
function enableXTransferTokenRanges(uint[] memory _starts, uint[] memory _ends, int[] memory _prices) external {
}
function _isInRange(uint x) internal view returns(int) {
}
function xTransferPrice(uint tokenId) external view returns(int) {
}
function xTransferToken(uint tokenId, bytes memory _transferData) nonReentrant payable external {
}
//function xReturnToken(uint tokenId, bytes memory _returnData) payable external {
// require(ownerOf(tokenId) == address(this), '!own');
// uint _fee = factory.utils().verifyXReturnData(_returnData, address(this), tokenId, factory.signer());
// require(msg.value == _fee, '!fee');
// if (_fee > 0)
// _send(factory.feeAddress(), _fee);
// IERC721Upgradeable(this).safeTransferFrom(address(this), _msgSender(), tokenId);
//}
function setOpenUntil(uint _openUntil) external {
}
function _refundReserve(uint256 tokenId) internal {
}
function _getBeneficiary() internal view returns(address) {
}
function _sendEth(uint256 eth, uint _feePercent) internal {
}
function _send(address dest, uint eth) internal {
}
function setPrice(uint256 _price) external {
}
function burn(uint256 amount) external {
}
//I'm a erc721 receiver too, but I only want my tokens
function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external override returns (bytes4) {
}
// Supports eip-4906
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721EnumerableUpgradeable, ERC2981Upgradeable) returns (bool) {
}
// Protect royalties
function setApprovalForAll(address operator, bool approved) public override(ERC721Upgradeable, IERC721Upgradeable) onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public override(ERC721Upgradeable, IERC721Upgradeable) onlyAllowedOperatorApproval(operator) {
}
event CCTransfer (
address indexed from,
address indexed to,
uint indexed tokenId
);
function _emitTransfer(address from, address to, uint tokenId) internal {
}
function transferFrom(address from, address to, uint256 tokenId) public override(ERC721Upgradeable, IERC721Upgradeable) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override(ERC721Upgradeable, IERC721Upgradeable) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public override(ERC721Upgradeable, IERC721Upgradeable) onlyAllowedOperator(from) {
}
}
| _owns(erc721,_msgSender()),'!owner' | 465,519 | _owns(erc721,_msgSender()) |
"Presale: token is the zero address" | pragma solidity ^0.8.18;
contract Presale is Vesting {
using SafeMath for uint256;
using SafeERC20 for IERC20;
uint256 public tokensSold;
struct WhiteListed {
bool exists;
}
mapping(address => WhiteListed) public _isWhitelisted;
// The token being sold
uint256 public totalSupply = 1777777777 * 10 ** 18; //do we need this, aur would mint
IERC20 private _token; // PMDG
IERC20 private _usdc;
IERC20 private _usdt;
AggregatorV3Interface internal priceFeedEth;
AggregatorV3Interface internal priceFeedUsdc;
AggregatorV3Interface internal priceFeedUsdt;
// Address where funds are collected
address payable private _wallet;
uint256 private _rate = 378787878787878;
// Amount raised
uint256 private _weiRaised;
uint256 private _usdcRaised;
uint256 private _usdtRaised;
bool private _finalized = false;
mapping(address => uint256) public tokenBought;
uint256 public totalHolder;
address[] public holders;
// =============================================================
// Event
// =============================================================
/**
* Event for token purchase logging
* @param purchaser who paid for the tokens
* @param value weis paid for purchase
* @param beneficiary who paid for purchase
* @param amount amount of tokens purchased
*/
event TokensPurchasedFromEth(
address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount
);
event TokensPurchasedFromUsdt(
address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount
);
event TokensPurchasedFromUsdc(
address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount
);
// =============================================================
// Constructor
// =============================================================
constructor(
address payable __wallet,
address __token,
IERC20 __usdc,
IERC20 __usdt
) Vesting(__token) {
require(__wallet != address(0), "Presale: wallet is the zero address");
require(<FILL_ME>)
_wallet = __wallet;
_token = IERC20(__token);
_usdc = __usdc;
_usdt = __usdt;
// ETH / USD
priceFeedEth = AggregatorV3Interface(
0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419
// 0xD4a33860578De61DBAbDc8BFdb98FD742fA7028e //goerli
// 0x694AA1769357215DE4FAC081bf1f309aDC325306 //sepolia
);
// USDC / USD
priceFeedUsdc = AggregatorV3Interface(
0x8fFfFfd4AfB6115b954Bd326cbe7B4BA576818f6
// 0xAb5c49580294Aff77670F839ea425f5b78ab3Ae7 //goerli
//0xA2F78ab2355fe2f984D808B5CeE7FD0A93D5270E //sepolia
);
// USDT / USD
priceFeedUsdt = AggregatorV3Interface(
0x3E7d1eAB13ad0104d2750B8863b489D65364e32D
// 0xA2F78ab2355fe2f984D808B5CeE7FD0A93D5270E // dummy for test
);
// 0x3E7d1eAB13ad0104d2750B8863b489D65364e32D mainnet
// not avaiable//goerli
// not avaiable//sepolia
}
/**
* ******************************
* Buy Tokens Functions
* ******************************
*/
/**
* @dev low level token purchase ***DO NOT OVERRIDE***
* This function has a non-reentrancy guard, so it shouldn't be called by
* another `nonReentrant` function.
* @param beneficiary Recipient of the token purchase
*/
function buyTokensFromEth(address beneficiary) public payable nonReentrant {
}
function buyTokensFromUsdc(
address beneficiary,
uint256 amount
) public nonReentrant {
}
function buyTokensFromUsdt(
address beneficiary,
uint256 amount
) public nonReentrant {
}
/**
* ******************************
* Helper Function
* ******************************
*/
/**
* @dev Validation of an incoming purchase. Use require statements to revert state when conditions are not met.
* Use `super` in contracts that inherit from Crowdsale to extend their validations.
* Example from CappedCrowdsale.sol's _preValidatePurchase method:
* super._preValidatePurchase(beneficiary, weiAmount);
* require(weiRaised().add(weiAmount) <= cap);
* @param beneficiary Address performing the token purchase
* @param weiAmount Value in wei involved in the purchase
*/
function _preValidatePurchase(
address beneficiary,
uint256 weiAmount
) internal view {
}
/**
* @dev Override to extend the way in which ether is converted to tokens.
* @param weiAmount Value in wei to be converted into tokens
* @return Number of tokens that can be purchased with the specified _weiAmount
*/
function _getTokenFromEth(
uint256 weiAmount // 1* 10**18
) internal view returns (uint256) {
}
function _getTokenFromUsdc(
uint256 amount //1* 10**6
) internal view returns (uint256 tokenAmount) {
}
function _getTokenFromUsdt(
uint256 amount //1* 10**6
) internal view returns (uint256 tokenAmount) {
}
/**
* @dev fallback function ***DO NOT OVERRIDE***
* Note that other contracts will transfer funds with a base gas stipend
* of 2300, which is not enough to call buyTokens. Consider calling
* buyTokens directly when purchasing tokens from a contract.
*/
receive() external payable {
}
// =============================================================
// Getters
// =============================================================
/**
* @return the token being sold.
*/
function token() public view returns (IERC20) {
}
/**
* @return the address where funds are collected.
*/
function wallet() public view returns (address payable) {
}
/**
* @return the number of token units a buyer gets per wei.
*/
function rate() public view returns (uint256) {
}
function isFinalized() public view returns (bool) {
}
/**
* @return the amount of wei raised.
*/
function weiRaised() public view returns (uint256) {
}
function usdcRaised() public view returns (uint256) {
}
function usdtRaised() public view returns (uint256) {
}
function getLatestPriceEth() public view returns (int) {
}
function getLatestPriceUsdc() public view returns (int) {
}
function getLatestPriceUsdt() public view returns (int) {
}
// =============================================================
// Setter
// =============================================================
function finalizePresale(bool status) external onlyOwner {
}
function setWallet(address payable newWallet) external onlyOwner {
}
function setRate(uint256 newRate) public onlyOwner {
}
}
| address(__token)!=address(0),"Presale: token is the zero address" | 465,613 | address(__token)!=address(0) |
"USDC Transfer Failed" | pragma solidity ^0.8.18;
contract Presale is Vesting {
using SafeMath for uint256;
using SafeERC20 for IERC20;
uint256 public tokensSold;
struct WhiteListed {
bool exists;
}
mapping(address => WhiteListed) public _isWhitelisted;
// The token being sold
uint256 public totalSupply = 1777777777 * 10 ** 18; //do we need this, aur would mint
IERC20 private _token; // PMDG
IERC20 private _usdc;
IERC20 private _usdt;
AggregatorV3Interface internal priceFeedEth;
AggregatorV3Interface internal priceFeedUsdc;
AggregatorV3Interface internal priceFeedUsdt;
// Address where funds are collected
address payable private _wallet;
uint256 private _rate = 378787878787878;
// Amount raised
uint256 private _weiRaised;
uint256 private _usdcRaised;
uint256 private _usdtRaised;
bool private _finalized = false;
mapping(address => uint256) public tokenBought;
uint256 public totalHolder;
address[] public holders;
// =============================================================
// Event
// =============================================================
/**
* Event for token purchase logging
* @param purchaser who paid for the tokens
* @param value weis paid for purchase
* @param beneficiary who paid for purchase
* @param amount amount of tokens purchased
*/
event TokensPurchasedFromEth(
address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount
);
event TokensPurchasedFromUsdt(
address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount
);
event TokensPurchasedFromUsdc(
address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount
);
// =============================================================
// Constructor
// =============================================================
constructor(
address payable __wallet,
address __token,
IERC20 __usdc,
IERC20 __usdt
) Vesting(__token) {
}
/**
* ******************************
* Buy Tokens Functions
* ******************************
*/
/**
* @dev low level token purchase ***DO NOT OVERRIDE***
* This function has a non-reentrancy guard, so it shouldn't be called by
* another `nonReentrant` function.
* @param beneficiary Recipient of the token purchase
*/
function buyTokensFromEth(address beneficiary) public payable nonReentrant {
}
function buyTokensFromUsdc(
address beneficiary,
uint256 amount
) public nonReentrant {
_preValidatePurchase(beneficiary, amount);
require(<FILL_ME>)
// calculate token amount to be created
uint256 tokens = _getTokenFromUsdc(amount);
// update state
_usdcRaised = _usdcRaised.add(amount);
tokenBought[beneficiary] += tokens;
createVestingSchedule(beneficiary, tokens);
tokensSold = tokensSold + tokens;
if (!_isWhitelisted[beneficiary].exists) {
_isWhitelisted[beneficiary].exists = true;
totalHolder = totalHolder + 1;
holders.push(beneficiary);
}
// ********************************
emit TokensPurchasedFromUsdc(_msgSender(), beneficiary, amount, tokens);
}
function buyTokensFromUsdt(
address beneficiary,
uint256 amount
) public nonReentrant {
}
/**
* ******************************
* Helper Function
* ******************************
*/
/**
* @dev Validation of an incoming purchase. Use require statements to revert state when conditions are not met.
* Use `super` in contracts that inherit from Crowdsale to extend their validations.
* Example from CappedCrowdsale.sol's _preValidatePurchase method:
* super._preValidatePurchase(beneficiary, weiAmount);
* require(weiRaised().add(weiAmount) <= cap);
* @param beneficiary Address performing the token purchase
* @param weiAmount Value in wei involved in the purchase
*/
function _preValidatePurchase(
address beneficiary,
uint256 weiAmount
) internal view {
}
/**
* @dev Override to extend the way in which ether is converted to tokens.
* @param weiAmount Value in wei to be converted into tokens
* @return Number of tokens that can be purchased with the specified _weiAmount
*/
function _getTokenFromEth(
uint256 weiAmount // 1* 10**18
) internal view returns (uint256) {
}
function _getTokenFromUsdc(
uint256 amount //1* 10**6
) internal view returns (uint256 tokenAmount) {
}
function _getTokenFromUsdt(
uint256 amount //1* 10**6
) internal view returns (uint256 tokenAmount) {
}
/**
* @dev fallback function ***DO NOT OVERRIDE***
* Note that other contracts will transfer funds with a base gas stipend
* of 2300, which is not enough to call buyTokens. Consider calling
* buyTokens directly when purchasing tokens from a contract.
*/
receive() external payable {
}
// =============================================================
// Getters
// =============================================================
/**
* @return the token being sold.
*/
function token() public view returns (IERC20) {
}
/**
* @return the address where funds are collected.
*/
function wallet() public view returns (address payable) {
}
/**
* @return the number of token units a buyer gets per wei.
*/
function rate() public view returns (uint256) {
}
function isFinalized() public view returns (bool) {
}
/**
* @return the amount of wei raised.
*/
function weiRaised() public view returns (uint256) {
}
function usdcRaised() public view returns (uint256) {
}
function usdtRaised() public view returns (uint256) {
}
function getLatestPriceEth() public view returns (int) {
}
function getLatestPriceUsdc() public view returns (int) {
}
function getLatestPriceUsdt() public view returns (int) {
}
// =============================================================
// Setter
// =============================================================
function finalizePresale(bool status) external onlyOwner {
}
function setWallet(address payable newWallet) external onlyOwner {
}
function setRate(uint256 newRate) public onlyOwner {
}
}
| _usdc.transferFrom(beneficiary,_wallet,amount),"USDC Transfer Failed" | 465,613 | _usdc.transferFrom(beneficiary,_wallet,amount) |
"USDT Transfer Failed" | pragma solidity ^0.8.18;
contract Presale is Vesting {
using SafeMath for uint256;
using SafeERC20 for IERC20;
uint256 public tokensSold;
struct WhiteListed {
bool exists;
}
mapping(address => WhiteListed) public _isWhitelisted;
// The token being sold
uint256 public totalSupply = 1777777777 * 10 ** 18; //do we need this, aur would mint
IERC20 private _token; // PMDG
IERC20 private _usdc;
IERC20 private _usdt;
AggregatorV3Interface internal priceFeedEth;
AggregatorV3Interface internal priceFeedUsdc;
AggregatorV3Interface internal priceFeedUsdt;
// Address where funds are collected
address payable private _wallet;
uint256 private _rate = 378787878787878;
// Amount raised
uint256 private _weiRaised;
uint256 private _usdcRaised;
uint256 private _usdtRaised;
bool private _finalized = false;
mapping(address => uint256) public tokenBought;
uint256 public totalHolder;
address[] public holders;
// =============================================================
// Event
// =============================================================
/**
* Event for token purchase logging
* @param purchaser who paid for the tokens
* @param value weis paid for purchase
* @param beneficiary who paid for purchase
* @param amount amount of tokens purchased
*/
event TokensPurchasedFromEth(
address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount
);
event TokensPurchasedFromUsdt(
address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount
);
event TokensPurchasedFromUsdc(
address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount
);
// =============================================================
// Constructor
// =============================================================
constructor(
address payable __wallet,
address __token,
IERC20 __usdc,
IERC20 __usdt
) Vesting(__token) {
}
/**
* ******************************
* Buy Tokens Functions
* ******************************
*/
/**
* @dev low level token purchase ***DO NOT OVERRIDE***
* This function has a non-reentrancy guard, so it shouldn't be called by
* another `nonReentrant` function.
* @param beneficiary Recipient of the token purchase
*/
function buyTokensFromEth(address beneficiary) public payable nonReentrant {
}
function buyTokensFromUsdc(
address beneficiary,
uint256 amount
) public nonReentrant {
}
function buyTokensFromUsdt(
address beneficiary,
uint256 amount
) public nonReentrant {
_preValidatePurchase(beneficiary, amount);
require(<FILL_ME>)
// calculate token amount to be created
uint256 tokens = _getTokenFromUsdt(amount);
// update state
_usdtRaised = _usdtRaised.add(amount);
tokenBought[beneficiary] += tokens;
createVestingSchedule(beneficiary, tokens);
tokensSold = tokensSold + tokens;
if (!_isWhitelisted[beneficiary].exists) {
_isWhitelisted[beneficiary].exists = true;
totalHolder = totalHolder + 1;
holders.push(beneficiary);
}
// ********************************
emit TokensPurchasedFromUsdt(_msgSender(), beneficiary, amount, tokens);
}
/**
* ******************************
* Helper Function
* ******************************
*/
/**
* @dev Validation of an incoming purchase. Use require statements to revert state when conditions are not met.
* Use `super` in contracts that inherit from Crowdsale to extend their validations.
* Example from CappedCrowdsale.sol's _preValidatePurchase method:
* super._preValidatePurchase(beneficiary, weiAmount);
* require(weiRaised().add(weiAmount) <= cap);
* @param beneficiary Address performing the token purchase
* @param weiAmount Value in wei involved in the purchase
*/
function _preValidatePurchase(
address beneficiary,
uint256 weiAmount
) internal view {
}
/**
* @dev Override to extend the way in which ether is converted to tokens.
* @param weiAmount Value in wei to be converted into tokens
* @return Number of tokens that can be purchased with the specified _weiAmount
*/
function _getTokenFromEth(
uint256 weiAmount // 1* 10**18
) internal view returns (uint256) {
}
function _getTokenFromUsdc(
uint256 amount //1* 10**6
) internal view returns (uint256 tokenAmount) {
}
function _getTokenFromUsdt(
uint256 amount //1* 10**6
) internal view returns (uint256 tokenAmount) {
}
/**
* @dev fallback function ***DO NOT OVERRIDE***
* Note that other contracts will transfer funds with a base gas stipend
* of 2300, which is not enough to call buyTokens. Consider calling
* buyTokens directly when purchasing tokens from a contract.
*/
receive() external payable {
}
// =============================================================
// Getters
// =============================================================
/**
* @return the token being sold.
*/
function token() public view returns (IERC20) {
}
/**
* @return the address where funds are collected.
*/
function wallet() public view returns (address payable) {
}
/**
* @return the number of token units a buyer gets per wei.
*/
function rate() public view returns (uint256) {
}
function isFinalized() public view returns (bool) {
}
/**
* @return the amount of wei raised.
*/
function weiRaised() public view returns (uint256) {
}
function usdcRaised() public view returns (uint256) {
}
function usdtRaised() public view returns (uint256) {
}
function getLatestPriceEth() public view returns (int) {
}
function getLatestPriceUsdc() public view returns (int) {
}
function getLatestPriceUsdt() public view returns (int) {
}
// =============================================================
// Setter
// =============================================================
function finalizePresale(bool status) external onlyOwner {
}
function setWallet(address payable newWallet) external onlyOwner {
}
function setRate(uint256 newRate) public onlyOwner {
}
}
| _usdt.transferFrom(beneficiary,_wallet,amount),"USDT Transfer Failed" | 465,613 | _usdt.transferFrom(beneficiary,_wallet,amount) |
"Crowdsale: address already whitelisted" | pragma solidity ^0.8.18;
contract Presale is Vesting {
using SafeMath for uint256;
using SafeERC20 for IERC20;
uint256 public tokensSold;
struct WhiteListed {
bool exists;
}
mapping(address => WhiteListed) public _isWhitelisted;
// The token being sold
uint256 public totalSupply = 1777777777 * 10 ** 18; //do we need this, aur would mint
IERC20 private _token; // PMDG
IERC20 private _usdc;
IERC20 private _usdt;
AggregatorV3Interface internal priceFeedEth;
AggregatorV3Interface internal priceFeedUsdc;
AggregatorV3Interface internal priceFeedUsdt;
// Address where funds are collected
address payable private _wallet;
uint256 private _rate = 378787878787878;
// Amount raised
uint256 private _weiRaised;
uint256 private _usdcRaised;
uint256 private _usdtRaised;
bool private _finalized = false;
mapping(address => uint256) public tokenBought;
uint256 public totalHolder;
address[] public holders;
// =============================================================
// Event
// =============================================================
/**
* Event for token purchase logging
* @param purchaser who paid for the tokens
* @param value weis paid for purchase
* @param beneficiary who paid for purchase
* @param amount amount of tokens purchased
*/
event TokensPurchasedFromEth(
address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount
);
event TokensPurchasedFromUsdt(
address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount
);
event TokensPurchasedFromUsdc(
address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount
);
// =============================================================
// Constructor
// =============================================================
constructor(
address payable __wallet,
address __token,
IERC20 __usdc,
IERC20 __usdt
) Vesting(__token) {
}
/**
* ******************************
* Buy Tokens Functions
* ******************************
*/
/**
* @dev low level token purchase ***DO NOT OVERRIDE***
* This function has a non-reentrancy guard, so it shouldn't be called by
* another `nonReentrant` function.
* @param beneficiary Recipient of the token purchase
*/
function buyTokensFromEth(address beneficiary) public payable nonReentrant {
}
function buyTokensFromUsdc(
address beneficiary,
uint256 amount
) public nonReentrant {
}
function buyTokensFromUsdt(
address beneficiary,
uint256 amount
) public nonReentrant {
}
/**
* ******************************
* Helper Function
* ******************************
*/
/**
* @dev Validation of an incoming purchase. Use require statements to revert state when conditions are not met.
* Use `super` in contracts that inherit from Crowdsale to extend their validations.
* Example from CappedCrowdsale.sol's _preValidatePurchase method:
* super._preValidatePurchase(beneficiary, weiAmount);
* require(weiRaised().add(weiAmount) <= cap);
* @param beneficiary Address performing the token purchase
* @param weiAmount Value in wei involved in the purchase
*/
function _preValidatePurchase(
address beneficiary,
uint256 weiAmount
) internal view {
require(_rate > 0, "Presale: rate is 0");
require(
beneficiary != address(0),
"Crowdsale: beneficiary is the zero address"
);
require(weiAmount != 0, "Crowdsale: weiAmount is 0");
require(totalSupply > tokensSold, "Crowdsale: PMDG Supply exceed");
require(!_finalized, "Crowdsale Ended");
require(<FILL_ME>)
this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
}
/**
* @dev Override to extend the way in which ether is converted to tokens.
* @param weiAmount Value in wei to be converted into tokens
* @return Number of tokens that can be purchased with the specified _weiAmount
*/
function _getTokenFromEth(
uint256 weiAmount // 1* 10**18
) internal view returns (uint256) {
}
function _getTokenFromUsdc(
uint256 amount //1* 10**6
) internal view returns (uint256 tokenAmount) {
}
function _getTokenFromUsdt(
uint256 amount //1* 10**6
) internal view returns (uint256 tokenAmount) {
}
/**
* @dev fallback function ***DO NOT OVERRIDE***
* Note that other contracts will transfer funds with a base gas stipend
* of 2300, which is not enough to call buyTokens. Consider calling
* buyTokens directly when purchasing tokens from a contract.
*/
receive() external payable {
}
// =============================================================
// Getters
// =============================================================
/**
* @return the token being sold.
*/
function token() public view returns (IERC20) {
}
/**
* @return the address where funds are collected.
*/
function wallet() public view returns (address payable) {
}
/**
* @return the number of token units a buyer gets per wei.
*/
function rate() public view returns (uint256) {
}
function isFinalized() public view returns (bool) {
}
/**
* @return the amount of wei raised.
*/
function weiRaised() public view returns (uint256) {
}
function usdcRaised() public view returns (uint256) {
}
function usdtRaised() public view returns (uint256) {
}
function getLatestPriceEth() public view returns (int) {
}
function getLatestPriceUsdc() public view returns (int) {
}
function getLatestPriceUsdt() public view returns (int) {
}
// =============================================================
// Setter
// =============================================================
function finalizePresale(bool status) external onlyOwner {
}
function setWallet(address payable newWallet) external onlyOwner {
}
function setRate(uint256 newRate) public onlyOwner {
}
}
| !hasClaimed[beneficiary].exists,"Crowdsale: address already whitelisted" | 465,613 | !hasClaimed[beneficiary].exists |
"max NFT per address exceeded" | pragma solidity ^0.8.4;
contract tempus is ERC721A, Ownable {
uint256 public maxMintAmount = 4;
uint256 public nftPerAddressLimit = 40;
uint256 MAX_SUPPLY = 10000;
uint256 public mintRate = 0.05 ether;
bool public paused = true;
bool public revealed = false;
string public baseURI; //ipfs://[FILL THIS OUT WITH CID]/ , don't forget trailing /
string public hiddenURI;
constructor(string memory _initBaseURI, string memory _initHiddenURI) ERC721A("Tempus", "TEMPUS") {
}
//override startTokenID to start at 1 instead of 0
function _startTokenId() internal view virtual override returns (uint256) {
}
function mint(uint256 quantity) external payable {
// _safeMint's second argument now takes in a quantity, not a tokenId.
require(totalSupply() + quantity <= MAX_SUPPLY, "Not enough NFTs left");
if (msg.sender != owner()) {
require(!paused, "the contract is paused");
require(quantity <= maxMintAmount, "Exceeded the mint limit for this session");
require(<FILL_ME>)
require(msg.value >= (mintRate * quantity), "Not enough ether sent");
}
_safeMint(msg.sender, quantity);
}
//AMOUNT MEASURED IN WEI
function withdraw(uint256 amount) external payable onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function setMintRate(uint256 _mintRate) public onlyOwner {
}
function setmaxMintAmount(uint256 _newmaxMintAmount) public onlyOwner {
}
function toggleReveal(bool _revealed) public onlyOwner {
}
function setNftPerAddressLimit(uint256 _limit) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setHiddenURI(string memory _hiddenURI) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId) external view returns (TokenOwnership memory) {
}
}
| _numberMinted(msg.sender)+quantity<=nftPerAddressLimit,"max NFT per address exceeded" | 465,719 | _numberMinted(msg.sender)+quantity<=nftPerAddressLimit |
"Address is not allowlisted" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./lib/ERC721Base.sol";
import "./lib/Signature.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract ArashiContract is ERC721Base, PaymentSplitter, AccessControl, Pausable, ReentrancyGuard, Ownable{
uint256 public constant maxSupply = 1000;
uint256 public constant maxPerTx = 10;
address private signerAddress;
// Pricing
uint256 public publicPrice = 0.01 ether;
uint256 public whitelistPrice = 0.01 ether;
// Phases
mapping(address => uint256) public claimed;
bool public isPublic = false;
bool public isPreMint = false;
constructor(
address[] memory payees,
uint256[] memory shares,
address ownerAddress
) ERC721Base(
"ipfs://QmWMcoyuXMegUhEb5UmHC8UUYA8K5NNXxd7WjZhqVihWQn",
"Arashi",
"ARA",
1000,
ownerAddress,
690
) PaymentSplitter(payees, shares) {
}
// Public Minting Function
function publicMint(uint256 quantity)
external payable
whenNotPaused nonReentrant
{
}
// Whitelist Minting Function
function privateMint(
uint256 quantity,
uint256 maxQuantity,
bytes memory signature
) external payable
whenNotPaused nonReentrant
{
require(isPreMint, "Whitelist mint is not open");
require(quantity > 0, "It Doesn't Allowed to mint zero");
require(totalSupply() + quantity <= maxSupply, "It has reached the maximum minted");
require(msg.value == whitelistPrice * quantity, "Insufficient fund");
require(signerAddress != address(0), "Signer has not set yet");
require(<FILL_ME>)
require(claimed[msg.sender] + quantity <= maxQuantity, "Exceed current max minted");
claimed[msg.sender] += quantity;
_safeMint(msg.sender, quantity);
}
// Airdrop Functions
function airdrop(address wallet, uint256 amount)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function airdrops(address[] calldata wallet, uint256[] calldata amount)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
// MetaData
function setTokenURI(string calldata _uri) external onlyRole(DEFAULT_ADMIN_ROLE){
}
function baseTokenURI() external view returns (string memory) {
}
// Signer
function setSignerAddress(address signer) external onlyRole(DEFAULT_ADMIN_ROLE){
}
// Phases
function setPause(bool pause) external onlyRole(DEFAULT_ADMIN_ROLE){
}
function setPublic(bool value) external onlyRole(DEFAULT_ADMIN_ROLE){
}
function setPreMint(bool value) external onlyRole(DEFAULT_ADMIN_ROLE){
}
// Minting Fee
function setPublicPrice(uint256 amount) external onlyRole(DEFAULT_ADMIN_ROLE){
}
function setWhitelistPrice(uint256 amount) external onlyRole(DEFAULT_ADMIN_ROLE){
}
function claim() external {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721Base, AccessControl) returns (bool) {
}
}
| Signature.verify(maxQuantity,msg.sender,signature)==signerAddress,"Address is not allowlisted" | 465,748 | Signature.verify(maxQuantity,msg.sender,signature)==signerAddress |
"Exceed current max minted" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./lib/ERC721Base.sol";
import "./lib/Signature.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract ArashiContract is ERC721Base, PaymentSplitter, AccessControl, Pausable, ReentrancyGuard, Ownable{
uint256 public constant maxSupply = 1000;
uint256 public constant maxPerTx = 10;
address private signerAddress;
// Pricing
uint256 public publicPrice = 0.01 ether;
uint256 public whitelistPrice = 0.01 ether;
// Phases
mapping(address => uint256) public claimed;
bool public isPublic = false;
bool public isPreMint = false;
constructor(
address[] memory payees,
uint256[] memory shares,
address ownerAddress
) ERC721Base(
"ipfs://QmWMcoyuXMegUhEb5UmHC8UUYA8K5NNXxd7WjZhqVihWQn",
"Arashi",
"ARA",
1000,
ownerAddress,
690
) PaymentSplitter(payees, shares) {
}
// Public Minting Function
function publicMint(uint256 quantity)
external payable
whenNotPaused nonReentrant
{
}
// Whitelist Minting Function
function privateMint(
uint256 quantity,
uint256 maxQuantity,
bytes memory signature
) external payable
whenNotPaused nonReentrant
{
require(isPreMint, "Whitelist mint is not open");
require(quantity > 0, "It Doesn't Allowed to mint zero");
require(totalSupply() + quantity <= maxSupply, "It has reached the maximum minted");
require(msg.value == whitelistPrice * quantity, "Insufficient fund");
require(signerAddress != address(0), "Signer has not set yet");
require(Signature.verify(maxQuantity, msg.sender, signature) == signerAddress, "Address is not allowlisted");
require(<FILL_ME>)
claimed[msg.sender] += quantity;
_safeMint(msg.sender, quantity);
}
// Airdrop Functions
function airdrop(address wallet, uint256 amount)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function airdrops(address[] calldata wallet, uint256[] calldata amount)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
// MetaData
function setTokenURI(string calldata _uri) external onlyRole(DEFAULT_ADMIN_ROLE){
}
function baseTokenURI() external view returns (string memory) {
}
// Signer
function setSignerAddress(address signer) external onlyRole(DEFAULT_ADMIN_ROLE){
}
// Phases
function setPause(bool pause) external onlyRole(DEFAULT_ADMIN_ROLE){
}
function setPublic(bool value) external onlyRole(DEFAULT_ADMIN_ROLE){
}
function setPreMint(bool value) external onlyRole(DEFAULT_ADMIN_ROLE){
}
// Minting Fee
function setPublicPrice(uint256 amount) external onlyRole(DEFAULT_ADMIN_ROLE){
}
function setWhitelistPrice(uint256 amount) external onlyRole(DEFAULT_ADMIN_ROLE){
}
function claim() external {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721Base, AccessControl) returns (bool) {
}
}
| claimed[msg.sender]+quantity<=maxQuantity,"Exceed current max minted" | 465,748 | claimed[msg.sender]+quantity<=maxQuantity |
null | pragma solidity ^0.8.10;
import "./CErc20Delegate.sol";
import "./Accountant/AccountantInterfaces.sol";
import "./Treasury/TreasuryInterfaces.sol";
import "./ErrorReporter.sol";
import "./NoteInterest.sol";
contract CNote is CErc20Delegate {
event AccountantSet(address accountant, address accountantPrior);
error FailedTransfer(uint256 amount);
AccountantInterface public _accountant; // accountant private _accountant = Accountant(address(0));
function setAccountantContract(address accountant_) public {
}
/**
* @dev return the current address of the Accounant
*/
function getAccountant() external view returns (address) {
}
/**
* @dev getCashPrior retrieves balance of the accountant (not cNote contract)
*/
function getCashPrior()
internal
view
virtual
override
returns (uint256)
{
}
function accrueInterest() public virtual override returns (uint256) {
}
/**
* @notice Calculates the exchange rate from Note to cNote
* @dev This function does not accrue efore calculating the exchange rate
* @return calculated exchange rate scaled by 1e18
*/
function exchangeRateStoredInternal()
internal
view
virtual
override
returns (uint256)
{
}
/**
* @dev Similar to EIP20 transfer, except it handles a False result from `transferFrom` and reverts in that case.
* This will revert due to insufficient balance or insufficient allowance.
* This function returns the actual amount received,
* which may be less than `amount` if there is a fee attached to the transfer.
*
* Note: This wrapper safely handles non-standard ERC-20 tokens that do not return a value.
* See here: https://medium.com/coinmonks/missing-return-value-bug-at-least-130-tokens-affected-d67bf08521ca
*/
function doTransferIn(address from, uint256 amount)
internal
virtual
override
returns (uint256)
{
require(<FILL_ME>) //check that the accountant has been set
EIP20Interface token = EIP20Interface(underlying);
token.transferFrom(from, address(this), amount); //allowance set before
//revert if transfer fails
bool success;
assembly {
switch returndatasize()
case 0 {
// This is a non-standard ERC-20
success := not(0) // set success to true
}
case 32 {
// This is a compliant ERC-20
returndatacopy(0, 0, 32)
success := mload(0) // Set `success = returndata` of override external call
}
default {
// This is an excessively non-compliant ERC-20, revert.
revert(0, 0)
}
}
require(success, "CNote::TOKEN_TRANSFER_IN_FAILED");
uint256 balanceAfter = token.balanceOf(address(this)); // Calculate the amount that was *actually* transferred
if (from != address(_accountant)) {
uint256 err = _accountant.redeemMarket(balanceAfter); //Whatever is transferred into cNote is then redeemed by the accountant
if (err != 0) {
revert AccountantSupplyError(balanceAfter);
}
}
return balanceAfter; // underflow already checked above, just subtract
}
/**
* @dev Similar to EIP20 transfer, except it handles a False success from `transfer` and returns an explanatory
* error code rather than reverting. If caller has not called checked protocol's balance, this may revert due to
* insufficient cash held in this contract. If caller has checked protocol's balance prior to this call, and verified
* it is >= amount, this should not revert in normal conditions.
*
* Note: This wrapper safely handles non-standard ERC-20 tokens that do not return a value.
* See here: https://medium.com/coinmonks/missing-return-value-bug-at-least-130-tokens-affected-d67bf08521ca
*/
function doTransferOut(address payable to, uint256 amount)
internal
virtual
override
{
}
/**
* @notice Users borrow assets from the protocol to their own address
* @param borrowAmount The amount of the underlying asset to borrow
*/
function borrowFresh(address payable borrower, uint256 borrowAmount)
internal
override
{
}
/**
* @notice User redeems cTokens in exchange for the underlying asset
* @dev Assumes interest has already been accrued up to the current block
* @param redeemer The address of the account which is redeeming the tokens
* @param redeemTokensIn The number of cTokens to redeem into underlying (only one of redeemTokensIn or redeemAmountIn may be non-zero)
* @param redeemAmountIn The number of underlying tokens to receive from redeeming cTokens (only one of redeemTokensIn or redeemAmountIn may be non-zero)
*/
function redeemFresh(
address payable redeemer,
uint256 redeemTokensIn,
uint256 redeemAmountIn
)
internal
override
{
}
/**
** Reentrancy Guard **
*/
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
*/
modifier nonReentrant() override {
}
}
| address(_accountant)!=address(0) | 465,763 | address(_accountant)!=address(0) |
"Sold Out" | pragma solidity ^0.8.0;
contract TurkeyEgg is ERC721A, Ownable {
using SafeMath for uint256;
using Strings for uint256;
string private _baseUri;
uint256 public PricePublic = 0.05 ether;
uint256 public MaxToken = 10000;
uint256 public TokenIndex = 0;
event TokenMinted(uint256 supply);
constructor() ERC721A("TurkeyEgg", "TRKE") {}
function _baseURI() internal view virtual override returns (string memory) { }
function tokenURI(uint256 tokenId) public view virtual override returns (string memory a) {
}
function mint(uint8 mintAmount) public payable {
require(<FILL_ME>)
require(mintAmount > 0, "At least one should be minted");
require(PricePublic * mintAmount <= msg.value, "Not enough funds");
_mint(msg.sender, mintAmount);
emit TokenMinted(totalSupply());
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function setPricePublic(uint256 _newPricePublic) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| totalSupply().add(mintAmount)<=MaxToken,"Sold Out" | 465,841 | totalSupply().add(mintAmount)<=MaxToken |
"Not enough funds" | pragma solidity ^0.8.0;
contract TurkeyEgg is ERC721A, Ownable {
using SafeMath for uint256;
using Strings for uint256;
string private _baseUri;
uint256 public PricePublic = 0.05 ether;
uint256 public MaxToken = 10000;
uint256 public TokenIndex = 0;
event TokenMinted(uint256 supply);
constructor() ERC721A("TurkeyEgg", "TRKE") {}
function _baseURI() internal view virtual override returns (string memory) { }
function tokenURI(uint256 tokenId) public view virtual override returns (string memory a) {
}
function mint(uint8 mintAmount) public payable {
require(totalSupply().add(mintAmount) <= MaxToken, "Sold Out");
require(mintAmount > 0, "At least one should be minted");
require(<FILL_ME>)
_mint(msg.sender, mintAmount);
emit TokenMinted(totalSupply());
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function setPricePublic(uint256 _newPricePublic) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| PricePublic*mintAmount<=msg.value,"Not enough funds" | 465,841 | PricePublic*mintAmount<=msg.value |
"Insufficient balance" | // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `to`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address to, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `from` to `to` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
pragma solidity ^0.8.4;
contract CaveShop is Ownable {
IERC1155 public tokenA;
IERC20 public tokenB;
IERC20 public tokenC;
address public initial;
address public DivideReceiver = 0xeE7513e1cFf5aE8b6f18F68Dd6Ef908e577CC68f;
address constant DEAD = 0x000000000000000000000000000000000000dEaD;
address public specialAddress = 0xfAe2ac6097A334777c0901DC49adc65483096029;
uint256 public DEADFee = 60;
uint256[] private commodityTokenId;
mapping(uint256 => uint256) private commodityPrice;
uint256[] private luxuryCommodityTokenId;
mapping(uint256 => uint256) private luxuryCommodityPrice;
mapping(uint256 => bool) private special;
mapping(uint256 => bool) private upgradePackage;
bool public _isCommonStore = true;
bool public _isCommonSynthesis = true;
bool public _isEquipmentSynthesis = true;
bool public _isTimesSwitch = true;
uint256[2] private businessHours;
event Synthesis(address indexed from,uint256 indexed _tokenId, uint256 indexed _amount, uint256 value);
constructor(address _tokenA, address _tokenB, address _tokenC) {
}
function commonStore(uint256[] memory _tokenId,uint256[] memory _amount) public{
require(_isCommonStore, "stoppage of business");
uint commodityLength = _tokenId.length;
uint commodityAmount = _amount.length;
require(
commodityLength == commodityAmount,
"Quantity does not match"
);
uint256 priceCount = 0;
uint256 specialPrice = 0;
uint256 upgradePrice = 0;
for(uint i = 0; i < commodityLength; i++){
require(<FILL_ME>)
require(
commodityPrice[_tokenId[i]] > 0,
"no such product"
);
if(special[_tokenId[i]]){
specialPrice += commodityPrice[_tokenId[i]] * _amount[i];
}else if(upgradePackage[_tokenId[i]]){
upgradePrice += commodityPrice[_tokenId[i]] * _amount[i];
}else{
priceCount += commodityPrice[_tokenId[i]] * _amount[i];
}
}
require(
tokenB.allowance(msg.sender,address(this)) >= priceCount + specialPrice,
"insufficient allowance"
);
require(
tokenC.allowance(msg.sender,address(this)) >= upgradePrice,
"insufficient allowance"
);
require(
tokenB.balanceOf(msg.sender) >= priceCount + specialPrice,
"Not enough Torch send"
);
require(
tokenC.balanceOf(msg.sender) >= upgradePrice,
"Not enough Torch send"
);
uint256 DeadAmount = priceCount * DEADFee / 10 ** 2;
uint256 divideAmount = priceCount - DeadAmount;
if(priceCount > 0){
tokenB.transferFrom(msg.sender, DEAD, DeadAmount);
tokenB.transferFrom(msg.sender, DivideReceiver, divideAmount);
}
if(specialPrice > 0){
tokenB.transferFrom(msg.sender, specialAddress, specialPrice);
}
if(upgradePrice > 0){
tokenC.transferFrom(msg.sender, specialAddress, upgradePrice);
}
tokenA.safeBatchTransferFrom(initial, msg.sender, _tokenId, _amount, "0x00");
}
function commonSynthesis(uint256[] memory _tokenId,uint256[] memory _amount,uint256 _monsterTokenid) public{
}
function luxuryStores(uint256[] memory _tokenId,uint256[] memory _amount) public{
}
function luxuryStoresSynthesis(uint256[] memory _tokenId,uint256[] memory _amount,uint256 _monsterTokenid) public{
}
function equipmentSynthesis(uint256[] memory _tokenId,uint256[] memory _amount,uint256 _monsterTokenid) public{
}
function setUpCommodityPrice(uint256[] memory _tokenId,uint256[] memory _amount) public onlyOwner {
}
function getIsCommodityTokenId(uint256 _tokenId) public view returns(bool){
}
function getCommodityPriceList() public view returns(uint256[] memory,uint256[] memory){
}
function setUpLuxuryCommodityPrice(uint256[] memory _tokenId,uint256[] memory _amount) public onlyOwner {
}
function getIsLuxuryCommodityTokenId(uint256 _tokenId) public view returns(bool){
}
function getLuxuryCommodityPriceList() public view returns(uint256[] memory,uint256[] memory){
}
function getGeneralStorePrice(uint256[] memory _tokenId,uint256[] memory _amount) public view returns(uint256){
}
function getLuxuryGeneralStorePrice(uint256[] memory _tokenId,uint256[] memory _amount) public view returns(uint256){
}
function setUpBusinessHours(uint256[] memory _timeDeta) public onlyOwner {
}
function getblocktimes() public view returns(uint256) {
}
function flipisCommonStore() public onlyOwner {
}
function flipisCommonSynthesis() public onlyOwner {
}
function flipisEquipmentSynthesis() public onlyOwner {
}
function flipisTimesSwitch() public onlyOwner {
}
function getBusinessHours() public view returns(uint256[2] memory){
}
function setTokenAContract(address _tokenA) public onlyOwner {
}
function setTokenBContract(address _tokenB) public onlyOwner {
}
function setTokenCContract(address _tokenC) public onlyOwner {
}
function setDivideReceiver(address _address) public onlyOwner {
}
function setDEADFee(uint256 _amount) public onlyOwner{
}
function setSpecialAddress(address _addr) public onlyOwner{
}
function setSpecial(uint256[] memory _tokenId,bool[] memory value) public onlyOwner{
}
function getSpecial(uint256[] memory _tokenId) public view returns(bool[] memory){
}
function setUpgradePackage(uint256[] memory _tokenId,bool[] memory value) public onlyOwner{
}
function getUpgradePackage(uint256[] memory _tokenId) public view returns(bool[] memory){
}
}
| tokenA.balanceOf(initial,_tokenId[i])>=_amount[i],"Insufficient balance" | 465,864 | tokenA.balanceOf(initial,_tokenId[i])>=_amount[i] |
"no such product" | // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `to`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address to, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `from` to `to` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
pragma solidity ^0.8.4;
contract CaveShop is Ownable {
IERC1155 public tokenA;
IERC20 public tokenB;
IERC20 public tokenC;
address public initial;
address public DivideReceiver = 0xeE7513e1cFf5aE8b6f18F68Dd6Ef908e577CC68f;
address constant DEAD = 0x000000000000000000000000000000000000dEaD;
address public specialAddress = 0xfAe2ac6097A334777c0901DC49adc65483096029;
uint256 public DEADFee = 60;
uint256[] private commodityTokenId;
mapping(uint256 => uint256) private commodityPrice;
uint256[] private luxuryCommodityTokenId;
mapping(uint256 => uint256) private luxuryCommodityPrice;
mapping(uint256 => bool) private special;
mapping(uint256 => bool) private upgradePackage;
bool public _isCommonStore = true;
bool public _isCommonSynthesis = true;
bool public _isEquipmentSynthesis = true;
bool public _isTimesSwitch = true;
uint256[2] private businessHours;
event Synthesis(address indexed from,uint256 indexed _tokenId, uint256 indexed _amount, uint256 value);
constructor(address _tokenA, address _tokenB, address _tokenC) {
}
function commonStore(uint256[] memory _tokenId,uint256[] memory _amount) public{
require(_isCommonStore, "stoppage of business");
uint commodityLength = _tokenId.length;
uint commodityAmount = _amount.length;
require(
commodityLength == commodityAmount,
"Quantity does not match"
);
uint256 priceCount = 0;
uint256 specialPrice = 0;
uint256 upgradePrice = 0;
for(uint i = 0; i < commodityLength; i++){
require(
tokenA.balanceOf(initial,_tokenId[i]) >= _amount[i],
"Insufficient balance"
);
require(<FILL_ME>)
if(special[_tokenId[i]]){
specialPrice += commodityPrice[_tokenId[i]] * _amount[i];
}else if(upgradePackage[_tokenId[i]]){
upgradePrice += commodityPrice[_tokenId[i]] * _amount[i];
}else{
priceCount += commodityPrice[_tokenId[i]] * _amount[i];
}
}
require(
tokenB.allowance(msg.sender,address(this)) >= priceCount + specialPrice,
"insufficient allowance"
);
require(
tokenC.allowance(msg.sender,address(this)) >= upgradePrice,
"insufficient allowance"
);
require(
tokenB.balanceOf(msg.sender) >= priceCount + specialPrice,
"Not enough Torch send"
);
require(
tokenC.balanceOf(msg.sender) >= upgradePrice,
"Not enough Torch send"
);
uint256 DeadAmount = priceCount * DEADFee / 10 ** 2;
uint256 divideAmount = priceCount - DeadAmount;
if(priceCount > 0){
tokenB.transferFrom(msg.sender, DEAD, DeadAmount);
tokenB.transferFrom(msg.sender, DivideReceiver, divideAmount);
}
if(specialPrice > 0){
tokenB.transferFrom(msg.sender, specialAddress, specialPrice);
}
if(upgradePrice > 0){
tokenC.transferFrom(msg.sender, specialAddress, upgradePrice);
}
tokenA.safeBatchTransferFrom(initial, msg.sender, _tokenId, _amount, "0x00");
}
function commonSynthesis(uint256[] memory _tokenId,uint256[] memory _amount,uint256 _monsterTokenid) public{
}
function luxuryStores(uint256[] memory _tokenId,uint256[] memory _amount) public{
}
function luxuryStoresSynthesis(uint256[] memory _tokenId,uint256[] memory _amount,uint256 _monsterTokenid) public{
}
function equipmentSynthesis(uint256[] memory _tokenId,uint256[] memory _amount,uint256 _monsterTokenid) public{
}
function setUpCommodityPrice(uint256[] memory _tokenId,uint256[] memory _amount) public onlyOwner {
}
function getIsCommodityTokenId(uint256 _tokenId) public view returns(bool){
}
function getCommodityPriceList() public view returns(uint256[] memory,uint256[] memory){
}
function setUpLuxuryCommodityPrice(uint256[] memory _tokenId,uint256[] memory _amount) public onlyOwner {
}
function getIsLuxuryCommodityTokenId(uint256 _tokenId) public view returns(bool){
}
function getLuxuryCommodityPriceList() public view returns(uint256[] memory,uint256[] memory){
}
function getGeneralStorePrice(uint256[] memory _tokenId,uint256[] memory _amount) public view returns(uint256){
}
function getLuxuryGeneralStorePrice(uint256[] memory _tokenId,uint256[] memory _amount) public view returns(uint256){
}
function setUpBusinessHours(uint256[] memory _timeDeta) public onlyOwner {
}
function getblocktimes() public view returns(uint256) {
}
function flipisCommonStore() public onlyOwner {
}
function flipisCommonSynthesis() public onlyOwner {
}
function flipisEquipmentSynthesis() public onlyOwner {
}
function flipisTimesSwitch() public onlyOwner {
}
function getBusinessHours() public view returns(uint256[2] memory){
}
function setTokenAContract(address _tokenA) public onlyOwner {
}
function setTokenBContract(address _tokenB) public onlyOwner {
}
function setTokenCContract(address _tokenC) public onlyOwner {
}
function setDivideReceiver(address _address) public onlyOwner {
}
function setDEADFee(uint256 _amount) public onlyOwner{
}
function setSpecialAddress(address _addr) public onlyOwner{
}
function setSpecial(uint256[] memory _tokenId,bool[] memory value) public onlyOwner{
}
function getSpecial(uint256[] memory _tokenId) public view returns(bool[] memory){
}
function setUpgradePackage(uint256[] memory _tokenId,bool[] memory value) public onlyOwner{
}
function getUpgradePackage(uint256[] memory _tokenId) public view returns(bool[] memory){
}
}
| commodityPrice[_tokenId[i]]>0,"no such product" | 465,864 | commodityPrice[_tokenId[i]]>0 |
"insufficient allowance" | // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `to`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address to, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `from` to `to` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
pragma solidity ^0.8.4;
contract CaveShop is Ownable {
IERC1155 public tokenA;
IERC20 public tokenB;
IERC20 public tokenC;
address public initial;
address public DivideReceiver = 0xeE7513e1cFf5aE8b6f18F68Dd6Ef908e577CC68f;
address constant DEAD = 0x000000000000000000000000000000000000dEaD;
address public specialAddress = 0xfAe2ac6097A334777c0901DC49adc65483096029;
uint256 public DEADFee = 60;
uint256[] private commodityTokenId;
mapping(uint256 => uint256) private commodityPrice;
uint256[] private luxuryCommodityTokenId;
mapping(uint256 => uint256) private luxuryCommodityPrice;
mapping(uint256 => bool) private special;
mapping(uint256 => bool) private upgradePackage;
bool public _isCommonStore = true;
bool public _isCommonSynthesis = true;
bool public _isEquipmentSynthesis = true;
bool public _isTimesSwitch = true;
uint256[2] private businessHours;
event Synthesis(address indexed from,uint256 indexed _tokenId, uint256 indexed _amount, uint256 value);
constructor(address _tokenA, address _tokenB, address _tokenC) {
}
function commonStore(uint256[] memory _tokenId,uint256[] memory _amount) public{
require(_isCommonStore, "stoppage of business");
uint commodityLength = _tokenId.length;
uint commodityAmount = _amount.length;
require(
commodityLength == commodityAmount,
"Quantity does not match"
);
uint256 priceCount = 0;
uint256 specialPrice = 0;
uint256 upgradePrice = 0;
for(uint i = 0; i < commodityLength; i++){
require(
tokenA.balanceOf(initial,_tokenId[i]) >= _amount[i],
"Insufficient balance"
);
require(
commodityPrice[_tokenId[i]] > 0,
"no such product"
);
if(special[_tokenId[i]]){
specialPrice += commodityPrice[_tokenId[i]] * _amount[i];
}else if(upgradePackage[_tokenId[i]]){
upgradePrice += commodityPrice[_tokenId[i]] * _amount[i];
}else{
priceCount += commodityPrice[_tokenId[i]] * _amount[i];
}
}
require(<FILL_ME>)
require(
tokenC.allowance(msg.sender,address(this)) >= upgradePrice,
"insufficient allowance"
);
require(
tokenB.balanceOf(msg.sender) >= priceCount + specialPrice,
"Not enough Torch send"
);
require(
tokenC.balanceOf(msg.sender) >= upgradePrice,
"Not enough Torch send"
);
uint256 DeadAmount = priceCount * DEADFee / 10 ** 2;
uint256 divideAmount = priceCount - DeadAmount;
if(priceCount > 0){
tokenB.transferFrom(msg.sender, DEAD, DeadAmount);
tokenB.transferFrom(msg.sender, DivideReceiver, divideAmount);
}
if(specialPrice > 0){
tokenB.transferFrom(msg.sender, specialAddress, specialPrice);
}
if(upgradePrice > 0){
tokenC.transferFrom(msg.sender, specialAddress, upgradePrice);
}
tokenA.safeBatchTransferFrom(initial, msg.sender, _tokenId, _amount, "0x00");
}
function commonSynthesis(uint256[] memory _tokenId,uint256[] memory _amount,uint256 _monsterTokenid) public{
}
function luxuryStores(uint256[] memory _tokenId,uint256[] memory _amount) public{
}
function luxuryStoresSynthesis(uint256[] memory _tokenId,uint256[] memory _amount,uint256 _monsterTokenid) public{
}
function equipmentSynthesis(uint256[] memory _tokenId,uint256[] memory _amount,uint256 _monsterTokenid) public{
}
function setUpCommodityPrice(uint256[] memory _tokenId,uint256[] memory _amount) public onlyOwner {
}
function getIsCommodityTokenId(uint256 _tokenId) public view returns(bool){
}
function getCommodityPriceList() public view returns(uint256[] memory,uint256[] memory){
}
function setUpLuxuryCommodityPrice(uint256[] memory _tokenId,uint256[] memory _amount) public onlyOwner {
}
function getIsLuxuryCommodityTokenId(uint256 _tokenId) public view returns(bool){
}
function getLuxuryCommodityPriceList() public view returns(uint256[] memory,uint256[] memory){
}
function getGeneralStorePrice(uint256[] memory _tokenId,uint256[] memory _amount) public view returns(uint256){
}
function getLuxuryGeneralStorePrice(uint256[] memory _tokenId,uint256[] memory _amount) public view returns(uint256){
}
function setUpBusinessHours(uint256[] memory _timeDeta) public onlyOwner {
}
function getblocktimes() public view returns(uint256) {
}
function flipisCommonStore() public onlyOwner {
}
function flipisCommonSynthesis() public onlyOwner {
}
function flipisEquipmentSynthesis() public onlyOwner {
}
function flipisTimesSwitch() public onlyOwner {
}
function getBusinessHours() public view returns(uint256[2] memory){
}
function setTokenAContract(address _tokenA) public onlyOwner {
}
function setTokenBContract(address _tokenB) public onlyOwner {
}
function setTokenCContract(address _tokenC) public onlyOwner {
}
function setDivideReceiver(address _address) public onlyOwner {
}
function setDEADFee(uint256 _amount) public onlyOwner{
}
function setSpecialAddress(address _addr) public onlyOwner{
}
function setSpecial(uint256[] memory _tokenId,bool[] memory value) public onlyOwner{
}
function getSpecial(uint256[] memory _tokenId) public view returns(bool[] memory){
}
function setUpgradePackage(uint256[] memory _tokenId,bool[] memory value) public onlyOwner{
}
function getUpgradePackage(uint256[] memory _tokenId) public view returns(bool[] memory){
}
}
| tokenB.allowance(msg.sender,address(this))>=priceCount+specialPrice,"insufficient allowance" | 465,864 | tokenB.allowance(msg.sender,address(this))>=priceCount+specialPrice |
"insufficient allowance" | // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `to`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address to, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `from` to `to` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
pragma solidity ^0.8.4;
contract CaveShop is Ownable {
IERC1155 public tokenA;
IERC20 public tokenB;
IERC20 public tokenC;
address public initial;
address public DivideReceiver = 0xeE7513e1cFf5aE8b6f18F68Dd6Ef908e577CC68f;
address constant DEAD = 0x000000000000000000000000000000000000dEaD;
address public specialAddress = 0xfAe2ac6097A334777c0901DC49adc65483096029;
uint256 public DEADFee = 60;
uint256[] private commodityTokenId;
mapping(uint256 => uint256) private commodityPrice;
uint256[] private luxuryCommodityTokenId;
mapping(uint256 => uint256) private luxuryCommodityPrice;
mapping(uint256 => bool) private special;
mapping(uint256 => bool) private upgradePackage;
bool public _isCommonStore = true;
bool public _isCommonSynthesis = true;
bool public _isEquipmentSynthesis = true;
bool public _isTimesSwitch = true;
uint256[2] private businessHours;
event Synthesis(address indexed from,uint256 indexed _tokenId, uint256 indexed _amount, uint256 value);
constructor(address _tokenA, address _tokenB, address _tokenC) {
}
function commonStore(uint256[] memory _tokenId,uint256[] memory _amount) public{
require(_isCommonStore, "stoppage of business");
uint commodityLength = _tokenId.length;
uint commodityAmount = _amount.length;
require(
commodityLength == commodityAmount,
"Quantity does not match"
);
uint256 priceCount = 0;
uint256 specialPrice = 0;
uint256 upgradePrice = 0;
for(uint i = 0; i < commodityLength; i++){
require(
tokenA.balanceOf(initial,_tokenId[i]) >= _amount[i],
"Insufficient balance"
);
require(
commodityPrice[_tokenId[i]] > 0,
"no such product"
);
if(special[_tokenId[i]]){
specialPrice += commodityPrice[_tokenId[i]] * _amount[i];
}else if(upgradePackage[_tokenId[i]]){
upgradePrice += commodityPrice[_tokenId[i]] * _amount[i];
}else{
priceCount += commodityPrice[_tokenId[i]] * _amount[i];
}
}
require(
tokenB.allowance(msg.sender,address(this)) >= priceCount + specialPrice,
"insufficient allowance"
);
require(<FILL_ME>)
require(
tokenB.balanceOf(msg.sender) >= priceCount + specialPrice,
"Not enough Torch send"
);
require(
tokenC.balanceOf(msg.sender) >= upgradePrice,
"Not enough Torch send"
);
uint256 DeadAmount = priceCount * DEADFee / 10 ** 2;
uint256 divideAmount = priceCount - DeadAmount;
if(priceCount > 0){
tokenB.transferFrom(msg.sender, DEAD, DeadAmount);
tokenB.transferFrom(msg.sender, DivideReceiver, divideAmount);
}
if(specialPrice > 0){
tokenB.transferFrom(msg.sender, specialAddress, specialPrice);
}
if(upgradePrice > 0){
tokenC.transferFrom(msg.sender, specialAddress, upgradePrice);
}
tokenA.safeBatchTransferFrom(initial, msg.sender, _tokenId, _amount, "0x00");
}
function commonSynthesis(uint256[] memory _tokenId,uint256[] memory _amount,uint256 _monsterTokenid) public{
}
function luxuryStores(uint256[] memory _tokenId,uint256[] memory _amount) public{
}
function luxuryStoresSynthesis(uint256[] memory _tokenId,uint256[] memory _amount,uint256 _monsterTokenid) public{
}
function equipmentSynthesis(uint256[] memory _tokenId,uint256[] memory _amount,uint256 _monsterTokenid) public{
}
function setUpCommodityPrice(uint256[] memory _tokenId,uint256[] memory _amount) public onlyOwner {
}
function getIsCommodityTokenId(uint256 _tokenId) public view returns(bool){
}
function getCommodityPriceList() public view returns(uint256[] memory,uint256[] memory){
}
function setUpLuxuryCommodityPrice(uint256[] memory _tokenId,uint256[] memory _amount) public onlyOwner {
}
function getIsLuxuryCommodityTokenId(uint256 _tokenId) public view returns(bool){
}
function getLuxuryCommodityPriceList() public view returns(uint256[] memory,uint256[] memory){
}
function getGeneralStorePrice(uint256[] memory _tokenId,uint256[] memory _amount) public view returns(uint256){
}
function getLuxuryGeneralStorePrice(uint256[] memory _tokenId,uint256[] memory _amount) public view returns(uint256){
}
function setUpBusinessHours(uint256[] memory _timeDeta) public onlyOwner {
}
function getblocktimes() public view returns(uint256) {
}
function flipisCommonStore() public onlyOwner {
}
function flipisCommonSynthesis() public onlyOwner {
}
function flipisEquipmentSynthesis() public onlyOwner {
}
function flipisTimesSwitch() public onlyOwner {
}
function getBusinessHours() public view returns(uint256[2] memory){
}
function setTokenAContract(address _tokenA) public onlyOwner {
}
function setTokenBContract(address _tokenB) public onlyOwner {
}
function setTokenCContract(address _tokenC) public onlyOwner {
}
function setDivideReceiver(address _address) public onlyOwner {
}
function setDEADFee(uint256 _amount) public onlyOwner{
}
function setSpecialAddress(address _addr) public onlyOwner{
}
function setSpecial(uint256[] memory _tokenId,bool[] memory value) public onlyOwner{
}
function getSpecial(uint256[] memory _tokenId) public view returns(bool[] memory){
}
function setUpgradePackage(uint256[] memory _tokenId,bool[] memory value) public onlyOwner{
}
function getUpgradePackage(uint256[] memory _tokenId) public view returns(bool[] memory){
}
}
| tokenC.allowance(msg.sender,address(this))>=upgradePrice,"insufficient allowance" | 465,864 | tokenC.allowance(msg.sender,address(this))>=upgradePrice |
"Not enough Torch send" | // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `to`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address to, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `from` to `to` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
pragma solidity ^0.8.4;
contract CaveShop is Ownable {
IERC1155 public tokenA;
IERC20 public tokenB;
IERC20 public tokenC;
address public initial;
address public DivideReceiver = 0xeE7513e1cFf5aE8b6f18F68Dd6Ef908e577CC68f;
address constant DEAD = 0x000000000000000000000000000000000000dEaD;
address public specialAddress = 0xfAe2ac6097A334777c0901DC49adc65483096029;
uint256 public DEADFee = 60;
uint256[] private commodityTokenId;
mapping(uint256 => uint256) private commodityPrice;
uint256[] private luxuryCommodityTokenId;
mapping(uint256 => uint256) private luxuryCommodityPrice;
mapping(uint256 => bool) private special;
mapping(uint256 => bool) private upgradePackage;
bool public _isCommonStore = true;
bool public _isCommonSynthesis = true;
bool public _isEquipmentSynthesis = true;
bool public _isTimesSwitch = true;
uint256[2] private businessHours;
event Synthesis(address indexed from,uint256 indexed _tokenId, uint256 indexed _amount, uint256 value);
constructor(address _tokenA, address _tokenB, address _tokenC) {
}
function commonStore(uint256[] memory _tokenId,uint256[] memory _amount) public{
require(_isCommonStore, "stoppage of business");
uint commodityLength = _tokenId.length;
uint commodityAmount = _amount.length;
require(
commodityLength == commodityAmount,
"Quantity does not match"
);
uint256 priceCount = 0;
uint256 specialPrice = 0;
uint256 upgradePrice = 0;
for(uint i = 0; i < commodityLength; i++){
require(
tokenA.balanceOf(initial,_tokenId[i]) >= _amount[i],
"Insufficient balance"
);
require(
commodityPrice[_tokenId[i]] > 0,
"no such product"
);
if(special[_tokenId[i]]){
specialPrice += commodityPrice[_tokenId[i]] * _amount[i];
}else if(upgradePackage[_tokenId[i]]){
upgradePrice += commodityPrice[_tokenId[i]] * _amount[i];
}else{
priceCount += commodityPrice[_tokenId[i]] * _amount[i];
}
}
require(
tokenB.allowance(msg.sender,address(this)) >= priceCount + specialPrice,
"insufficient allowance"
);
require(
tokenC.allowance(msg.sender,address(this)) >= upgradePrice,
"insufficient allowance"
);
require(<FILL_ME>)
require(
tokenC.balanceOf(msg.sender) >= upgradePrice,
"Not enough Torch send"
);
uint256 DeadAmount = priceCount * DEADFee / 10 ** 2;
uint256 divideAmount = priceCount - DeadAmount;
if(priceCount > 0){
tokenB.transferFrom(msg.sender, DEAD, DeadAmount);
tokenB.transferFrom(msg.sender, DivideReceiver, divideAmount);
}
if(specialPrice > 0){
tokenB.transferFrom(msg.sender, specialAddress, specialPrice);
}
if(upgradePrice > 0){
tokenC.transferFrom(msg.sender, specialAddress, upgradePrice);
}
tokenA.safeBatchTransferFrom(initial, msg.sender, _tokenId, _amount, "0x00");
}
function commonSynthesis(uint256[] memory _tokenId,uint256[] memory _amount,uint256 _monsterTokenid) public{
}
function luxuryStores(uint256[] memory _tokenId,uint256[] memory _amount) public{
}
function luxuryStoresSynthesis(uint256[] memory _tokenId,uint256[] memory _amount,uint256 _monsterTokenid) public{
}
function equipmentSynthesis(uint256[] memory _tokenId,uint256[] memory _amount,uint256 _monsterTokenid) public{
}
function setUpCommodityPrice(uint256[] memory _tokenId,uint256[] memory _amount) public onlyOwner {
}
function getIsCommodityTokenId(uint256 _tokenId) public view returns(bool){
}
function getCommodityPriceList() public view returns(uint256[] memory,uint256[] memory){
}
function setUpLuxuryCommodityPrice(uint256[] memory _tokenId,uint256[] memory _amount) public onlyOwner {
}
function getIsLuxuryCommodityTokenId(uint256 _tokenId) public view returns(bool){
}
function getLuxuryCommodityPriceList() public view returns(uint256[] memory,uint256[] memory){
}
function getGeneralStorePrice(uint256[] memory _tokenId,uint256[] memory _amount) public view returns(uint256){
}
function getLuxuryGeneralStorePrice(uint256[] memory _tokenId,uint256[] memory _amount) public view returns(uint256){
}
function setUpBusinessHours(uint256[] memory _timeDeta) public onlyOwner {
}
function getblocktimes() public view returns(uint256) {
}
function flipisCommonStore() public onlyOwner {
}
function flipisCommonSynthesis() public onlyOwner {
}
function flipisEquipmentSynthesis() public onlyOwner {
}
function flipisTimesSwitch() public onlyOwner {
}
function getBusinessHours() public view returns(uint256[2] memory){
}
function setTokenAContract(address _tokenA) public onlyOwner {
}
function setTokenBContract(address _tokenB) public onlyOwner {
}
function setTokenCContract(address _tokenC) public onlyOwner {
}
function setDivideReceiver(address _address) public onlyOwner {
}
function setDEADFee(uint256 _amount) public onlyOwner{
}
function setSpecialAddress(address _addr) public onlyOwner{
}
function setSpecial(uint256[] memory _tokenId,bool[] memory value) public onlyOwner{
}
function getSpecial(uint256[] memory _tokenId) public view returns(bool[] memory){
}
function setUpgradePackage(uint256[] memory _tokenId,bool[] memory value) public onlyOwner{
}
function getUpgradePackage(uint256[] memory _tokenId) public view returns(bool[] memory){
}
}
| tokenB.balanceOf(msg.sender)>=priceCount+specialPrice,"Not enough Torch send" | 465,864 | tokenB.balanceOf(msg.sender)>=priceCount+specialPrice |
"Not enough Torch send" | // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `to`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address to, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `from` to `to` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
pragma solidity ^0.8.4;
contract CaveShop is Ownable {
IERC1155 public tokenA;
IERC20 public tokenB;
IERC20 public tokenC;
address public initial;
address public DivideReceiver = 0xeE7513e1cFf5aE8b6f18F68Dd6Ef908e577CC68f;
address constant DEAD = 0x000000000000000000000000000000000000dEaD;
address public specialAddress = 0xfAe2ac6097A334777c0901DC49adc65483096029;
uint256 public DEADFee = 60;
uint256[] private commodityTokenId;
mapping(uint256 => uint256) private commodityPrice;
uint256[] private luxuryCommodityTokenId;
mapping(uint256 => uint256) private luxuryCommodityPrice;
mapping(uint256 => bool) private special;
mapping(uint256 => bool) private upgradePackage;
bool public _isCommonStore = true;
bool public _isCommonSynthesis = true;
bool public _isEquipmentSynthesis = true;
bool public _isTimesSwitch = true;
uint256[2] private businessHours;
event Synthesis(address indexed from,uint256 indexed _tokenId, uint256 indexed _amount, uint256 value);
constructor(address _tokenA, address _tokenB, address _tokenC) {
}
function commonStore(uint256[] memory _tokenId,uint256[] memory _amount) public{
require(_isCommonStore, "stoppage of business");
uint commodityLength = _tokenId.length;
uint commodityAmount = _amount.length;
require(
commodityLength == commodityAmount,
"Quantity does not match"
);
uint256 priceCount = 0;
uint256 specialPrice = 0;
uint256 upgradePrice = 0;
for(uint i = 0; i < commodityLength; i++){
require(
tokenA.balanceOf(initial,_tokenId[i]) >= _amount[i],
"Insufficient balance"
);
require(
commodityPrice[_tokenId[i]] > 0,
"no such product"
);
if(special[_tokenId[i]]){
specialPrice += commodityPrice[_tokenId[i]] * _amount[i];
}else if(upgradePackage[_tokenId[i]]){
upgradePrice += commodityPrice[_tokenId[i]] * _amount[i];
}else{
priceCount += commodityPrice[_tokenId[i]] * _amount[i];
}
}
require(
tokenB.allowance(msg.sender,address(this)) >= priceCount + specialPrice,
"insufficient allowance"
);
require(
tokenC.allowance(msg.sender,address(this)) >= upgradePrice,
"insufficient allowance"
);
require(
tokenB.balanceOf(msg.sender) >= priceCount + specialPrice,
"Not enough Torch send"
);
require(<FILL_ME>)
uint256 DeadAmount = priceCount * DEADFee / 10 ** 2;
uint256 divideAmount = priceCount - DeadAmount;
if(priceCount > 0){
tokenB.transferFrom(msg.sender, DEAD, DeadAmount);
tokenB.transferFrom(msg.sender, DivideReceiver, divideAmount);
}
if(specialPrice > 0){
tokenB.transferFrom(msg.sender, specialAddress, specialPrice);
}
if(upgradePrice > 0){
tokenC.transferFrom(msg.sender, specialAddress, upgradePrice);
}
tokenA.safeBatchTransferFrom(initial, msg.sender, _tokenId, _amount, "0x00");
}
function commonSynthesis(uint256[] memory _tokenId,uint256[] memory _amount,uint256 _monsterTokenid) public{
}
function luxuryStores(uint256[] memory _tokenId,uint256[] memory _amount) public{
}
function luxuryStoresSynthesis(uint256[] memory _tokenId,uint256[] memory _amount,uint256 _monsterTokenid) public{
}
function equipmentSynthesis(uint256[] memory _tokenId,uint256[] memory _amount,uint256 _monsterTokenid) public{
}
function setUpCommodityPrice(uint256[] memory _tokenId,uint256[] memory _amount) public onlyOwner {
}
function getIsCommodityTokenId(uint256 _tokenId) public view returns(bool){
}
function getCommodityPriceList() public view returns(uint256[] memory,uint256[] memory){
}
function setUpLuxuryCommodityPrice(uint256[] memory _tokenId,uint256[] memory _amount) public onlyOwner {
}
function getIsLuxuryCommodityTokenId(uint256 _tokenId) public view returns(bool){
}
function getLuxuryCommodityPriceList() public view returns(uint256[] memory,uint256[] memory){
}
function getGeneralStorePrice(uint256[] memory _tokenId,uint256[] memory _amount) public view returns(uint256){
}
function getLuxuryGeneralStorePrice(uint256[] memory _tokenId,uint256[] memory _amount) public view returns(uint256){
}
function setUpBusinessHours(uint256[] memory _timeDeta) public onlyOwner {
}
function getblocktimes() public view returns(uint256) {
}
function flipisCommonStore() public onlyOwner {
}
function flipisCommonSynthesis() public onlyOwner {
}
function flipisEquipmentSynthesis() public onlyOwner {
}
function flipisTimesSwitch() public onlyOwner {
}
function getBusinessHours() public view returns(uint256[2] memory){
}
function setTokenAContract(address _tokenA) public onlyOwner {
}
function setTokenBContract(address _tokenB) public onlyOwner {
}
function setTokenCContract(address _tokenC) public onlyOwner {
}
function setDivideReceiver(address _address) public onlyOwner {
}
function setDEADFee(uint256 _amount) public onlyOwner{
}
function setSpecialAddress(address _addr) public onlyOwner{
}
function setSpecial(uint256[] memory _tokenId,bool[] memory value) public onlyOwner{
}
function getSpecial(uint256[] memory _tokenId) public view returns(bool[] memory){
}
function setUpgradePackage(uint256[] memory _tokenId,bool[] memory value) public onlyOwner{
}
function getUpgradePackage(uint256[] memory _tokenId) public view returns(bool[] memory){
}
}
| tokenC.balanceOf(msg.sender)>=upgradePrice,"Not enough Torch send" | 465,864 | tokenC.balanceOf(msg.sender)>=upgradePrice |
"Business hours have not yet come" | // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `to`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address to, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `from` to `to` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
pragma solidity ^0.8.4;
contract CaveShop is Ownable {
IERC1155 public tokenA;
IERC20 public tokenB;
IERC20 public tokenC;
address public initial;
address public DivideReceiver = 0xeE7513e1cFf5aE8b6f18F68Dd6Ef908e577CC68f;
address constant DEAD = 0x000000000000000000000000000000000000dEaD;
address public specialAddress = 0xfAe2ac6097A334777c0901DC49adc65483096029;
uint256 public DEADFee = 60;
uint256[] private commodityTokenId;
mapping(uint256 => uint256) private commodityPrice;
uint256[] private luxuryCommodityTokenId;
mapping(uint256 => uint256) private luxuryCommodityPrice;
mapping(uint256 => bool) private special;
mapping(uint256 => bool) private upgradePackage;
bool public _isCommonStore = true;
bool public _isCommonSynthesis = true;
bool public _isEquipmentSynthesis = true;
bool public _isTimesSwitch = true;
uint256[2] private businessHours;
event Synthesis(address indexed from,uint256 indexed _tokenId, uint256 indexed _amount, uint256 value);
constructor(address _tokenA, address _tokenB, address _tokenC) {
}
function commonStore(uint256[] memory _tokenId,uint256[] memory _amount) public{
}
function commonSynthesis(uint256[] memory _tokenId,uint256[] memory _amount,uint256 _monsterTokenid) public{
}
function luxuryStores(uint256[] memory _tokenId,uint256[] memory _amount) public{
uint commodityLength = _tokenId.length;
uint commodityAmount = _amount.length;
require(
commodityLength == commodityAmount,
"Quantity does not match"
);
if(_isTimesSwitch){
require(<FILL_ME>)
}
uint256 priceCount = 0;
for(uint i = 0; i < commodityLength; i++){
require(
tokenA.balanceOf(initial,_tokenId[i]) >= _amount[i],
"Insufficient balance"
);
require(
luxuryCommodityPrice[_tokenId[i]] > 0,
"no such product"
);
priceCount += luxuryCommodityPrice[_tokenId[i]] * _amount[i];
}
require(
tokenB.allowance(msg.sender,address(this)) >= priceCount,
"insufficient allowance"
);
require(
tokenB.balanceOf(msg.sender) >= priceCount,
"Not enough Torch send"
);
uint256 DeadAmount = priceCount * DEADFee / 10 ** 2;
uint256 divideAmount = priceCount - DeadAmount;
tokenB.transferFrom(msg.sender, DEAD, DeadAmount);
tokenB.transferFrom(msg.sender, DivideReceiver, divideAmount);
tokenA.safeBatchTransferFrom(initial, msg.sender, _tokenId, _amount, "0x00");
}
function luxuryStoresSynthesis(uint256[] memory _tokenId,uint256[] memory _amount,uint256 _monsterTokenid) public{
}
function equipmentSynthesis(uint256[] memory _tokenId,uint256[] memory _amount,uint256 _monsterTokenid) public{
}
function setUpCommodityPrice(uint256[] memory _tokenId,uint256[] memory _amount) public onlyOwner {
}
function getIsCommodityTokenId(uint256 _tokenId) public view returns(bool){
}
function getCommodityPriceList() public view returns(uint256[] memory,uint256[] memory){
}
function setUpLuxuryCommodityPrice(uint256[] memory _tokenId,uint256[] memory _amount) public onlyOwner {
}
function getIsLuxuryCommodityTokenId(uint256 _tokenId) public view returns(bool){
}
function getLuxuryCommodityPriceList() public view returns(uint256[] memory,uint256[] memory){
}
function getGeneralStorePrice(uint256[] memory _tokenId,uint256[] memory _amount) public view returns(uint256){
}
function getLuxuryGeneralStorePrice(uint256[] memory _tokenId,uint256[] memory _amount) public view returns(uint256){
}
function setUpBusinessHours(uint256[] memory _timeDeta) public onlyOwner {
}
function getblocktimes() public view returns(uint256) {
}
function flipisCommonStore() public onlyOwner {
}
function flipisCommonSynthesis() public onlyOwner {
}
function flipisEquipmentSynthesis() public onlyOwner {
}
function flipisTimesSwitch() public onlyOwner {
}
function getBusinessHours() public view returns(uint256[2] memory){
}
function setTokenAContract(address _tokenA) public onlyOwner {
}
function setTokenBContract(address _tokenB) public onlyOwner {
}
function setTokenCContract(address _tokenC) public onlyOwner {
}
function setDivideReceiver(address _address) public onlyOwner {
}
function setDEADFee(uint256 _amount) public onlyOwner{
}
function setSpecialAddress(address _addr) public onlyOwner{
}
function setSpecial(uint256[] memory _tokenId,bool[] memory value) public onlyOwner{
}
function getSpecial(uint256[] memory _tokenId) public view returns(bool[] memory){
}
function setUpgradePackage(uint256[] memory _tokenId,bool[] memory value) public onlyOwner{
}
function getUpgradePackage(uint256[] memory _tokenId) public view returns(bool[] memory){
}
}
| businessHours[0]<block.timestamp&&businessHours[0]+businessHours[1]>block.timestamp,"Business hours have not yet come" | 465,864 | businessHours[0]<block.timestamp&&businessHours[0]+businessHours[1]>block.timestamp |
"no such product" | // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `to`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address to, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `from` to `to` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
pragma solidity ^0.8.4;
contract CaveShop is Ownable {
IERC1155 public tokenA;
IERC20 public tokenB;
IERC20 public tokenC;
address public initial;
address public DivideReceiver = 0xeE7513e1cFf5aE8b6f18F68Dd6Ef908e577CC68f;
address constant DEAD = 0x000000000000000000000000000000000000dEaD;
address public specialAddress = 0xfAe2ac6097A334777c0901DC49adc65483096029;
uint256 public DEADFee = 60;
uint256[] private commodityTokenId;
mapping(uint256 => uint256) private commodityPrice;
uint256[] private luxuryCommodityTokenId;
mapping(uint256 => uint256) private luxuryCommodityPrice;
mapping(uint256 => bool) private special;
mapping(uint256 => bool) private upgradePackage;
bool public _isCommonStore = true;
bool public _isCommonSynthesis = true;
bool public _isEquipmentSynthesis = true;
bool public _isTimesSwitch = true;
uint256[2] private businessHours;
event Synthesis(address indexed from,uint256 indexed _tokenId, uint256 indexed _amount, uint256 value);
constructor(address _tokenA, address _tokenB, address _tokenC) {
}
function commonStore(uint256[] memory _tokenId,uint256[] memory _amount) public{
}
function commonSynthesis(uint256[] memory _tokenId,uint256[] memory _amount,uint256 _monsterTokenid) public{
}
function luxuryStores(uint256[] memory _tokenId,uint256[] memory _amount) public{
uint commodityLength = _tokenId.length;
uint commodityAmount = _amount.length;
require(
commodityLength == commodityAmount,
"Quantity does not match"
);
if(_isTimesSwitch){
require(
businessHours[0] < block.timestamp && businessHours[0] + businessHours[1] > block.timestamp,
"Business hours have not yet come"
);
}
uint256 priceCount = 0;
for(uint i = 0; i < commodityLength; i++){
require(
tokenA.balanceOf(initial,_tokenId[i]) >= _amount[i],
"Insufficient balance"
);
require(<FILL_ME>)
priceCount += luxuryCommodityPrice[_tokenId[i]] * _amount[i];
}
require(
tokenB.allowance(msg.sender,address(this)) >= priceCount,
"insufficient allowance"
);
require(
tokenB.balanceOf(msg.sender) >= priceCount,
"Not enough Torch send"
);
uint256 DeadAmount = priceCount * DEADFee / 10 ** 2;
uint256 divideAmount = priceCount - DeadAmount;
tokenB.transferFrom(msg.sender, DEAD, DeadAmount);
tokenB.transferFrom(msg.sender, DivideReceiver, divideAmount);
tokenA.safeBatchTransferFrom(initial, msg.sender, _tokenId, _amount, "0x00");
}
function luxuryStoresSynthesis(uint256[] memory _tokenId,uint256[] memory _amount,uint256 _monsterTokenid) public{
}
function equipmentSynthesis(uint256[] memory _tokenId,uint256[] memory _amount,uint256 _monsterTokenid) public{
}
function setUpCommodityPrice(uint256[] memory _tokenId,uint256[] memory _amount) public onlyOwner {
}
function getIsCommodityTokenId(uint256 _tokenId) public view returns(bool){
}
function getCommodityPriceList() public view returns(uint256[] memory,uint256[] memory){
}
function setUpLuxuryCommodityPrice(uint256[] memory _tokenId,uint256[] memory _amount) public onlyOwner {
}
function getIsLuxuryCommodityTokenId(uint256 _tokenId) public view returns(bool){
}
function getLuxuryCommodityPriceList() public view returns(uint256[] memory,uint256[] memory){
}
function getGeneralStorePrice(uint256[] memory _tokenId,uint256[] memory _amount) public view returns(uint256){
}
function getLuxuryGeneralStorePrice(uint256[] memory _tokenId,uint256[] memory _amount) public view returns(uint256){
}
function setUpBusinessHours(uint256[] memory _timeDeta) public onlyOwner {
}
function getblocktimes() public view returns(uint256) {
}
function flipisCommonStore() public onlyOwner {
}
function flipisCommonSynthesis() public onlyOwner {
}
function flipisEquipmentSynthesis() public onlyOwner {
}
function flipisTimesSwitch() public onlyOwner {
}
function getBusinessHours() public view returns(uint256[2] memory){
}
function setTokenAContract(address _tokenA) public onlyOwner {
}
function setTokenBContract(address _tokenB) public onlyOwner {
}
function setTokenCContract(address _tokenC) public onlyOwner {
}
function setDivideReceiver(address _address) public onlyOwner {
}
function setDEADFee(uint256 _amount) public onlyOwner{
}
function setSpecialAddress(address _addr) public onlyOwner{
}
function setSpecial(uint256[] memory _tokenId,bool[] memory value) public onlyOwner{
}
function getSpecial(uint256[] memory _tokenId) public view returns(bool[] memory){
}
function setUpgradePackage(uint256[] memory _tokenId,bool[] memory value) public onlyOwner{
}
function getUpgradePackage(uint256[] memory _tokenId) public view returns(bool[] memory){
}
}
| luxuryCommodityPrice[_tokenId[i]]>0,"no such product" | 465,864 | luxuryCommodityPrice[_tokenId[i]]>0 |
"insufficient allowance" | // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `to`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address to, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `from` to `to` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
pragma solidity ^0.8.4;
contract CaveShop is Ownable {
IERC1155 public tokenA;
IERC20 public tokenB;
IERC20 public tokenC;
address public initial;
address public DivideReceiver = 0xeE7513e1cFf5aE8b6f18F68Dd6Ef908e577CC68f;
address constant DEAD = 0x000000000000000000000000000000000000dEaD;
address public specialAddress = 0xfAe2ac6097A334777c0901DC49adc65483096029;
uint256 public DEADFee = 60;
uint256[] private commodityTokenId;
mapping(uint256 => uint256) private commodityPrice;
uint256[] private luxuryCommodityTokenId;
mapping(uint256 => uint256) private luxuryCommodityPrice;
mapping(uint256 => bool) private special;
mapping(uint256 => bool) private upgradePackage;
bool public _isCommonStore = true;
bool public _isCommonSynthesis = true;
bool public _isEquipmentSynthesis = true;
bool public _isTimesSwitch = true;
uint256[2] private businessHours;
event Synthesis(address indexed from,uint256 indexed _tokenId, uint256 indexed _amount, uint256 value);
constructor(address _tokenA, address _tokenB, address _tokenC) {
}
function commonStore(uint256[] memory _tokenId,uint256[] memory _amount) public{
}
function commonSynthesis(uint256[] memory _tokenId,uint256[] memory _amount,uint256 _monsterTokenid) public{
}
function luxuryStores(uint256[] memory _tokenId,uint256[] memory _amount) public{
uint commodityLength = _tokenId.length;
uint commodityAmount = _amount.length;
require(
commodityLength == commodityAmount,
"Quantity does not match"
);
if(_isTimesSwitch){
require(
businessHours[0] < block.timestamp && businessHours[0] + businessHours[1] > block.timestamp,
"Business hours have not yet come"
);
}
uint256 priceCount = 0;
for(uint i = 0; i < commodityLength; i++){
require(
tokenA.balanceOf(initial,_tokenId[i]) >= _amount[i],
"Insufficient balance"
);
require(
luxuryCommodityPrice[_tokenId[i]] > 0,
"no such product"
);
priceCount += luxuryCommodityPrice[_tokenId[i]] * _amount[i];
}
require(<FILL_ME>)
require(
tokenB.balanceOf(msg.sender) >= priceCount,
"Not enough Torch send"
);
uint256 DeadAmount = priceCount * DEADFee / 10 ** 2;
uint256 divideAmount = priceCount - DeadAmount;
tokenB.transferFrom(msg.sender, DEAD, DeadAmount);
tokenB.transferFrom(msg.sender, DivideReceiver, divideAmount);
tokenA.safeBatchTransferFrom(initial, msg.sender, _tokenId, _amount, "0x00");
}
function luxuryStoresSynthesis(uint256[] memory _tokenId,uint256[] memory _amount,uint256 _monsterTokenid) public{
}
function equipmentSynthesis(uint256[] memory _tokenId,uint256[] memory _amount,uint256 _monsterTokenid) public{
}
function setUpCommodityPrice(uint256[] memory _tokenId,uint256[] memory _amount) public onlyOwner {
}
function getIsCommodityTokenId(uint256 _tokenId) public view returns(bool){
}
function getCommodityPriceList() public view returns(uint256[] memory,uint256[] memory){
}
function setUpLuxuryCommodityPrice(uint256[] memory _tokenId,uint256[] memory _amount) public onlyOwner {
}
function getIsLuxuryCommodityTokenId(uint256 _tokenId) public view returns(bool){
}
function getLuxuryCommodityPriceList() public view returns(uint256[] memory,uint256[] memory){
}
function getGeneralStorePrice(uint256[] memory _tokenId,uint256[] memory _amount) public view returns(uint256){
}
function getLuxuryGeneralStorePrice(uint256[] memory _tokenId,uint256[] memory _amount) public view returns(uint256){
}
function setUpBusinessHours(uint256[] memory _timeDeta) public onlyOwner {
}
function getblocktimes() public view returns(uint256) {
}
function flipisCommonStore() public onlyOwner {
}
function flipisCommonSynthesis() public onlyOwner {
}
function flipisEquipmentSynthesis() public onlyOwner {
}
function flipisTimesSwitch() public onlyOwner {
}
function getBusinessHours() public view returns(uint256[2] memory){
}
function setTokenAContract(address _tokenA) public onlyOwner {
}
function setTokenBContract(address _tokenB) public onlyOwner {
}
function setTokenCContract(address _tokenC) public onlyOwner {
}
function setDivideReceiver(address _address) public onlyOwner {
}
function setDEADFee(uint256 _amount) public onlyOwner{
}
function setSpecialAddress(address _addr) public onlyOwner{
}
function setSpecial(uint256[] memory _tokenId,bool[] memory value) public onlyOwner{
}
function getSpecial(uint256[] memory _tokenId) public view returns(bool[] memory){
}
function setUpgradePackage(uint256[] memory _tokenId,bool[] memory value) public onlyOwner{
}
function getUpgradePackage(uint256[] memory _tokenId) public view returns(bool[] memory){
}
}
| tokenB.allowance(msg.sender,address(this))>=priceCount,"insufficient allowance" | 465,864 | tokenB.allowance(msg.sender,address(this))>=priceCount |
"Not enough Torch send" | // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `to`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address to, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `from` to `to` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
pragma solidity ^0.8.4;
contract CaveShop is Ownable {
IERC1155 public tokenA;
IERC20 public tokenB;
IERC20 public tokenC;
address public initial;
address public DivideReceiver = 0xeE7513e1cFf5aE8b6f18F68Dd6Ef908e577CC68f;
address constant DEAD = 0x000000000000000000000000000000000000dEaD;
address public specialAddress = 0xfAe2ac6097A334777c0901DC49adc65483096029;
uint256 public DEADFee = 60;
uint256[] private commodityTokenId;
mapping(uint256 => uint256) private commodityPrice;
uint256[] private luxuryCommodityTokenId;
mapping(uint256 => uint256) private luxuryCommodityPrice;
mapping(uint256 => bool) private special;
mapping(uint256 => bool) private upgradePackage;
bool public _isCommonStore = true;
bool public _isCommonSynthesis = true;
bool public _isEquipmentSynthesis = true;
bool public _isTimesSwitch = true;
uint256[2] private businessHours;
event Synthesis(address indexed from,uint256 indexed _tokenId, uint256 indexed _amount, uint256 value);
constructor(address _tokenA, address _tokenB, address _tokenC) {
}
function commonStore(uint256[] memory _tokenId,uint256[] memory _amount) public{
}
function commonSynthesis(uint256[] memory _tokenId,uint256[] memory _amount,uint256 _monsterTokenid) public{
}
function luxuryStores(uint256[] memory _tokenId,uint256[] memory _amount) public{
uint commodityLength = _tokenId.length;
uint commodityAmount = _amount.length;
require(
commodityLength == commodityAmount,
"Quantity does not match"
);
if(_isTimesSwitch){
require(
businessHours[0] < block.timestamp && businessHours[0] + businessHours[1] > block.timestamp,
"Business hours have not yet come"
);
}
uint256 priceCount = 0;
for(uint i = 0; i < commodityLength; i++){
require(
tokenA.balanceOf(initial,_tokenId[i]) >= _amount[i],
"Insufficient balance"
);
require(
luxuryCommodityPrice[_tokenId[i]] > 0,
"no such product"
);
priceCount += luxuryCommodityPrice[_tokenId[i]] * _amount[i];
}
require(
tokenB.allowance(msg.sender,address(this)) >= priceCount,
"insufficient allowance"
);
require(<FILL_ME>)
uint256 DeadAmount = priceCount * DEADFee / 10 ** 2;
uint256 divideAmount = priceCount - DeadAmount;
tokenB.transferFrom(msg.sender, DEAD, DeadAmount);
tokenB.transferFrom(msg.sender, DivideReceiver, divideAmount);
tokenA.safeBatchTransferFrom(initial, msg.sender, _tokenId, _amount, "0x00");
}
function luxuryStoresSynthesis(uint256[] memory _tokenId,uint256[] memory _amount,uint256 _monsterTokenid) public{
}
function equipmentSynthesis(uint256[] memory _tokenId,uint256[] memory _amount,uint256 _monsterTokenid) public{
}
function setUpCommodityPrice(uint256[] memory _tokenId,uint256[] memory _amount) public onlyOwner {
}
function getIsCommodityTokenId(uint256 _tokenId) public view returns(bool){
}
function getCommodityPriceList() public view returns(uint256[] memory,uint256[] memory){
}
function setUpLuxuryCommodityPrice(uint256[] memory _tokenId,uint256[] memory _amount) public onlyOwner {
}
function getIsLuxuryCommodityTokenId(uint256 _tokenId) public view returns(bool){
}
function getLuxuryCommodityPriceList() public view returns(uint256[] memory,uint256[] memory){
}
function getGeneralStorePrice(uint256[] memory _tokenId,uint256[] memory _amount) public view returns(uint256){
}
function getLuxuryGeneralStorePrice(uint256[] memory _tokenId,uint256[] memory _amount) public view returns(uint256){
}
function setUpBusinessHours(uint256[] memory _timeDeta) public onlyOwner {
}
function getblocktimes() public view returns(uint256) {
}
function flipisCommonStore() public onlyOwner {
}
function flipisCommonSynthesis() public onlyOwner {
}
function flipisEquipmentSynthesis() public onlyOwner {
}
function flipisTimesSwitch() public onlyOwner {
}
function getBusinessHours() public view returns(uint256[2] memory){
}
function setTokenAContract(address _tokenA) public onlyOwner {
}
function setTokenBContract(address _tokenB) public onlyOwner {
}
function setTokenCContract(address _tokenC) public onlyOwner {
}
function setDivideReceiver(address _address) public onlyOwner {
}
function setDEADFee(uint256 _amount) public onlyOwner{
}
function setSpecialAddress(address _addr) public onlyOwner{
}
function setSpecial(uint256[] memory _tokenId,bool[] memory value) public onlyOwner{
}
function getSpecial(uint256[] memory _tokenId) public view returns(bool[] memory){
}
function setUpgradePackage(uint256[] memory _tokenId,bool[] memory value) public onlyOwner{
}
function getUpgradePackage(uint256[] memory _tokenId) public view returns(bool[] memory){
}
}
| tokenB.balanceOf(msg.sender)>=priceCount,"Not enough Torch send" | 465,864 | tokenB.balanceOf(msg.sender)>=priceCount |
"Insufficient balance" | // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `to`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address to, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `from` to `to` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
pragma solidity ^0.8.4;
contract CaveShop is Ownable {
IERC1155 public tokenA;
IERC20 public tokenB;
IERC20 public tokenC;
address public initial;
address public DivideReceiver = 0xeE7513e1cFf5aE8b6f18F68Dd6Ef908e577CC68f;
address constant DEAD = 0x000000000000000000000000000000000000dEaD;
address public specialAddress = 0xfAe2ac6097A334777c0901DC49adc65483096029;
uint256 public DEADFee = 60;
uint256[] private commodityTokenId;
mapping(uint256 => uint256) private commodityPrice;
uint256[] private luxuryCommodityTokenId;
mapping(uint256 => uint256) private luxuryCommodityPrice;
mapping(uint256 => bool) private special;
mapping(uint256 => bool) private upgradePackage;
bool public _isCommonStore = true;
bool public _isCommonSynthesis = true;
bool public _isEquipmentSynthesis = true;
bool public _isTimesSwitch = true;
uint256[2] private businessHours;
event Synthesis(address indexed from,uint256 indexed _tokenId, uint256 indexed _amount, uint256 value);
constructor(address _tokenA, address _tokenB, address _tokenC) {
}
function commonStore(uint256[] memory _tokenId,uint256[] memory _amount) public{
}
function commonSynthesis(uint256[] memory _tokenId,uint256[] memory _amount,uint256 _monsterTokenid) public{
}
function luxuryStores(uint256[] memory _tokenId,uint256[] memory _amount) public{
}
function luxuryStoresSynthesis(uint256[] memory _tokenId,uint256[] memory _amount,uint256 _monsterTokenid) public{
}
function equipmentSynthesis(uint256[] memory _tokenId,uint256[] memory _amount,uint256 _monsterTokenid) public{
require(_isEquipmentSynthesis, "stoppage of business");
uint commodityLength = _tokenId.length;
uint commodityAmount = _amount.length;
require(
commodityLength == commodityAmount,
"Quantity does not match"
);
for(uint i = 0; i < commodityLength; i++){
require(<FILL_ME>)
emit Synthesis(msg.sender, _tokenId[i], _amount[i],_monsterTokenid);
}
tokenA.safeBatchTransferFrom(msg.sender, DEAD, _tokenId, _amount, "0x00");
}
function setUpCommodityPrice(uint256[] memory _tokenId,uint256[] memory _amount) public onlyOwner {
}
function getIsCommodityTokenId(uint256 _tokenId) public view returns(bool){
}
function getCommodityPriceList() public view returns(uint256[] memory,uint256[] memory){
}
function setUpLuxuryCommodityPrice(uint256[] memory _tokenId,uint256[] memory _amount) public onlyOwner {
}
function getIsLuxuryCommodityTokenId(uint256 _tokenId) public view returns(bool){
}
function getLuxuryCommodityPriceList() public view returns(uint256[] memory,uint256[] memory){
}
function getGeneralStorePrice(uint256[] memory _tokenId,uint256[] memory _amount) public view returns(uint256){
}
function getLuxuryGeneralStorePrice(uint256[] memory _tokenId,uint256[] memory _amount) public view returns(uint256){
}
function setUpBusinessHours(uint256[] memory _timeDeta) public onlyOwner {
}
function getblocktimes() public view returns(uint256) {
}
function flipisCommonStore() public onlyOwner {
}
function flipisCommonSynthesis() public onlyOwner {
}
function flipisEquipmentSynthesis() public onlyOwner {
}
function flipisTimesSwitch() public onlyOwner {
}
function getBusinessHours() public view returns(uint256[2] memory){
}
function setTokenAContract(address _tokenA) public onlyOwner {
}
function setTokenBContract(address _tokenB) public onlyOwner {
}
function setTokenCContract(address _tokenC) public onlyOwner {
}
function setDivideReceiver(address _address) public onlyOwner {
}
function setDEADFee(uint256 _amount) public onlyOwner{
}
function setSpecialAddress(address _addr) public onlyOwner{
}
function setSpecial(uint256[] memory _tokenId,bool[] memory value) public onlyOwner{
}
function getSpecial(uint256[] memory _tokenId) public view returns(bool[] memory){
}
function setUpgradePackage(uint256[] memory _tokenId,bool[] memory value) public onlyOwner{
}
function getUpgradePackage(uint256[] memory _tokenId) public view returns(bool[] memory){
}
}
| tokenA.balanceOf(msg.sender,_tokenId[i])>=_amount[i],"Insufficient balance" | 465,864 | tokenA.balanceOf(msg.sender,_tokenId[i])>=_amount[i] |
"In blacklist" | pragma solidity ^0.8.7;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
abstract contract Base721 is ERC721AQueryable, Ownable {
uint256 public maxSupply;
string public defaultURI;
string public baseURI;
mapping(uint256 => bool) public blackList;
using SafeERC20 for IERC20;
using Strings for uint256;
function adminMint(address _address, uint256 _num) external onlyOwner {
}
function withdrawETH(address payable _to) external onlyOwner {
}
function withdrawERC20(address _erc20, address _to) external onlyOwner {
}
function withdrawERC721(
address _erc721,
address _to,
uint256[] calldata _tokenIds
) external onlyOwner {
}
function withdrawERC1155(
address _erc1155,
address _to,
uint256[] calldata _ids,
uint256[] calldata _amounts,
bytes calldata _data
) external onlyOwner {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual override {
for (uint256 i = startTokenId; i < startTokenId + quantity; i++) {
require(<FILL_ME>)
}
}
function setBlackList(
uint256[] calldata _blackList,
bool _status
) external onlyOwner {
}
function setBaseURI(string memory _baseURI) public onlyOwner {
}
function setDefaultURI(string memory _defaultURI) public onlyOwner {
}
function tokenURI(
uint256 _tokenId
) public view override returns (string memory) {
}
}
| !blackList[i],"In blacklist" | 466,001 | !blackList[i] |
Subsets and Splits