comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"Native currency amount mismatch" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "./LockedStaking.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "../IMYCStakingManager.sol";
import "../IMYCStakingFactory.sol";
import "../../helpers/Mocks/IWETH.sol";
/// @title Locked Staking Factory
/// @notice Creates new LockedStaking Contracts
contract LockedStakingFactory is EIP712, IMYCStakingFactory {
/**
* @dev Emitted when withdawing MYC `reward` fees for `poolAddress`
*/
event WithdrawnMYCFees(address indexed poolAddress, uint256 reward);
error SignatureMismatch();
error TransactionOverdue();
error DatesSort();
error IncompleteArray();
error WrongExecutor();
IMYCStakingManager internal _mycStakingManager;
IWETH internal _WETH;
constructor(
IMYCStakingManager mycStakingManager_,
IWETH weth_
) EIP712("MyCointainer", "1") {
}
/**
* @dev Returns WETH address
*
*/
function WETH() external view returns (address) {
}
/**
* @dev Returns MyCointainer Staking Manager Contract Address
*
*/
function mycStakingManager() external view returns (address) {
}
/**
* @dev Returns signer address
*/
function signer() external view returns (address) {
}
/**
* @dev Returns signer address
*/
function treasury() external view returns (address) {
}
/**
* @dev Returns main owner address
*/
function owner() external view returns (address) {
}
/**
* @dev Creates {LockedStaking} new smart contract
*
*/
function createPool(
address poolOwner, // pool Owner
address tokenAddress, // staking token address
uint256[] memory durations, // for how long user cannot unstake
uint256[] memory maxTokensBeStaked, // maximum amount that can be staked amoung all stakers for each duration
uint256[] memory rewardsPool, // reward pool for each duration
uint256[] memory mycFeesPool, //myc fees pools for each duration
uint256[] memory maxStakingAmount, //max staking amount
uint256 dateStart, // start date for all pools
uint256 dateEnd, // end date for all pools
uint256 deadline,
bytes memory signature
) external payable{
//check pool owner
if (poolOwner != msg.sender && poolOwner != address(0)) {
revert WrongExecutor();
}
// checking dates
if (dateStart >= dateEnd) {
revert DatesSort();
}
// checking arrays
if (
durations.length != maxTokensBeStaked.length ||
maxTokensBeStaked.length != rewardsPool.length ||
rewardsPool.length != mycFeesPool.length ||
maxStakingAmount.length != mycFeesPool.length ||
durations.length == 0
) {
revert IncompleteArray();
}
if (block.timestamp > deadline) revert TransactionOverdue();
bytes32 typedHash = _hashTypedDataV4(
keccak256(
abi.encode(
keccak256(
"AddStakePoolData(address tokenAddress,address owner,uint256[] durations,uint256[] maxTokensBeStaked,uint256[] rewardsPool,uint256[] mycFeesPool,uint256[] maxStakingAmount,uint256 dateStart,uint256 dateEnd,uint256 deadline)"
),
tokenAddress,
poolOwner == address(0) ? address(0) : msg.sender,
keccak256(abi.encodePacked(durations)),
keccak256(abi.encodePacked(maxTokensBeStaked)),
keccak256(abi.encodePacked(rewardsPool)),
keccak256(abi.encodePacked(mycFeesPool)),
keccak256(abi.encodePacked(maxStakingAmount)),
dateStart,
dateEnd,
deadline
)
)
);
if (ECDSA.recover(typedHash, signature) != _mycStakingManager.signer())
revert SignatureMismatch();
LockedStaking createdPool = new LockedStaking{salt: bytes32(signature)}(
tokenAddress,
msg.sender,
durations,
maxTokensBeStaked,
rewardsPool,
mycFeesPool,
maxStakingAmount,
dateStart,
dateEnd
);
uint256 rewardPoolSum = 0;
uint256 mycFeeSum = 0;
for (uint256 i = 0; i < rewardsPool.length; i++) {
mycFeeSum += mycFeesPool[i];
rewardPoolSum += rewardsPool[i];
}
if(address(_WETH) == tokenAddress){
require(<FILL_ME>)
_WETH.deposit{value: msg.value}();
_WETH.transfer(address(createdPool),rewardPoolSum);
if(mycFeeSum>0){
_WETH.transfer(_mycStakingManager.treasury(),mycFeeSum);
}
}
else{
IERC20(tokenAddress).transferFrom(
msg.sender,
address(createdPool),
rewardPoolSum
);
if (mycFeeSum > 0) {
IERC20(tokenAddress).transferFrom(
msg.sender,
_mycStakingManager.treasury(),
mycFeeSum
);
}
}
_mycStakingManager.addStakingPool(
address(createdPool),
bytes32(signature)
);
}
}
| rewardPoolSum+mycFeeSum==msg.value,"Native currency amount mismatch" | 73,169 | rewardPoolSum+mycFeeSum==msg.value |
"DEQUANTIZATION_OVERFLOW" | /*
Copyright 2019-2021 StarkWare Industries Ltd.
Licensed under the Apache License, Version 2.0 (the "License").
You may not use this file except in compliance with the License.
You may obtain a copy of the License at
https://www.starkware.co/open-source-license/
Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions
and limitations under the License.
*/
// SPDX-License-Identifier: Apache-2.0.
pragma solidity ^0.6.11;
import "MainStorage.sol";
import "MTokenQuantization.sol";
contract TokenQuantization is MainStorage, MTokenQuantization {
function fromQuantized(uint256 presumedAssetType, uint256 quantizedAmount)
internal view override returns (uint256 amount) {
uint256 quantum = getQuantum(presumedAssetType);
amount = quantizedAmount * quantum;
require(<FILL_ME>)
}
function getQuantum(uint256 presumedAssetType) public view override returns (uint256 quantum) {
}
function toQuantized(uint256 presumedAssetType, uint256 amount)
internal view override returns (uint256 quantizedAmount) {
}
}
| amount/quantum==quantizedAmount,"DEQUANTIZATION_OVERFLOW" | 73,293 | amount/quantum==quantizedAmount |
"INVALID_AMOUNT" | /*
Copyright 2019-2021 StarkWare Industries Ltd.
Licensed under the Apache License, Version 2.0 (the "License").
You may not use this file except in compliance with the License.
You may obtain a copy of the License at
https://www.starkware.co/open-source-license/
Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions
and limitations under the License.
*/
// SPDX-License-Identifier: Apache-2.0.
pragma solidity ^0.6.11;
import "MainStorage.sol";
import "MTokenQuantization.sol";
contract TokenQuantization is MainStorage, MTokenQuantization {
function fromQuantized(uint256 presumedAssetType, uint256 quantizedAmount)
internal view override returns (uint256 amount) {
}
function getQuantum(uint256 presumedAssetType) public view override returns (uint256 quantum) {
}
function toQuantized(uint256 presumedAssetType, uint256 amount)
internal view override returns (uint256 quantizedAmount) {
uint256 quantum = getQuantum(presumedAssetType);
require(<FILL_ME>)
quantizedAmount = amount / quantum;
}
}
| amount%quantum==0,"INVALID_AMOUNT" | 73,293 | amount%quantum==0 |
Errors.CODEC_OVERFLOW | // SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity ^0.7.0;
import "@balancer-labs/v2-interfaces/contracts/solidity-utils/helpers/BalancerErrors.sol";
import "../math/Math.sol";
/**
* @dev Library for encoding and decoding values stored inside a 256 bit word. Typically used to pack multiple values in
* a single storage slot, saving gas by performing less storage accesses.
*
* Each value is defined by its size and the least significant bit in the word, also known as offset. For example, two
* 128 bit values may be encoded in a word by assigning one an offset of 0, and the other an offset of 128.
*
* We could use Solidity structs to pack values together in a single storage slot instead of relying on a custom and
* error-prone library, but unfortunately Solidity only allows for structs to live in either storage, calldata or
* memory. Because a memory struct uses not just memory but also a slot in the stack (to store its memory location),
* using memory for word-sized values (i.e. of 256 bits or less) is strictly less gas performant, and doesn't even
* prevent stack-too-deep issues. This is compounded by the fact that Balancer contracts typically are memory-intensive,
* and the cost of accesing memory increases quadratically with the number of allocated words. Manual packing and
* unpacking is therefore the preferred approach.
*/
library WordCodec {
// Masks are values with the least significant N bits set. They can be used to extract an encoded value from a word,
// or to insert a new one replacing the old.
uint256 private constant _MASK_1 = 2**(1) - 1;
uint256 private constant _MASK_192 = 2**(192) - 1;
// In-place insertion
/**
* @dev Inserts an unsigned integer of bitLength, shifted by an offset, into a 256 bit word,
* replacing the old value. Returns the new word.
*/
function insertUint(
bytes32 word,
uint256 value,
uint256 offset,
uint256 bitLength
) internal pure returns (bytes32) {
}
/**
* @dev Inserts a signed integer shifted by an offset into a 256 bit word, replacing the old value. Returns
* the new word.
*
* Assumes `value` can be represented using `bitLength` bits.
*/
function insertInt(
bytes32 word,
int256 value,
uint256 offset,
uint256 bitLength
) internal pure returns (bytes32) {
}
// Encoding
/**
* @dev Encodes an unsigned integer shifted by an offset. Ensures value fits within
* `bitLength` bits.
*
* The return value can be ORed bitwise with other encoded values to form a 256 bit word.
*/
function encodeUint(
uint256 value,
uint256 offset,
uint256 bitLength
) internal pure returns (bytes32) {
}
/**
* @dev Encodes a signed integer shifted by an offset.
*
* The return value can be ORed bitwise with other encoded values to form a 256 bit word.
*/
function encodeInt(
int256 value,
uint256 offset,
uint256 bitLength
) internal pure returns (bytes32) {
}
// Decoding
/**
* @dev Decodes and returns an unsigned integer with `bitLength` bits, shifted by an offset, from a 256 bit word.
*/
function decodeUint(
bytes32 word,
uint256 offset,
uint256 bitLength
) internal pure returns (uint256) {
}
/**
* @dev Decodes and returns a signed integer with `bitLength` bits, shifted by an offset, from a 256 bit word.
*/
function decodeInt(
bytes32 word,
uint256 offset,
uint256 bitLength
) internal pure returns (int256) {
}
// Special cases
/**
* @dev Decodes and returns a boolean shifted by an offset from a 256 bit word.
*/
function decodeBool(bytes32 word, uint256 offset) internal pure returns (bool) {
}
/**
* @dev Inserts a 192 bit value shifted by an offset into a 256 bit word, replacing the old value.
* Returns the new word.
*
* Assumes `value` can be represented using 192 bits.
*/
function insertBits192(
bytes32 word,
bytes32 value,
uint256 offset
) internal pure returns (bytes32) {
}
/**
* @dev Inserts a boolean value shifted by an offset into a 256 bit word, replacing the old value. Returns the new
* word.
*/
function insertBool(
bytes32 word,
bool value,
uint256 offset
) internal pure returns (bytes32) {
}
// Helpers
function _validateEncodingParams(
uint256 value,
uint256 offset,
uint256 bitLength
) private pure {
_require(offset < 256, Errors.OUT_OF_BOUNDS);
// We never accept 256 bit values (which would make the codec pointless), and the larger the offset the smaller
// the maximum bit length.
_require(bitLength >= 1 && bitLength <= Math.min(255, 256 - offset), Errors.OUT_OF_BOUNDS);
// Testing unsigned values for size is straightforward: their upper bits must be cleared.
require(<FILL_ME>)
}
function _validateEncodingParams(
int256 value,
uint256 offset,
uint256 bitLength
) private pure {
}
}
| (value>>bitLength==0,Errors.CODEC_OVERFLOW | 73,386 | value>>bitLength==0 |
Errors.CODEC_OVERFLOW | // SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity ^0.7.0;
import "@balancer-labs/v2-interfaces/contracts/solidity-utils/helpers/BalancerErrors.sol";
import "../math/Math.sol";
/**
* @dev Library for encoding and decoding values stored inside a 256 bit word. Typically used to pack multiple values in
* a single storage slot, saving gas by performing less storage accesses.
*
* Each value is defined by its size and the least significant bit in the word, also known as offset. For example, two
* 128 bit values may be encoded in a word by assigning one an offset of 0, and the other an offset of 128.
*
* We could use Solidity structs to pack values together in a single storage slot instead of relying on a custom and
* error-prone library, but unfortunately Solidity only allows for structs to live in either storage, calldata or
* memory. Because a memory struct uses not just memory but also a slot in the stack (to store its memory location),
* using memory for word-sized values (i.e. of 256 bits or less) is strictly less gas performant, and doesn't even
* prevent stack-too-deep issues. This is compounded by the fact that Balancer contracts typically are memory-intensive,
* and the cost of accesing memory increases quadratically with the number of allocated words. Manual packing and
* unpacking is therefore the preferred approach.
*/
library WordCodec {
// Masks are values with the least significant N bits set. They can be used to extract an encoded value from a word,
// or to insert a new one replacing the old.
uint256 private constant _MASK_1 = 2**(1) - 1;
uint256 private constant _MASK_192 = 2**(192) - 1;
// In-place insertion
/**
* @dev Inserts an unsigned integer of bitLength, shifted by an offset, into a 256 bit word,
* replacing the old value. Returns the new word.
*/
function insertUint(
bytes32 word,
uint256 value,
uint256 offset,
uint256 bitLength
) internal pure returns (bytes32) {
}
/**
* @dev Inserts a signed integer shifted by an offset into a 256 bit word, replacing the old value. Returns
* the new word.
*
* Assumes `value` can be represented using `bitLength` bits.
*/
function insertInt(
bytes32 word,
int256 value,
uint256 offset,
uint256 bitLength
) internal pure returns (bytes32) {
}
// Encoding
/**
* @dev Encodes an unsigned integer shifted by an offset. Ensures value fits within
* `bitLength` bits.
*
* The return value can be ORed bitwise with other encoded values to form a 256 bit word.
*/
function encodeUint(
uint256 value,
uint256 offset,
uint256 bitLength
) internal pure returns (bytes32) {
}
/**
* @dev Encodes a signed integer shifted by an offset.
*
* The return value can be ORed bitwise with other encoded values to form a 256 bit word.
*/
function encodeInt(
int256 value,
uint256 offset,
uint256 bitLength
) internal pure returns (bytes32) {
}
// Decoding
/**
* @dev Decodes and returns an unsigned integer with `bitLength` bits, shifted by an offset, from a 256 bit word.
*/
function decodeUint(
bytes32 word,
uint256 offset,
uint256 bitLength
) internal pure returns (uint256) {
}
/**
* @dev Decodes and returns a signed integer with `bitLength` bits, shifted by an offset, from a 256 bit word.
*/
function decodeInt(
bytes32 word,
uint256 offset,
uint256 bitLength
) internal pure returns (int256) {
}
// Special cases
/**
* @dev Decodes and returns a boolean shifted by an offset from a 256 bit word.
*/
function decodeBool(bytes32 word, uint256 offset) internal pure returns (bool) {
}
/**
* @dev Inserts a 192 bit value shifted by an offset into a 256 bit word, replacing the old value.
* Returns the new word.
*
* Assumes `value` can be represented using 192 bits.
*/
function insertBits192(
bytes32 word,
bytes32 value,
uint256 offset
) internal pure returns (bytes32) {
}
/**
* @dev Inserts a boolean value shifted by an offset into a 256 bit word, replacing the old value. Returns the new
* word.
*/
function insertBool(
bytes32 word,
bool value,
uint256 offset
) internal pure returns (bytes32) {
}
// Helpers
function _validateEncodingParams(
uint256 value,
uint256 offset,
uint256 bitLength
) private pure {
}
function _validateEncodingParams(
int256 value,
uint256 offset,
uint256 bitLength
) private pure {
_require(offset < 256, Errors.OUT_OF_BOUNDS);
// We never accept 256 bit values (which would make the codec pointless), and the larger the offset the smaller
// the maximum bit length.
_require(bitLength >= 1 && bitLength <= Math.min(255, 256 - offset), Errors.OUT_OF_BOUNDS);
// Testing signed values for size is a bit more involved.
if (value >= 0) {
// For positive values, we can simply check that the upper bits are clear. Notice we remove one bit from the
// length for the sign bit.
require(<FILL_ME>)
} else {
// Negative values can receive the same treatment by making them positive, with the caveat that the range
// for negative values in two's complement supports one more value than for the positive case.
_require(Math.abs(value + 1) >> (bitLength - 1) == 0, Errors.CODEC_OVERFLOW);
}
}
}
| (value>>(bitLength-1)==0,Errors.CODEC_OVERFLOW | 73,386 | value>>(bitLength-1)==0 |
Errors.CODEC_OVERFLOW | // SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity ^0.7.0;
import "@balancer-labs/v2-interfaces/contracts/solidity-utils/helpers/BalancerErrors.sol";
import "../math/Math.sol";
/**
* @dev Library for encoding and decoding values stored inside a 256 bit word. Typically used to pack multiple values in
* a single storage slot, saving gas by performing less storage accesses.
*
* Each value is defined by its size and the least significant bit in the word, also known as offset. For example, two
* 128 bit values may be encoded in a word by assigning one an offset of 0, and the other an offset of 128.
*
* We could use Solidity structs to pack values together in a single storage slot instead of relying on a custom and
* error-prone library, but unfortunately Solidity only allows for structs to live in either storage, calldata or
* memory. Because a memory struct uses not just memory but also a slot in the stack (to store its memory location),
* using memory for word-sized values (i.e. of 256 bits or less) is strictly less gas performant, and doesn't even
* prevent stack-too-deep issues. This is compounded by the fact that Balancer contracts typically are memory-intensive,
* and the cost of accesing memory increases quadratically with the number of allocated words. Manual packing and
* unpacking is therefore the preferred approach.
*/
library WordCodec {
// Masks are values with the least significant N bits set. They can be used to extract an encoded value from a word,
// or to insert a new one replacing the old.
uint256 private constant _MASK_1 = 2**(1) - 1;
uint256 private constant _MASK_192 = 2**(192) - 1;
// In-place insertion
/**
* @dev Inserts an unsigned integer of bitLength, shifted by an offset, into a 256 bit word,
* replacing the old value. Returns the new word.
*/
function insertUint(
bytes32 word,
uint256 value,
uint256 offset,
uint256 bitLength
) internal pure returns (bytes32) {
}
/**
* @dev Inserts a signed integer shifted by an offset into a 256 bit word, replacing the old value. Returns
* the new word.
*
* Assumes `value` can be represented using `bitLength` bits.
*/
function insertInt(
bytes32 word,
int256 value,
uint256 offset,
uint256 bitLength
) internal pure returns (bytes32) {
}
// Encoding
/**
* @dev Encodes an unsigned integer shifted by an offset. Ensures value fits within
* `bitLength` bits.
*
* The return value can be ORed bitwise with other encoded values to form a 256 bit word.
*/
function encodeUint(
uint256 value,
uint256 offset,
uint256 bitLength
) internal pure returns (bytes32) {
}
/**
* @dev Encodes a signed integer shifted by an offset.
*
* The return value can be ORed bitwise with other encoded values to form a 256 bit word.
*/
function encodeInt(
int256 value,
uint256 offset,
uint256 bitLength
) internal pure returns (bytes32) {
}
// Decoding
/**
* @dev Decodes and returns an unsigned integer with `bitLength` bits, shifted by an offset, from a 256 bit word.
*/
function decodeUint(
bytes32 word,
uint256 offset,
uint256 bitLength
) internal pure returns (uint256) {
}
/**
* @dev Decodes and returns a signed integer with `bitLength` bits, shifted by an offset, from a 256 bit word.
*/
function decodeInt(
bytes32 word,
uint256 offset,
uint256 bitLength
) internal pure returns (int256) {
}
// Special cases
/**
* @dev Decodes and returns a boolean shifted by an offset from a 256 bit word.
*/
function decodeBool(bytes32 word, uint256 offset) internal pure returns (bool) {
}
/**
* @dev Inserts a 192 bit value shifted by an offset into a 256 bit word, replacing the old value.
* Returns the new word.
*
* Assumes `value` can be represented using 192 bits.
*/
function insertBits192(
bytes32 word,
bytes32 value,
uint256 offset
) internal pure returns (bytes32) {
}
/**
* @dev Inserts a boolean value shifted by an offset into a 256 bit word, replacing the old value. Returns the new
* word.
*/
function insertBool(
bytes32 word,
bool value,
uint256 offset
) internal pure returns (bytes32) {
}
// Helpers
function _validateEncodingParams(
uint256 value,
uint256 offset,
uint256 bitLength
) private pure {
}
function _validateEncodingParams(
int256 value,
uint256 offset,
uint256 bitLength
) private pure {
_require(offset < 256, Errors.OUT_OF_BOUNDS);
// We never accept 256 bit values (which would make the codec pointless), and the larger the offset the smaller
// the maximum bit length.
_require(bitLength >= 1 && bitLength <= Math.min(255, 256 - offset), Errors.OUT_OF_BOUNDS);
// Testing signed values for size is a bit more involved.
if (value >= 0) {
// For positive values, we can simply check that the upper bits are clear. Notice we remove one bit from the
// length for the sign bit.
_require(value >> (bitLength - 1) == 0, Errors.CODEC_OVERFLOW);
} else {
// Negative values can receive the same treatment by making them positive, with the caveat that the range
// for negative values in two's complement supports one more value than for the positive case.
require(<FILL_ME>)
}
}
}
| (Math.abs(value+1)>>(bitLength-1)==0,Errors.CODEC_OVERFLOW | 73,386 | Math.abs(value+1)>>(bitLength-1)==0 |
"Not Available." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
import "./OpenzeppelinERC1155.sol";
contract AnniversaryOnEth1ByMetaani is ERC1155{
string public name = "Anniversary by Metaani";
address public owner;
uint private tokenId = 1;
mapping(address => bool) private mintedAddressMap;
uint public limited = 1000;
uint public minted = 0;
uint public endSaleDate = 1662994800;
bool public isStartingSale = false;
event freeMinted(address minter);
modifier isOwner(){
}
function isOnSale() internal view returns(bool){
}
constructor(string memory _ipfsURL) ERC1155(_ipfsURL){
}
function freeMint() public {
require(isStartingSale == true, "Coming soon.");
require(<FILL_ME>)
require(mintedAddressMap[_msgSender()] == false, "Already minted.");
require(minted < limited, "Reached limited.");
_mint(_msgSender(), tokenId, 1, "");
minted++;
mintedAddressMap[_msgSender()] = true;
emit freeMinted(_msgSender());
}
function toggleIsStartingSale() isOwner() public {
}
function afterThat(string memory _newuri) isOwner() public{
}
}
| isOnSale()==true,"Not Available." | 73,409 | isOnSale()==true |
"Already minted." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
import "./OpenzeppelinERC1155.sol";
contract AnniversaryOnEth1ByMetaani is ERC1155{
string public name = "Anniversary by Metaani";
address public owner;
uint private tokenId = 1;
mapping(address => bool) private mintedAddressMap;
uint public limited = 1000;
uint public minted = 0;
uint public endSaleDate = 1662994800;
bool public isStartingSale = false;
event freeMinted(address minter);
modifier isOwner(){
}
function isOnSale() internal view returns(bool){
}
constructor(string memory _ipfsURL) ERC1155(_ipfsURL){
}
function freeMint() public {
require(isStartingSale == true, "Coming soon.");
require(isOnSale() == true, "Not Available.");
require(<FILL_ME>)
require(minted < limited, "Reached limited.");
_mint(_msgSender(), tokenId, 1, "");
minted++;
mintedAddressMap[_msgSender()] = true;
emit freeMinted(_msgSender());
}
function toggleIsStartingSale() isOwner() public {
}
function afterThat(string memory _newuri) isOwner() public{
}
}
| mintedAddressMap[_msgSender()]==false,"Already minted." | 73,409 | mintedAddressMap[_msgSender()]==false |
"Shiniki: signature claim is invalid" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./interfaces/IShiniki.sol";
import "./interfaces/ISignatureVerifier.sol";
import "./ShinikiTransfer.sol";
import "./ERC721A.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
contract Shiniki is
Ownable,
IShiniki,
ERC721A,
ReentrancyGuard,
Pausable,
ERC2981,
ShinikiTransfer
{
// Info config
struct SaleConfig {
uint128 preSaleStartTime;
uint128 preSaleDuration;
uint128 publicSaleStartTime;
uint128 publicSaleDuration;
uint256 publicSalePrice;
}
// Info interface address signature
ISignatureVerifier public SIGNATURE_VERIFIER;
// Info config mint
SaleConfig public saleConfig;
// Check transfer when tokenId is locked
mapping(uint256 => bool) public stakingTransfer;
// Info number minted public
mapping(address => uint256) public numberPublicMinted;
// Info number minted pre
mapping(address => uint256) public numberPreMinted;
// Info locked
mapping(uint256 => bool) public locked;
event Lock(address locker, uint256 tokenId, uint64 startTimestampLock);
event UnLock(address unlocker, uint256 tokenId);
constructor(
address signatureVerifier,
uint256 collectionSize_,
uint256 maxBatchSize_,
uint256 amountMintDev_,
string memory defaultURI_
) ERC721A("LandOfGod", "LOG", collectionSize_, maxBatchSize_) {
}
/**
* @notice Validate caller
*/
modifier callerIsUser() {
}
/**
* @notice mint pre sale
* @param receiver 'address' receiver for nft
* @param typeMints array 'bytes32' type mint
* @param quantities array 'uint256' quantity for each type
* @param amountAllowce 'uint256' maximum quanity of user in whitelist
* @param nonce 'uint256' a number random
* @param signature 'bytes' a signature to verify data when mint nft
*/
function preSaleMint(
address receiver,
bytes32[] memory typeMints,
uint256[] memory quantities,
uint256 amountAllowce,
uint256 nonce,
bytes memory signature
) external override nonReentrant callerIsUser whenNotPaused {
require(receiver == msg.sender, "Shiniki: caller is not receiver");
require(<FILL_ME>)
uint256 totalMint = caculatorQuantity(typeMints, quantities);
require(
totalMint <= maxBatchSize,
"Shiniki: quantity to mint is less than maxBatchSize"
);
require(isPreSaleOn(), "Shiniki: pre sale has not begun yet");
require(
totalSupply() + totalMint <= collectionSize,
"Shiniki: reached max supply"
);
require(
numberPreMinted[msg.sender] + totalMint <= amountAllowce,
"Shiniki: can not mint greater than whiteList"
);
numberPreMinted[msg.sender] += totalMint;
for (uint8 i = 0; i < typeMints.length; i++) {
_safeMint(msg.sender, quantities[i], typeMints[i]);
}
}
/**
* @notice mint public sale
* @param typeMints array 'bytes32' type mint
* @param quantities array 'uint256' quantity for each type
*/
function publicSaleMint(
bytes32[] memory typeMints,
uint256[] memory quantities
) external payable override nonReentrant callerIsUser whenNotPaused {
}
/**
* @notice mint private
* @param receiver 'address' receiver when mint nft
* @param quantityType1 'uint256' quantity when mint nft by Type1
* @param quantityType2 'uint256' quantity when mint nft by Type2
*/
function privateMint(
address receiver,
uint256 quantityType1,
uint256 quantityType2
) public override onlyOwner whenNotPaused {
}
/**
* @notice caculate total quantity
* @param typeMints array 'bytes32' type mint
* @param quantities array 'uint256' quantity for each type
* @return 'uint256' total quantity user want to mint
*/
function caculatorQuantity(
bytes32[] memory typeMints,
uint256[] memory quantities
) internal view returns (uint256) {
}
/**
* @notice lock nft for staking
* @param tokenIds array 'uint256' tokenIds
*/
function lock(uint256[] memory tokenIds) public override {
}
/**
* @notice unlock nft for un-staking
* @param tokenIds array 'uint256' tokenIds
*/
function unlock(uint256[] memory tokenIds) public override {
}
/**
* @notice set base uri
* @param _typeMint array 'bytes32' type mint
* @param _baseURI array 'string' base uri
*/
function setBaseURI(bytes32[] memory _typeMint, string[] memory _baseURI)
external
onlyOwner
{
}
/**
* @notice set default uri
* @param _defaultURI 'string' default uri
*/
function setDefaultURI(string memory _defaultURI) external onlyOwner {
}
/**
* @notice set max batch size
* @param _maxBatchSize 'uint256' number new maxBatchSize
*/
function setMaxBatchSize(uint256 _maxBatchSize) external onlyOwner {
}
/**
@notice Setting new address signature
* @param _signatureVerifier 'address' signature
*/
function setSignatureVerifier(address _signatureVerifier)
external
onlyOwner
{
}
/**
* @notice check pre sale
* @return 'bool' status pre sale
*/
function isPreSaleOn() public view returns (bool) {
}
/**
* @notice check public sale
* @return 'bool' status public sale
*/
function isPublicSaleOn() public view returns (bool) {
}
/**
* @notice set pre sale config
* @param _preSaleStartTime 'uint128' start time pre sale
* @param _preSaleDuration 'uint128' duration time of pre sale
*/
function setPreSaleConfig(
uint128 _preSaleStartTime,
uint128 _preSaleDuration
) external onlyOwner {
}
/**
* @notice set public sale config
* @param _publicSaleStartTime 'uint128' start time public sale
* @param _publicSaleDuration 'uint128' duration time of public sale
* @param _publicSalePrice 'uint256' price of public sale for each nft
*/
function setPublicSaleConfig(
uint128 _publicSaleStartTime,
uint128 _publicSaleDuration,
uint256 _publicSalePrice
) external onlyOwner {
}
/**
* @notice set revealed
* @param _revealed 'bool' status revealed
*/
function setRevealed(bool _revealed) external onlyOwner {
}
/**
* @notice withdraw asset
* @param receiver 'address' receiver asset
* @param amount 'uint256' number asset to withdraw
*/
function withdraw(address receiver, uint256 amount)
external
override
onlyOwner
nonReentrant
{
}
/**
* @notice withdraw all asset
* @param receiver 'address' receiver asset
*/
function withdrawAll(address receiver)
external
override
onlyOwner
nonReentrant
{
}
/**
* @notice number minted
* @param owner 'address' user
*/
function numberMinted(address owner) public view returns (uint256) {
}
/**
* @notice get ownership data of a nft
* @param tokenId 'uint256' id of nft
* @return 'TokenOwnership' detail a nft
*/
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
/**
@notice Transfer a token between addresses while the Shiniki is staking
* @param from 'address' sender
* @param to 'address' receiver
* @param tokenId 'uint256' id of nft
*/
function safeTransferWhileStaking(
address from,
address to,
uint256 tokenId
) external override {
}
/**
@dev Pause the contract
*/
function pause() public onlyOwner {
}
/**
@dev Unpause the contract
*/
function unpause() public onlyOwner {
}
/**
@dev Block transfers while staking.
*/
function _beforeTokenTransfers(
address from,
address,
uint256 tokenId,
uint256
) internal view override {
}
/**
@notice Sets the contract-wide royalty info.
*/
function setRoyaltyInfo(address receiver, uint96 feeBasisPoints)
external
onlyOwner
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721A, ERC2981)
returns (bool)
{
}
}
| SIGNATURE_VERIFIER.verifyPreSaleMint(receiver,typeMints,quantities,amountAllowce,nonce,signature),"Shiniki: signature claim is invalid" | 73,474 | SIGNATURE_VERIFIER.verifyPreSaleMint(receiver,typeMints,quantities,amountAllowce,nonce,signature) |
"Shiniki: pre sale has not begun yet" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./interfaces/IShiniki.sol";
import "./interfaces/ISignatureVerifier.sol";
import "./ShinikiTransfer.sol";
import "./ERC721A.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
contract Shiniki is
Ownable,
IShiniki,
ERC721A,
ReentrancyGuard,
Pausable,
ERC2981,
ShinikiTransfer
{
// Info config
struct SaleConfig {
uint128 preSaleStartTime;
uint128 preSaleDuration;
uint128 publicSaleStartTime;
uint128 publicSaleDuration;
uint256 publicSalePrice;
}
// Info interface address signature
ISignatureVerifier public SIGNATURE_VERIFIER;
// Info config mint
SaleConfig public saleConfig;
// Check transfer when tokenId is locked
mapping(uint256 => bool) public stakingTransfer;
// Info number minted public
mapping(address => uint256) public numberPublicMinted;
// Info number minted pre
mapping(address => uint256) public numberPreMinted;
// Info locked
mapping(uint256 => bool) public locked;
event Lock(address locker, uint256 tokenId, uint64 startTimestampLock);
event UnLock(address unlocker, uint256 tokenId);
constructor(
address signatureVerifier,
uint256 collectionSize_,
uint256 maxBatchSize_,
uint256 amountMintDev_,
string memory defaultURI_
) ERC721A("LandOfGod", "LOG", collectionSize_, maxBatchSize_) {
}
/**
* @notice Validate caller
*/
modifier callerIsUser() {
}
/**
* @notice mint pre sale
* @param receiver 'address' receiver for nft
* @param typeMints array 'bytes32' type mint
* @param quantities array 'uint256' quantity for each type
* @param amountAllowce 'uint256' maximum quanity of user in whitelist
* @param nonce 'uint256' a number random
* @param signature 'bytes' a signature to verify data when mint nft
*/
function preSaleMint(
address receiver,
bytes32[] memory typeMints,
uint256[] memory quantities,
uint256 amountAllowce,
uint256 nonce,
bytes memory signature
) external override nonReentrant callerIsUser whenNotPaused {
require(receiver == msg.sender, "Shiniki: caller is not receiver");
require(
SIGNATURE_VERIFIER.verifyPreSaleMint(
receiver,
typeMints,
quantities,
amountAllowce,
nonce,
signature
),
"Shiniki: signature claim is invalid"
);
uint256 totalMint = caculatorQuantity(typeMints, quantities);
require(
totalMint <= maxBatchSize,
"Shiniki: quantity to mint is less than maxBatchSize"
);
require(<FILL_ME>)
require(
totalSupply() + totalMint <= collectionSize,
"Shiniki: reached max supply"
);
require(
numberPreMinted[msg.sender] + totalMint <= amountAllowce,
"Shiniki: can not mint greater than whiteList"
);
numberPreMinted[msg.sender] += totalMint;
for (uint8 i = 0; i < typeMints.length; i++) {
_safeMint(msg.sender, quantities[i], typeMints[i]);
}
}
/**
* @notice mint public sale
* @param typeMints array 'bytes32' type mint
* @param quantities array 'uint256' quantity for each type
*/
function publicSaleMint(
bytes32[] memory typeMints,
uint256[] memory quantities
) external payable override nonReentrant callerIsUser whenNotPaused {
}
/**
* @notice mint private
* @param receiver 'address' receiver when mint nft
* @param quantityType1 'uint256' quantity when mint nft by Type1
* @param quantityType2 'uint256' quantity when mint nft by Type2
*/
function privateMint(
address receiver,
uint256 quantityType1,
uint256 quantityType2
) public override onlyOwner whenNotPaused {
}
/**
* @notice caculate total quantity
* @param typeMints array 'bytes32' type mint
* @param quantities array 'uint256' quantity for each type
* @return 'uint256' total quantity user want to mint
*/
function caculatorQuantity(
bytes32[] memory typeMints,
uint256[] memory quantities
) internal view returns (uint256) {
}
/**
* @notice lock nft for staking
* @param tokenIds array 'uint256' tokenIds
*/
function lock(uint256[] memory tokenIds) public override {
}
/**
* @notice unlock nft for un-staking
* @param tokenIds array 'uint256' tokenIds
*/
function unlock(uint256[] memory tokenIds) public override {
}
/**
* @notice set base uri
* @param _typeMint array 'bytes32' type mint
* @param _baseURI array 'string' base uri
*/
function setBaseURI(bytes32[] memory _typeMint, string[] memory _baseURI)
external
onlyOwner
{
}
/**
* @notice set default uri
* @param _defaultURI 'string' default uri
*/
function setDefaultURI(string memory _defaultURI) external onlyOwner {
}
/**
* @notice set max batch size
* @param _maxBatchSize 'uint256' number new maxBatchSize
*/
function setMaxBatchSize(uint256 _maxBatchSize) external onlyOwner {
}
/**
@notice Setting new address signature
* @param _signatureVerifier 'address' signature
*/
function setSignatureVerifier(address _signatureVerifier)
external
onlyOwner
{
}
/**
* @notice check pre sale
* @return 'bool' status pre sale
*/
function isPreSaleOn() public view returns (bool) {
}
/**
* @notice check public sale
* @return 'bool' status public sale
*/
function isPublicSaleOn() public view returns (bool) {
}
/**
* @notice set pre sale config
* @param _preSaleStartTime 'uint128' start time pre sale
* @param _preSaleDuration 'uint128' duration time of pre sale
*/
function setPreSaleConfig(
uint128 _preSaleStartTime,
uint128 _preSaleDuration
) external onlyOwner {
}
/**
* @notice set public sale config
* @param _publicSaleStartTime 'uint128' start time public sale
* @param _publicSaleDuration 'uint128' duration time of public sale
* @param _publicSalePrice 'uint256' price of public sale for each nft
*/
function setPublicSaleConfig(
uint128 _publicSaleStartTime,
uint128 _publicSaleDuration,
uint256 _publicSalePrice
) external onlyOwner {
}
/**
* @notice set revealed
* @param _revealed 'bool' status revealed
*/
function setRevealed(bool _revealed) external onlyOwner {
}
/**
* @notice withdraw asset
* @param receiver 'address' receiver asset
* @param amount 'uint256' number asset to withdraw
*/
function withdraw(address receiver, uint256 amount)
external
override
onlyOwner
nonReentrant
{
}
/**
* @notice withdraw all asset
* @param receiver 'address' receiver asset
*/
function withdrawAll(address receiver)
external
override
onlyOwner
nonReentrant
{
}
/**
* @notice number minted
* @param owner 'address' user
*/
function numberMinted(address owner) public view returns (uint256) {
}
/**
* @notice get ownership data of a nft
* @param tokenId 'uint256' id of nft
* @return 'TokenOwnership' detail a nft
*/
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
/**
@notice Transfer a token between addresses while the Shiniki is staking
* @param from 'address' sender
* @param to 'address' receiver
* @param tokenId 'uint256' id of nft
*/
function safeTransferWhileStaking(
address from,
address to,
uint256 tokenId
) external override {
}
/**
@dev Pause the contract
*/
function pause() public onlyOwner {
}
/**
@dev Unpause the contract
*/
function unpause() public onlyOwner {
}
/**
@dev Block transfers while staking.
*/
function _beforeTokenTransfers(
address from,
address,
uint256 tokenId,
uint256
) internal view override {
}
/**
@notice Sets the contract-wide royalty info.
*/
function setRoyaltyInfo(address receiver, uint96 feeBasisPoints)
external
onlyOwner
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721A, ERC2981)
returns (bool)
{
}
}
| isPreSaleOn(),"Shiniki: pre sale has not begun yet" | 73,474 | isPreSaleOn() |
"Shiniki: reached max supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./interfaces/IShiniki.sol";
import "./interfaces/ISignatureVerifier.sol";
import "./ShinikiTransfer.sol";
import "./ERC721A.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
contract Shiniki is
Ownable,
IShiniki,
ERC721A,
ReentrancyGuard,
Pausable,
ERC2981,
ShinikiTransfer
{
// Info config
struct SaleConfig {
uint128 preSaleStartTime;
uint128 preSaleDuration;
uint128 publicSaleStartTime;
uint128 publicSaleDuration;
uint256 publicSalePrice;
}
// Info interface address signature
ISignatureVerifier public SIGNATURE_VERIFIER;
// Info config mint
SaleConfig public saleConfig;
// Check transfer when tokenId is locked
mapping(uint256 => bool) public stakingTransfer;
// Info number minted public
mapping(address => uint256) public numberPublicMinted;
// Info number minted pre
mapping(address => uint256) public numberPreMinted;
// Info locked
mapping(uint256 => bool) public locked;
event Lock(address locker, uint256 tokenId, uint64 startTimestampLock);
event UnLock(address unlocker, uint256 tokenId);
constructor(
address signatureVerifier,
uint256 collectionSize_,
uint256 maxBatchSize_,
uint256 amountMintDev_,
string memory defaultURI_
) ERC721A("LandOfGod", "LOG", collectionSize_, maxBatchSize_) {
}
/**
* @notice Validate caller
*/
modifier callerIsUser() {
}
/**
* @notice mint pre sale
* @param receiver 'address' receiver for nft
* @param typeMints array 'bytes32' type mint
* @param quantities array 'uint256' quantity for each type
* @param amountAllowce 'uint256' maximum quanity of user in whitelist
* @param nonce 'uint256' a number random
* @param signature 'bytes' a signature to verify data when mint nft
*/
function preSaleMint(
address receiver,
bytes32[] memory typeMints,
uint256[] memory quantities,
uint256 amountAllowce,
uint256 nonce,
bytes memory signature
) external override nonReentrant callerIsUser whenNotPaused {
require(receiver == msg.sender, "Shiniki: caller is not receiver");
require(
SIGNATURE_VERIFIER.verifyPreSaleMint(
receiver,
typeMints,
quantities,
amountAllowce,
nonce,
signature
),
"Shiniki: signature claim is invalid"
);
uint256 totalMint = caculatorQuantity(typeMints, quantities);
require(
totalMint <= maxBatchSize,
"Shiniki: quantity to mint is less than maxBatchSize"
);
require(isPreSaleOn(), "Shiniki: pre sale has not begun yet");
require(<FILL_ME>)
require(
numberPreMinted[msg.sender] + totalMint <= amountAllowce,
"Shiniki: can not mint greater than whiteList"
);
numberPreMinted[msg.sender] += totalMint;
for (uint8 i = 0; i < typeMints.length; i++) {
_safeMint(msg.sender, quantities[i], typeMints[i]);
}
}
/**
* @notice mint public sale
* @param typeMints array 'bytes32' type mint
* @param quantities array 'uint256' quantity for each type
*/
function publicSaleMint(
bytes32[] memory typeMints,
uint256[] memory quantities
) external payable override nonReentrant callerIsUser whenNotPaused {
}
/**
* @notice mint private
* @param receiver 'address' receiver when mint nft
* @param quantityType1 'uint256' quantity when mint nft by Type1
* @param quantityType2 'uint256' quantity when mint nft by Type2
*/
function privateMint(
address receiver,
uint256 quantityType1,
uint256 quantityType2
) public override onlyOwner whenNotPaused {
}
/**
* @notice caculate total quantity
* @param typeMints array 'bytes32' type mint
* @param quantities array 'uint256' quantity for each type
* @return 'uint256' total quantity user want to mint
*/
function caculatorQuantity(
bytes32[] memory typeMints,
uint256[] memory quantities
) internal view returns (uint256) {
}
/**
* @notice lock nft for staking
* @param tokenIds array 'uint256' tokenIds
*/
function lock(uint256[] memory tokenIds) public override {
}
/**
* @notice unlock nft for un-staking
* @param tokenIds array 'uint256' tokenIds
*/
function unlock(uint256[] memory tokenIds) public override {
}
/**
* @notice set base uri
* @param _typeMint array 'bytes32' type mint
* @param _baseURI array 'string' base uri
*/
function setBaseURI(bytes32[] memory _typeMint, string[] memory _baseURI)
external
onlyOwner
{
}
/**
* @notice set default uri
* @param _defaultURI 'string' default uri
*/
function setDefaultURI(string memory _defaultURI) external onlyOwner {
}
/**
* @notice set max batch size
* @param _maxBatchSize 'uint256' number new maxBatchSize
*/
function setMaxBatchSize(uint256 _maxBatchSize) external onlyOwner {
}
/**
@notice Setting new address signature
* @param _signatureVerifier 'address' signature
*/
function setSignatureVerifier(address _signatureVerifier)
external
onlyOwner
{
}
/**
* @notice check pre sale
* @return 'bool' status pre sale
*/
function isPreSaleOn() public view returns (bool) {
}
/**
* @notice check public sale
* @return 'bool' status public sale
*/
function isPublicSaleOn() public view returns (bool) {
}
/**
* @notice set pre sale config
* @param _preSaleStartTime 'uint128' start time pre sale
* @param _preSaleDuration 'uint128' duration time of pre sale
*/
function setPreSaleConfig(
uint128 _preSaleStartTime,
uint128 _preSaleDuration
) external onlyOwner {
}
/**
* @notice set public sale config
* @param _publicSaleStartTime 'uint128' start time public sale
* @param _publicSaleDuration 'uint128' duration time of public sale
* @param _publicSalePrice 'uint256' price of public sale for each nft
*/
function setPublicSaleConfig(
uint128 _publicSaleStartTime,
uint128 _publicSaleDuration,
uint256 _publicSalePrice
) external onlyOwner {
}
/**
* @notice set revealed
* @param _revealed 'bool' status revealed
*/
function setRevealed(bool _revealed) external onlyOwner {
}
/**
* @notice withdraw asset
* @param receiver 'address' receiver asset
* @param amount 'uint256' number asset to withdraw
*/
function withdraw(address receiver, uint256 amount)
external
override
onlyOwner
nonReentrant
{
}
/**
* @notice withdraw all asset
* @param receiver 'address' receiver asset
*/
function withdrawAll(address receiver)
external
override
onlyOwner
nonReentrant
{
}
/**
* @notice number minted
* @param owner 'address' user
*/
function numberMinted(address owner) public view returns (uint256) {
}
/**
* @notice get ownership data of a nft
* @param tokenId 'uint256' id of nft
* @return 'TokenOwnership' detail a nft
*/
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
/**
@notice Transfer a token between addresses while the Shiniki is staking
* @param from 'address' sender
* @param to 'address' receiver
* @param tokenId 'uint256' id of nft
*/
function safeTransferWhileStaking(
address from,
address to,
uint256 tokenId
) external override {
}
/**
@dev Pause the contract
*/
function pause() public onlyOwner {
}
/**
@dev Unpause the contract
*/
function unpause() public onlyOwner {
}
/**
@dev Block transfers while staking.
*/
function _beforeTokenTransfers(
address from,
address,
uint256 tokenId,
uint256
) internal view override {
}
/**
@notice Sets the contract-wide royalty info.
*/
function setRoyaltyInfo(address receiver, uint96 feeBasisPoints)
external
onlyOwner
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721A, ERC2981)
returns (bool)
{
}
}
| totalSupply()+totalMint<=collectionSize,"Shiniki: reached max supply" | 73,474 | totalSupply()+totalMint<=collectionSize |
"Shiniki: can not mint greater than whiteList" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./interfaces/IShiniki.sol";
import "./interfaces/ISignatureVerifier.sol";
import "./ShinikiTransfer.sol";
import "./ERC721A.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
contract Shiniki is
Ownable,
IShiniki,
ERC721A,
ReentrancyGuard,
Pausable,
ERC2981,
ShinikiTransfer
{
// Info config
struct SaleConfig {
uint128 preSaleStartTime;
uint128 preSaleDuration;
uint128 publicSaleStartTime;
uint128 publicSaleDuration;
uint256 publicSalePrice;
}
// Info interface address signature
ISignatureVerifier public SIGNATURE_VERIFIER;
// Info config mint
SaleConfig public saleConfig;
// Check transfer when tokenId is locked
mapping(uint256 => bool) public stakingTransfer;
// Info number minted public
mapping(address => uint256) public numberPublicMinted;
// Info number minted pre
mapping(address => uint256) public numberPreMinted;
// Info locked
mapping(uint256 => bool) public locked;
event Lock(address locker, uint256 tokenId, uint64 startTimestampLock);
event UnLock(address unlocker, uint256 tokenId);
constructor(
address signatureVerifier,
uint256 collectionSize_,
uint256 maxBatchSize_,
uint256 amountMintDev_,
string memory defaultURI_
) ERC721A("LandOfGod", "LOG", collectionSize_, maxBatchSize_) {
}
/**
* @notice Validate caller
*/
modifier callerIsUser() {
}
/**
* @notice mint pre sale
* @param receiver 'address' receiver for nft
* @param typeMints array 'bytes32' type mint
* @param quantities array 'uint256' quantity for each type
* @param amountAllowce 'uint256' maximum quanity of user in whitelist
* @param nonce 'uint256' a number random
* @param signature 'bytes' a signature to verify data when mint nft
*/
function preSaleMint(
address receiver,
bytes32[] memory typeMints,
uint256[] memory quantities,
uint256 amountAllowce,
uint256 nonce,
bytes memory signature
) external override nonReentrant callerIsUser whenNotPaused {
require(receiver == msg.sender, "Shiniki: caller is not receiver");
require(
SIGNATURE_VERIFIER.verifyPreSaleMint(
receiver,
typeMints,
quantities,
amountAllowce,
nonce,
signature
),
"Shiniki: signature claim is invalid"
);
uint256 totalMint = caculatorQuantity(typeMints, quantities);
require(
totalMint <= maxBatchSize,
"Shiniki: quantity to mint is less than maxBatchSize"
);
require(isPreSaleOn(), "Shiniki: pre sale has not begun yet");
require(
totalSupply() + totalMint <= collectionSize,
"Shiniki: reached max supply"
);
require(<FILL_ME>)
numberPreMinted[msg.sender] += totalMint;
for (uint8 i = 0; i < typeMints.length; i++) {
_safeMint(msg.sender, quantities[i], typeMints[i]);
}
}
/**
* @notice mint public sale
* @param typeMints array 'bytes32' type mint
* @param quantities array 'uint256' quantity for each type
*/
function publicSaleMint(
bytes32[] memory typeMints,
uint256[] memory quantities
) external payable override nonReentrant callerIsUser whenNotPaused {
}
/**
* @notice mint private
* @param receiver 'address' receiver when mint nft
* @param quantityType1 'uint256' quantity when mint nft by Type1
* @param quantityType2 'uint256' quantity when mint nft by Type2
*/
function privateMint(
address receiver,
uint256 quantityType1,
uint256 quantityType2
) public override onlyOwner whenNotPaused {
}
/**
* @notice caculate total quantity
* @param typeMints array 'bytes32' type mint
* @param quantities array 'uint256' quantity for each type
* @return 'uint256' total quantity user want to mint
*/
function caculatorQuantity(
bytes32[] memory typeMints,
uint256[] memory quantities
) internal view returns (uint256) {
}
/**
* @notice lock nft for staking
* @param tokenIds array 'uint256' tokenIds
*/
function lock(uint256[] memory tokenIds) public override {
}
/**
* @notice unlock nft for un-staking
* @param tokenIds array 'uint256' tokenIds
*/
function unlock(uint256[] memory tokenIds) public override {
}
/**
* @notice set base uri
* @param _typeMint array 'bytes32' type mint
* @param _baseURI array 'string' base uri
*/
function setBaseURI(bytes32[] memory _typeMint, string[] memory _baseURI)
external
onlyOwner
{
}
/**
* @notice set default uri
* @param _defaultURI 'string' default uri
*/
function setDefaultURI(string memory _defaultURI) external onlyOwner {
}
/**
* @notice set max batch size
* @param _maxBatchSize 'uint256' number new maxBatchSize
*/
function setMaxBatchSize(uint256 _maxBatchSize) external onlyOwner {
}
/**
@notice Setting new address signature
* @param _signatureVerifier 'address' signature
*/
function setSignatureVerifier(address _signatureVerifier)
external
onlyOwner
{
}
/**
* @notice check pre sale
* @return 'bool' status pre sale
*/
function isPreSaleOn() public view returns (bool) {
}
/**
* @notice check public sale
* @return 'bool' status public sale
*/
function isPublicSaleOn() public view returns (bool) {
}
/**
* @notice set pre sale config
* @param _preSaleStartTime 'uint128' start time pre sale
* @param _preSaleDuration 'uint128' duration time of pre sale
*/
function setPreSaleConfig(
uint128 _preSaleStartTime,
uint128 _preSaleDuration
) external onlyOwner {
}
/**
* @notice set public sale config
* @param _publicSaleStartTime 'uint128' start time public sale
* @param _publicSaleDuration 'uint128' duration time of public sale
* @param _publicSalePrice 'uint256' price of public sale for each nft
*/
function setPublicSaleConfig(
uint128 _publicSaleStartTime,
uint128 _publicSaleDuration,
uint256 _publicSalePrice
) external onlyOwner {
}
/**
* @notice set revealed
* @param _revealed 'bool' status revealed
*/
function setRevealed(bool _revealed) external onlyOwner {
}
/**
* @notice withdraw asset
* @param receiver 'address' receiver asset
* @param amount 'uint256' number asset to withdraw
*/
function withdraw(address receiver, uint256 amount)
external
override
onlyOwner
nonReentrant
{
}
/**
* @notice withdraw all asset
* @param receiver 'address' receiver asset
*/
function withdrawAll(address receiver)
external
override
onlyOwner
nonReentrant
{
}
/**
* @notice number minted
* @param owner 'address' user
*/
function numberMinted(address owner) public view returns (uint256) {
}
/**
* @notice get ownership data of a nft
* @param tokenId 'uint256' id of nft
* @return 'TokenOwnership' detail a nft
*/
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
/**
@notice Transfer a token between addresses while the Shiniki is staking
* @param from 'address' sender
* @param to 'address' receiver
* @param tokenId 'uint256' id of nft
*/
function safeTransferWhileStaking(
address from,
address to,
uint256 tokenId
) external override {
}
/**
@dev Pause the contract
*/
function pause() public onlyOwner {
}
/**
@dev Unpause the contract
*/
function unpause() public onlyOwner {
}
/**
@dev Block transfers while staking.
*/
function _beforeTokenTransfers(
address from,
address,
uint256 tokenId,
uint256
) internal view override {
}
/**
@notice Sets the contract-wide royalty info.
*/
function setRoyaltyInfo(address receiver, uint96 feeBasisPoints)
external
onlyOwner
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721A, ERC2981)
returns (bool)
{
}
}
| numberPreMinted[msg.sender]+totalMint<=amountAllowce,"Shiniki: can not mint greater than whiteList" | 73,474 | numberPreMinted[msg.sender]+totalMint<=amountAllowce |
"Shiniki: reached max supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./interfaces/IShiniki.sol";
import "./interfaces/ISignatureVerifier.sol";
import "./ShinikiTransfer.sol";
import "./ERC721A.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
contract Shiniki is
Ownable,
IShiniki,
ERC721A,
ReentrancyGuard,
Pausable,
ERC2981,
ShinikiTransfer
{
// Info config
struct SaleConfig {
uint128 preSaleStartTime;
uint128 preSaleDuration;
uint128 publicSaleStartTime;
uint128 publicSaleDuration;
uint256 publicSalePrice;
}
// Info interface address signature
ISignatureVerifier public SIGNATURE_VERIFIER;
// Info config mint
SaleConfig public saleConfig;
// Check transfer when tokenId is locked
mapping(uint256 => bool) public stakingTransfer;
// Info number minted public
mapping(address => uint256) public numberPublicMinted;
// Info number minted pre
mapping(address => uint256) public numberPreMinted;
// Info locked
mapping(uint256 => bool) public locked;
event Lock(address locker, uint256 tokenId, uint64 startTimestampLock);
event UnLock(address unlocker, uint256 tokenId);
constructor(
address signatureVerifier,
uint256 collectionSize_,
uint256 maxBatchSize_,
uint256 amountMintDev_,
string memory defaultURI_
) ERC721A("LandOfGod", "LOG", collectionSize_, maxBatchSize_) {
}
/**
* @notice Validate caller
*/
modifier callerIsUser() {
}
/**
* @notice mint pre sale
* @param receiver 'address' receiver for nft
* @param typeMints array 'bytes32' type mint
* @param quantities array 'uint256' quantity for each type
* @param amountAllowce 'uint256' maximum quanity of user in whitelist
* @param nonce 'uint256' a number random
* @param signature 'bytes' a signature to verify data when mint nft
*/
function preSaleMint(
address receiver,
bytes32[] memory typeMints,
uint256[] memory quantities,
uint256 amountAllowce,
uint256 nonce,
bytes memory signature
) external override nonReentrant callerIsUser whenNotPaused {
}
/**
* @notice mint public sale
* @param typeMints array 'bytes32' type mint
* @param quantities array 'uint256' quantity for each type
*/
function publicSaleMint(
bytes32[] memory typeMints,
uint256[] memory quantities
) external payable override nonReentrant callerIsUser whenNotPaused {
}
/**
* @notice mint private
* @param receiver 'address' receiver when mint nft
* @param quantityType1 'uint256' quantity when mint nft by Type1
* @param quantityType2 'uint256' quantity when mint nft by Type2
*/
function privateMint(
address receiver,
uint256 quantityType1,
uint256 quantityType2
) public override onlyOwner whenNotPaused {
require(<FILL_ME>)
//mint with type 1
if (quantityType1 != 0) {
require(
totalSupply(TYPE_1) + quantityType1 <= collectionSize / 2,
"Shiniki: type1 input is reached max supply"
);
_safeMint(receiver, quantityType1, TYPE_1);
}
//mint with type 2
if (quantityType2 != 0) {
require(
totalSupply(TYPE_2) + quantityType2 <=
(collectionSize - (collectionSize / 2)),
"Shiniki: type2 input is reached max supply"
);
_safeMint(receiver, quantityType2, TYPE_2);
}
}
/**
* @notice caculate total quantity
* @param typeMints array 'bytes32' type mint
* @param quantities array 'uint256' quantity for each type
* @return 'uint256' total quantity user want to mint
*/
function caculatorQuantity(
bytes32[] memory typeMints,
uint256[] memory quantities
) internal view returns (uint256) {
}
/**
* @notice lock nft for staking
* @param tokenIds array 'uint256' tokenIds
*/
function lock(uint256[] memory tokenIds) public override {
}
/**
* @notice unlock nft for un-staking
* @param tokenIds array 'uint256' tokenIds
*/
function unlock(uint256[] memory tokenIds) public override {
}
/**
* @notice set base uri
* @param _typeMint array 'bytes32' type mint
* @param _baseURI array 'string' base uri
*/
function setBaseURI(bytes32[] memory _typeMint, string[] memory _baseURI)
external
onlyOwner
{
}
/**
* @notice set default uri
* @param _defaultURI 'string' default uri
*/
function setDefaultURI(string memory _defaultURI) external onlyOwner {
}
/**
* @notice set max batch size
* @param _maxBatchSize 'uint256' number new maxBatchSize
*/
function setMaxBatchSize(uint256 _maxBatchSize) external onlyOwner {
}
/**
@notice Setting new address signature
* @param _signatureVerifier 'address' signature
*/
function setSignatureVerifier(address _signatureVerifier)
external
onlyOwner
{
}
/**
* @notice check pre sale
* @return 'bool' status pre sale
*/
function isPreSaleOn() public view returns (bool) {
}
/**
* @notice check public sale
* @return 'bool' status public sale
*/
function isPublicSaleOn() public view returns (bool) {
}
/**
* @notice set pre sale config
* @param _preSaleStartTime 'uint128' start time pre sale
* @param _preSaleDuration 'uint128' duration time of pre sale
*/
function setPreSaleConfig(
uint128 _preSaleStartTime,
uint128 _preSaleDuration
) external onlyOwner {
}
/**
* @notice set public sale config
* @param _publicSaleStartTime 'uint128' start time public sale
* @param _publicSaleDuration 'uint128' duration time of public sale
* @param _publicSalePrice 'uint256' price of public sale for each nft
*/
function setPublicSaleConfig(
uint128 _publicSaleStartTime,
uint128 _publicSaleDuration,
uint256 _publicSalePrice
) external onlyOwner {
}
/**
* @notice set revealed
* @param _revealed 'bool' status revealed
*/
function setRevealed(bool _revealed) external onlyOwner {
}
/**
* @notice withdraw asset
* @param receiver 'address' receiver asset
* @param amount 'uint256' number asset to withdraw
*/
function withdraw(address receiver, uint256 amount)
external
override
onlyOwner
nonReentrant
{
}
/**
* @notice withdraw all asset
* @param receiver 'address' receiver asset
*/
function withdrawAll(address receiver)
external
override
onlyOwner
nonReentrant
{
}
/**
* @notice number minted
* @param owner 'address' user
*/
function numberMinted(address owner) public view returns (uint256) {
}
/**
* @notice get ownership data of a nft
* @param tokenId 'uint256' id of nft
* @return 'TokenOwnership' detail a nft
*/
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
/**
@notice Transfer a token between addresses while the Shiniki is staking
* @param from 'address' sender
* @param to 'address' receiver
* @param tokenId 'uint256' id of nft
*/
function safeTransferWhileStaking(
address from,
address to,
uint256 tokenId
) external override {
}
/**
@dev Pause the contract
*/
function pause() public onlyOwner {
}
/**
@dev Unpause the contract
*/
function unpause() public onlyOwner {
}
/**
@dev Block transfers while staking.
*/
function _beforeTokenTransfers(
address from,
address,
uint256 tokenId,
uint256
) internal view override {
}
/**
@notice Sets the contract-wide royalty info.
*/
function setRoyaltyInfo(address receiver, uint96 feeBasisPoints)
external
onlyOwner
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721A, ERC2981)
returns (bool)
{
}
}
| totalSupply()+quantityType1+quantityType2<=collectionSize,"Shiniki: reached max supply" | 73,474 | totalSupply()+quantityType1+quantityType2<=collectionSize |
"Shiniki: type1 input is reached max supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./interfaces/IShiniki.sol";
import "./interfaces/ISignatureVerifier.sol";
import "./ShinikiTransfer.sol";
import "./ERC721A.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
contract Shiniki is
Ownable,
IShiniki,
ERC721A,
ReentrancyGuard,
Pausable,
ERC2981,
ShinikiTransfer
{
// Info config
struct SaleConfig {
uint128 preSaleStartTime;
uint128 preSaleDuration;
uint128 publicSaleStartTime;
uint128 publicSaleDuration;
uint256 publicSalePrice;
}
// Info interface address signature
ISignatureVerifier public SIGNATURE_VERIFIER;
// Info config mint
SaleConfig public saleConfig;
// Check transfer when tokenId is locked
mapping(uint256 => bool) public stakingTransfer;
// Info number minted public
mapping(address => uint256) public numberPublicMinted;
// Info number minted pre
mapping(address => uint256) public numberPreMinted;
// Info locked
mapping(uint256 => bool) public locked;
event Lock(address locker, uint256 tokenId, uint64 startTimestampLock);
event UnLock(address unlocker, uint256 tokenId);
constructor(
address signatureVerifier,
uint256 collectionSize_,
uint256 maxBatchSize_,
uint256 amountMintDev_,
string memory defaultURI_
) ERC721A("LandOfGod", "LOG", collectionSize_, maxBatchSize_) {
}
/**
* @notice Validate caller
*/
modifier callerIsUser() {
}
/**
* @notice mint pre sale
* @param receiver 'address' receiver for nft
* @param typeMints array 'bytes32' type mint
* @param quantities array 'uint256' quantity for each type
* @param amountAllowce 'uint256' maximum quanity of user in whitelist
* @param nonce 'uint256' a number random
* @param signature 'bytes' a signature to verify data when mint nft
*/
function preSaleMint(
address receiver,
bytes32[] memory typeMints,
uint256[] memory quantities,
uint256 amountAllowce,
uint256 nonce,
bytes memory signature
) external override nonReentrant callerIsUser whenNotPaused {
}
/**
* @notice mint public sale
* @param typeMints array 'bytes32' type mint
* @param quantities array 'uint256' quantity for each type
*/
function publicSaleMint(
bytes32[] memory typeMints,
uint256[] memory quantities
) external payable override nonReentrant callerIsUser whenNotPaused {
}
/**
* @notice mint private
* @param receiver 'address' receiver when mint nft
* @param quantityType1 'uint256' quantity when mint nft by Type1
* @param quantityType2 'uint256' quantity when mint nft by Type2
*/
function privateMint(
address receiver,
uint256 quantityType1,
uint256 quantityType2
) public override onlyOwner whenNotPaused {
require(
totalSupply() + quantityType1 + quantityType2 <= collectionSize,
"Shiniki: reached max supply"
);
//mint with type 1
if (quantityType1 != 0) {
require(<FILL_ME>)
_safeMint(receiver, quantityType1, TYPE_1);
}
//mint with type 2
if (quantityType2 != 0) {
require(
totalSupply(TYPE_2) + quantityType2 <=
(collectionSize - (collectionSize / 2)),
"Shiniki: type2 input is reached max supply"
);
_safeMint(receiver, quantityType2, TYPE_2);
}
}
/**
* @notice caculate total quantity
* @param typeMints array 'bytes32' type mint
* @param quantities array 'uint256' quantity for each type
* @return 'uint256' total quantity user want to mint
*/
function caculatorQuantity(
bytes32[] memory typeMints,
uint256[] memory quantities
) internal view returns (uint256) {
}
/**
* @notice lock nft for staking
* @param tokenIds array 'uint256' tokenIds
*/
function lock(uint256[] memory tokenIds) public override {
}
/**
* @notice unlock nft for un-staking
* @param tokenIds array 'uint256' tokenIds
*/
function unlock(uint256[] memory tokenIds) public override {
}
/**
* @notice set base uri
* @param _typeMint array 'bytes32' type mint
* @param _baseURI array 'string' base uri
*/
function setBaseURI(bytes32[] memory _typeMint, string[] memory _baseURI)
external
onlyOwner
{
}
/**
* @notice set default uri
* @param _defaultURI 'string' default uri
*/
function setDefaultURI(string memory _defaultURI) external onlyOwner {
}
/**
* @notice set max batch size
* @param _maxBatchSize 'uint256' number new maxBatchSize
*/
function setMaxBatchSize(uint256 _maxBatchSize) external onlyOwner {
}
/**
@notice Setting new address signature
* @param _signatureVerifier 'address' signature
*/
function setSignatureVerifier(address _signatureVerifier)
external
onlyOwner
{
}
/**
* @notice check pre sale
* @return 'bool' status pre sale
*/
function isPreSaleOn() public view returns (bool) {
}
/**
* @notice check public sale
* @return 'bool' status public sale
*/
function isPublicSaleOn() public view returns (bool) {
}
/**
* @notice set pre sale config
* @param _preSaleStartTime 'uint128' start time pre sale
* @param _preSaleDuration 'uint128' duration time of pre sale
*/
function setPreSaleConfig(
uint128 _preSaleStartTime,
uint128 _preSaleDuration
) external onlyOwner {
}
/**
* @notice set public sale config
* @param _publicSaleStartTime 'uint128' start time public sale
* @param _publicSaleDuration 'uint128' duration time of public sale
* @param _publicSalePrice 'uint256' price of public sale for each nft
*/
function setPublicSaleConfig(
uint128 _publicSaleStartTime,
uint128 _publicSaleDuration,
uint256 _publicSalePrice
) external onlyOwner {
}
/**
* @notice set revealed
* @param _revealed 'bool' status revealed
*/
function setRevealed(bool _revealed) external onlyOwner {
}
/**
* @notice withdraw asset
* @param receiver 'address' receiver asset
* @param amount 'uint256' number asset to withdraw
*/
function withdraw(address receiver, uint256 amount)
external
override
onlyOwner
nonReentrant
{
}
/**
* @notice withdraw all asset
* @param receiver 'address' receiver asset
*/
function withdrawAll(address receiver)
external
override
onlyOwner
nonReentrant
{
}
/**
* @notice number minted
* @param owner 'address' user
*/
function numberMinted(address owner) public view returns (uint256) {
}
/**
* @notice get ownership data of a nft
* @param tokenId 'uint256' id of nft
* @return 'TokenOwnership' detail a nft
*/
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
/**
@notice Transfer a token between addresses while the Shiniki is staking
* @param from 'address' sender
* @param to 'address' receiver
* @param tokenId 'uint256' id of nft
*/
function safeTransferWhileStaking(
address from,
address to,
uint256 tokenId
) external override {
}
/**
@dev Pause the contract
*/
function pause() public onlyOwner {
}
/**
@dev Unpause the contract
*/
function unpause() public onlyOwner {
}
/**
@dev Block transfers while staking.
*/
function _beforeTokenTransfers(
address from,
address,
uint256 tokenId,
uint256
) internal view override {
}
/**
@notice Sets the contract-wide royalty info.
*/
function setRoyaltyInfo(address receiver, uint96 feeBasisPoints)
external
onlyOwner
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721A, ERC2981)
returns (bool)
{
}
}
| totalSupply(TYPE_1)+quantityType1<=collectionSize/2,"Shiniki: type1 input is reached max supply" | 73,474 | totalSupply(TYPE_1)+quantityType1<=collectionSize/2 |
"Shiniki: type2 input is reached max supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./interfaces/IShiniki.sol";
import "./interfaces/ISignatureVerifier.sol";
import "./ShinikiTransfer.sol";
import "./ERC721A.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
contract Shiniki is
Ownable,
IShiniki,
ERC721A,
ReentrancyGuard,
Pausable,
ERC2981,
ShinikiTransfer
{
// Info config
struct SaleConfig {
uint128 preSaleStartTime;
uint128 preSaleDuration;
uint128 publicSaleStartTime;
uint128 publicSaleDuration;
uint256 publicSalePrice;
}
// Info interface address signature
ISignatureVerifier public SIGNATURE_VERIFIER;
// Info config mint
SaleConfig public saleConfig;
// Check transfer when tokenId is locked
mapping(uint256 => bool) public stakingTransfer;
// Info number minted public
mapping(address => uint256) public numberPublicMinted;
// Info number minted pre
mapping(address => uint256) public numberPreMinted;
// Info locked
mapping(uint256 => bool) public locked;
event Lock(address locker, uint256 tokenId, uint64 startTimestampLock);
event UnLock(address unlocker, uint256 tokenId);
constructor(
address signatureVerifier,
uint256 collectionSize_,
uint256 maxBatchSize_,
uint256 amountMintDev_,
string memory defaultURI_
) ERC721A("LandOfGod", "LOG", collectionSize_, maxBatchSize_) {
}
/**
* @notice Validate caller
*/
modifier callerIsUser() {
}
/**
* @notice mint pre sale
* @param receiver 'address' receiver for nft
* @param typeMints array 'bytes32' type mint
* @param quantities array 'uint256' quantity for each type
* @param amountAllowce 'uint256' maximum quanity of user in whitelist
* @param nonce 'uint256' a number random
* @param signature 'bytes' a signature to verify data when mint nft
*/
function preSaleMint(
address receiver,
bytes32[] memory typeMints,
uint256[] memory quantities,
uint256 amountAllowce,
uint256 nonce,
bytes memory signature
) external override nonReentrant callerIsUser whenNotPaused {
}
/**
* @notice mint public sale
* @param typeMints array 'bytes32' type mint
* @param quantities array 'uint256' quantity for each type
*/
function publicSaleMint(
bytes32[] memory typeMints,
uint256[] memory quantities
) external payable override nonReentrant callerIsUser whenNotPaused {
}
/**
* @notice mint private
* @param receiver 'address' receiver when mint nft
* @param quantityType1 'uint256' quantity when mint nft by Type1
* @param quantityType2 'uint256' quantity when mint nft by Type2
*/
function privateMint(
address receiver,
uint256 quantityType1,
uint256 quantityType2
) public override onlyOwner whenNotPaused {
require(
totalSupply() + quantityType1 + quantityType2 <= collectionSize,
"Shiniki: reached max supply"
);
//mint with type 1
if (quantityType1 != 0) {
require(
totalSupply(TYPE_1) + quantityType1 <= collectionSize / 2,
"Shiniki: type1 input is reached max supply"
);
_safeMint(receiver, quantityType1, TYPE_1);
}
//mint with type 2
if (quantityType2 != 0) {
require(<FILL_ME>)
_safeMint(receiver, quantityType2, TYPE_2);
}
}
/**
* @notice caculate total quantity
* @param typeMints array 'bytes32' type mint
* @param quantities array 'uint256' quantity for each type
* @return 'uint256' total quantity user want to mint
*/
function caculatorQuantity(
bytes32[] memory typeMints,
uint256[] memory quantities
) internal view returns (uint256) {
}
/**
* @notice lock nft for staking
* @param tokenIds array 'uint256' tokenIds
*/
function lock(uint256[] memory tokenIds) public override {
}
/**
* @notice unlock nft for un-staking
* @param tokenIds array 'uint256' tokenIds
*/
function unlock(uint256[] memory tokenIds) public override {
}
/**
* @notice set base uri
* @param _typeMint array 'bytes32' type mint
* @param _baseURI array 'string' base uri
*/
function setBaseURI(bytes32[] memory _typeMint, string[] memory _baseURI)
external
onlyOwner
{
}
/**
* @notice set default uri
* @param _defaultURI 'string' default uri
*/
function setDefaultURI(string memory _defaultURI) external onlyOwner {
}
/**
* @notice set max batch size
* @param _maxBatchSize 'uint256' number new maxBatchSize
*/
function setMaxBatchSize(uint256 _maxBatchSize) external onlyOwner {
}
/**
@notice Setting new address signature
* @param _signatureVerifier 'address' signature
*/
function setSignatureVerifier(address _signatureVerifier)
external
onlyOwner
{
}
/**
* @notice check pre sale
* @return 'bool' status pre sale
*/
function isPreSaleOn() public view returns (bool) {
}
/**
* @notice check public sale
* @return 'bool' status public sale
*/
function isPublicSaleOn() public view returns (bool) {
}
/**
* @notice set pre sale config
* @param _preSaleStartTime 'uint128' start time pre sale
* @param _preSaleDuration 'uint128' duration time of pre sale
*/
function setPreSaleConfig(
uint128 _preSaleStartTime,
uint128 _preSaleDuration
) external onlyOwner {
}
/**
* @notice set public sale config
* @param _publicSaleStartTime 'uint128' start time public sale
* @param _publicSaleDuration 'uint128' duration time of public sale
* @param _publicSalePrice 'uint256' price of public sale for each nft
*/
function setPublicSaleConfig(
uint128 _publicSaleStartTime,
uint128 _publicSaleDuration,
uint256 _publicSalePrice
) external onlyOwner {
}
/**
* @notice set revealed
* @param _revealed 'bool' status revealed
*/
function setRevealed(bool _revealed) external onlyOwner {
}
/**
* @notice withdraw asset
* @param receiver 'address' receiver asset
* @param amount 'uint256' number asset to withdraw
*/
function withdraw(address receiver, uint256 amount)
external
override
onlyOwner
nonReentrant
{
}
/**
* @notice withdraw all asset
* @param receiver 'address' receiver asset
*/
function withdrawAll(address receiver)
external
override
onlyOwner
nonReentrant
{
}
/**
* @notice number minted
* @param owner 'address' user
*/
function numberMinted(address owner) public view returns (uint256) {
}
/**
* @notice get ownership data of a nft
* @param tokenId 'uint256' id of nft
* @return 'TokenOwnership' detail a nft
*/
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
/**
@notice Transfer a token between addresses while the Shiniki is staking
* @param from 'address' sender
* @param to 'address' receiver
* @param tokenId 'uint256' id of nft
*/
function safeTransferWhileStaking(
address from,
address to,
uint256 tokenId
) external override {
}
/**
@dev Pause the contract
*/
function pause() public onlyOwner {
}
/**
@dev Unpause the contract
*/
function unpause() public onlyOwner {
}
/**
@dev Block transfers while staking.
*/
function _beforeTokenTransfers(
address from,
address,
uint256 tokenId,
uint256
) internal view override {
}
/**
@notice Sets the contract-wide royalty info.
*/
function setRoyaltyInfo(address receiver, uint96 feeBasisPoints)
external
onlyOwner
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721A, ERC2981)
returns (bool)
{
}
}
| totalSupply(TYPE_2)+quantityType2<=(collectionSize-(collectionSize/2)),"Shiniki: type2 input is reached max supply" | 73,474 | totalSupply(TYPE_2)+quantityType2<=(collectionSize-(collectionSize/2)) |
"Shiniki: input is invalid" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./interfaces/IShiniki.sol";
import "./interfaces/ISignatureVerifier.sol";
import "./ShinikiTransfer.sol";
import "./ERC721A.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
contract Shiniki is
Ownable,
IShiniki,
ERC721A,
ReentrancyGuard,
Pausable,
ERC2981,
ShinikiTransfer
{
// Info config
struct SaleConfig {
uint128 preSaleStartTime;
uint128 preSaleDuration;
uint128 publicSaleStartTime;
uint128 publicSaleDuration;
uint256 publicSalePrice;
}
// Info interface address signature
ISignatureVerifier public SIGNATURE_VERIFIER;
// Info config mint
SaleConfig public saleConfig;
// Check transfer when tokenId is locked
mapping(uint256 => bool) public stakingTransfer;
// Info number minted public
mapping(address => uint256) public numberPublicMinted;
// Info number minted pre
mapping(address => uint256) public numberPreMinted;
// Info locked
mapping(uint256 => bool) public locked;
event Lock(address locker, uint256 tokenId, uint64 startTimestampLock);
event UnLock(address unlocker, uint256 tokenId);
constructor(
address signatureVerifier,
uint256 collectionSize_,
uint256 maxBatchSize_,
uint256 amountMintDev_,
string memory defaultURI_
) ERC721A("LandOfGod", "LOG", collectionSize_, maxBatchSize_) {
}
/**
* @notice Validate caller
*/
modifier callerIsUser() {
}
/**
* @notice mint pre sale
* @param receiver 'address' receiver for nft
* @param typeMints array 'bytes32' type mint
* @param quantities array 'uint256' quantity for each type
* @param amountAllowce 'uint256' maximum quanity of user in whitelist
* @param nonce 'uint256' a number random
* @param signature 'bytes' a signature to verify data when mint nft
*/
function preSaleMint(
address receiver,
bytes32[] memory typeMints,
uint256[] memory quantities,
uint256 amountAllowce,
uint256 nonce,
bytes memory signature
) external override nonReentrant callerIsUser whenNotPaused {
}
/**
* @notice mint public sale
* @param typeMints array 'bytes32' type mint
* @param quantities array 'uint256' quantity for each type
*/
function publicSaleMint(
bytes32[] memory typeMints,
uint256[] memory quantities
) external payable override nonReentrant callerIsUser whenNotPaused {
}
/**
* @notice mint private
* @param receiver 'address' receiver when mint nft
* @param quantityType1 'uint256' quantity when mint nft by Type1
* @param quantityType2 'uint256' quantity when mint nft by Type2
*/
function privateMint(
address receiver,
uint256 quantityType1,
uint256 quantityType2
) public override onlyOwner whenNotPaused {
}
/**
* @notice caculate total quantity
* @param typeMints array 'bytes32' type mint
* @param quantities array 'uint256' quantity for each type
* @return 'uint256' total quantity user want to mint
*/
function caculatorQuantity(
bytes32[] memory typeMints,
uint256[] memory quantities
) internal view returns (uint256) {
uint256 totalQuantity = 0;
require(<FILL_ME>)
for (uint8 i = 0; i < typeMints.length; i++) {
require(
(typeMints[i] == TYPE_1 || typeMints[i] == TYPE_2),
"Shiniki: type input is invalid"
);
if (typeMints[i] == TYPE_1) {
require(
totalSupply(typeMints[i]) + quantities[i] <=
collectionSize / 2,
"Shiniki: type1 input is reached max supply"
);
} else {
require(
quantities[i] + totalSupply(typeMints[i]) <=
(collectionSize - (collectionSize / 2)),
"Shiniki: type2 input is reached max supply"
);
}
totalQuantity += quantities[i];
}
return totalQuantity;
}
/**
* @notice lock nft for staking
* @param tokenIds array 'uint256' tokenIds
*/
function lock(uint256[] memory tokenIds) public override {
}
/**
* @notice unlock nft for un-staking
* @param tokenIds array 'uint256' tokenIds
*/
function unlock(uint256[] memory tokenIds) public override {
}
/**
* @notice set base uri
* @param _typeMint array 'bytes32' type mint
* @param _baseURI array 'string' base uri
*/
function setBaseURI(bytes32[] memory _typeMint, string[] memory _baseURI)
external
onlyOwner
{
}
/**
* @notice set default uri
* @param _defaultURI 'string' default uri
*/
function setDefaultURI(string memory _defaultURI) external onlyOwner {
}
/**
* @notice set max batch size
* @param _maxBatchSize 'uint256' number new maxBatchSize
*/
function setMaxBatchSize(uint256 _maxBatchSize) external onlyOwner {
}
/**
@notice Setting new address signature
* @param _signatureVerifier 'address' signature
*/
function setSignatureVerifier(address _signatureVerifier)
external
onlyOwner
{
}
/**
* @notice check pre sale
* @return 'bool' status pre sale
*/
function isPreSaleOn() public view returns (bool) {
}
/**
* @notice check public sale
* @return 'bool' status public sale
*/
function isPublicSaleOn() public view returns (bool) {
}
/**
* @notice set pre sale config
* @param _preSaleStartTime 'uint128' start time pre sale
* @param _preSaleDuration 'uint128' duration time of pre sale
*/
function setPreSaleConfig(
uint128 _preSaleStartTime,
uint128 _preSaleDuration
) external onlyOwner {
}
/**
* @notice set public sale config
* @param _publicSaleStartTime 'uint128' start time public sale
* @param _publicSaleDuration 'uint128' duration time of public sale
* @param _publicSalePrice 'uint256' price of public sale for each nft
*/
function setPublicSaleConfig(
uint128 _publicSaleStartTime,
uint128 _publicSaleDuration,
uint256 _publicSalePrice
) external onlyOwner {
}
/**
* @notice set revealed
* @param _revealed 'bool' status revealed
*/
function setRevealed(bool _revealed) external onlyOwner {
}
/**
* @notice withdraw asset
* @param receiver 'address' receiver asset
* @param amount 'uint256' number asset to withdraw
*/
function withdraw(address receiver, uint256 amount)
external
override
onlyOwner
nonReentrant
{
}
/**
* @notice withdraw all asset
* @param receiver 'address' receiver asset
*/
function withdrawAll(address receiver)
external
override
onlyOwner
nonReentrant
{
}
/**
* @notice number minted
* @param owner 'address' user
*/
function numberMinted(address owner) public view returns (uint256) {
}
/**
* @notice get ownership data of a nft
* @param tokenId 'uint256' id of nft
* @return 'TokenOwnership' detail a nft
*/
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
/**
@notice Transfer a token between addresses while the Shiniki is staking
* @param from 'address' sender
* @param to 'address' receiver
* @param tokenId 'uint256' id of nft
*/
function safeTransferWhileStaking(
address from,
address to,
uint256 tokenId
) external override {
}
/**
@dev Pause the contract
*/
function pause() public onlyOwner {
}
/**
@dev Unpause the contract
*/
function unpause() public onlyOwner {
}
/**
@dev Block transfers while staking.
*/
function _beforeTokenTransfers(
address from,
address,
uint256 tokenId,
uint256
) internal view override {
}
/**
@notice Sets the contract-wide royalty info.
*/
function setRoyaltyInfo(address receiver, uint96 feeBasisPoints)
external
onlyOwner
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721A, ERC2981)
returns (bool)
{
}
}
| (typeMints.length==quantities.length),"Shiniki: input is invalid" | 73,474 | (typeMints.length==quantities.length) |
"Shiniki: type input is invalid" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./interfaces/IShiniki.sol";
import "./interfaces/ISignatureVerifier.sol";
import "./ShinikiTransfer.sol";
import "./ERC721A.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
contract Shiniki is
Ownable,
IShiniki,
ERC721A,
ReentrancyGuard,
Pausable,
ERC2981,
ShinikiTransfer
{
// Info config
struct SaleConfig {
uint128 preSaleStartTime;
uint128 preSaleDuration;
uint128 publicSaleStartTime;
uint128 publicSaleDuration;
uint256 publicSalePrice;
}
// Info interface address signature
ISignatureVerifier public SIGNATURE_VERIFIER;
// Info config mint
SaleConfig public saleConfig;
// Check transfer when tokenId is locked
mapping(uint256 => bool) public stakingTransfer;
// Info number minted public
mapping(address => uint256) public numberPublicMinted;
// Info number minted pre
mapping(address => uint256) public numberPreMinted;
// Info locked
mapping(uint256 => bool) public locked;
event Lock(address locker, uint256 tokenId, uint64 startTimestampLock);
event UnLock(address unlocker, uint256 tokenId);
constructor(
address signatureVerifier,
uint256 collectionSize_,
uint256 maxBatchSize_,
uint256 amountMintDev_,
string memory defaultURI_
) ERC721A("LandOfGod", "LOG", collectionSize_, maxBatchSize_) {
}
/**
* @notice Validate caller
*/
modifier callerIsUser() {
}
/**
* @notice mint pre sale
* @param receiver 'address' receiver for nft
* @param typeMints array 'bytes32' type mint
* @param quantities array 'uint256' quantity for each type
* @param amountAllowce 'uint256' maximum quanity of user in whitelist
* @param nonce 'uint256' a number random
* @param signature 'bytes' a signature to verify data when mint nft
*/
function preSaleMint(
address receiver,
bytes32[] memory typeMints,
uint256[] memory quantities,
uint256 amountAllowce,
uint256 nonce,
bytes memory signature
) external override nonReentrant callerIsUser whenNotPaused {
}
/**
* @notice mint public sale
* @param typeMints array 'bytes32' type mint
* @param quantities array 'uint256' quantity for each type
*/
function publicSaleMint(
bytes32[] memory typeMints,
uint256[] memory quantities
) external payable override nonReentrant callerIsUser whenNotPaused {
}
/**
* @notice mint private
* @param receiver 'address' receiver when mint nft
* @param quantityType1 'uint256' quantity when mint nft by Type1
* @param quantityType2 'uint256' quantity when mint nft by Type2
*/
function privateMint(
address receiver,
uint256 quantityType1,
uint256 quantityType2
) public override onlyOwner whenNotPaused {
}
/**
* @notice caculate total quantity
* @param typeMints array 'bytes32' type mint
* @param quantities array 'uint256' quantity for each type
* @return 'uint256' total quantity user want to mint
*/
function caculatorQuantity(
bytes32[] memory typeMints,
uint256[] memory quantities
) internal view returns (uint256) {
uint256 totalQuantity = 0;
require(
(typeMints.length == quantities.length),
"Shiniki: input is invalid"
);
for (uint8 i = 0; i < typeMints.length; i++) {
require(<FILL_ME>)
if (typeMints[i] == TYPE_1) {
require(
totalSupply(typeMints[i]) + quantities[i] <=
collectionSize / 2,
"Shiniki: type1 input is reached max supply"
);
} else {
require(
quantities[i] + totalSupply(typeMints[i]) <=
(collectionSize - (collectionSize / 2)),
"Shiniki: type2 input is reached max supply"
);
}
totalQuantity += quantities[i];
}
return totalQuantity;
}
/**
* @notice lock nft for staking
* @param tokenIds array 'uint256' tokenIds
*/
function lock(uint256[] memory tokenIds) public override {
}
/**
* @notice unlock nft for un-staking
* @param tokenIds array 'uint256' tokenIds
*/
function unlock(uint256[] memory tokenIds) public override {
}
/**
* @notice set base uri
* @param _typeMint array 'bytes32' type mint
* @param _baseURI array 'string' base uri
*/
function setBaseURI(bytes32[] memory _typeMint, string[] memory _baseURI)
external
onlyOwner
{
}
/**
* @notice set default uri
* @param _defaultURI 'string' default uri
*/
function setDefaultURI(string memory _defaultURI) external onlyOwner {
}
/**
* @notice set max batch size
* @param _maxBatchSize 'uint256' number new maxBatchSize
*/
function setMaxBatchSize(uint256 _maxBatchSize) external onlyOwner {
}
/**
@notice Setting new address signature
* @param _signatureVerifier 'address' signature
*/
function setSignatureVerifier(address _signatureVerifier)
external
onlyOwner
{
}
/**
* @notice check pre sale
* @return 'bool' status pre sale
*/
function isPreSaleOn() public view returns (bool) {
}
/**
* @notice check public sale
* @return 'bool' status public sale
*/
function isPublicSaleOn() public view returns (bool) {
}
/**
* @notice set pre sale config
* @param _preSaleStartTime 'uint128' start time pre sale
* @param _preSaleDuration 'uint128' duration time of pre sale
*/
function setPreSaleConfig(
uint128 _preSaleStartTime,
uint128 _preSaleDuration
) external onlyOwner {
}
/**
* @notice set public sale config
* @param _publicSaleStartTime 'uint128' start time public sale
* @param _publicSaleDuration 'uint128' duration time of public sale
* @param _publicSalePrice 'uint256' price of public sale for each nft
*/
function setPublicSaleConfig(
uint128 _publicSaleStartTime,
uint128 _publicSaleDuration,
uint256 _publicSalePrice
) external onlyOwner {
}
/**
* @notice set revealed
* @param _revealed 'bool' status revealed
*/
function setRevealed(bool _revealed) external onlyOwner {
}
/**
* @notice withdraw asset
* @param receiver 'address' receiver asset
* @param amount 'uint256' number asset to withdraw
*/
function withdraw(address receiver, uint256 amount)
external
override
onlyOwner
nonReentrant
{
}
/**
* @notice withdraw all asset
* @param receiver 'address' receiver asset
*/
function withdrawAll(address receiver)
external
override
onlyOwner
nonReentrant
{
}
/**
* @notice number minted
* @param owner 'address' user
*/
function numberMinted(address owner) public view returns (uint256) {
}
/**
* @notice get ownership data of a nft
* @param tokenId 'uint256' id of nft
* @return 'TokenOwnership' detail a nft
*/
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
/**
@notice Transfer a token between addresses while the Shiniki is staking
* @param from 'address' sender
* @param to 'address' receiver
* @param tokenId 'uint256' id of nft
*/
function safeTransferWhileStaking(
address from,
address to,
uint256 tokenId
) external override {
}
/**
@dev Pause the contract
*/
function pause() public onlyOwner {
}
/**
@dev Unpause the contract
*/
function unpause() public onlyOwner {
}
/**
@dev Block transfers while staking.
*/
function _beforeTokenTransfers(
address from,
address,
uint256 tokenId,
uint256
) internal view override {
}
/**
@notice Sets the contract-wide royalty info.
*/
function setRoyaltyInfo(address receiver, uint96 feeBasisPoints)
external
onlyOwner
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721A, ERC2981)
returns (bool)
{
}
}
| (typeMints[i]==TYPE_1||typeMints[i]==TYPE_2),"Shiniki: type input is invalid" | 73,474 | (typeMints[i]==TYPE_1||typeMints[i]==TYPE_2) |
"Shiniki: type1 input is reached max supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./interfaces/IShiniki.sol";
import "./interfaces/ISignatureVerifier.sol";
import "./ShinikiTransfer.sol";
import "./ERC721A.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
contract Shiniki is
Ownable,
IShiniki,
ERC721A,
ReentrancyGuard,
Pausable,
ERC2981,
ShinikiTransfer
{
// Info config
struct SaleConfig {
uint128 preSaleStartTime;
uint128 preSaleDuration;
uint128 publicSaleStartTime;
uint128 publicSaleDuration;
uint256 publicSalePrice;
}
// Info interface address signature
ISignatureVerifier public SIGNATURE_VERIFIER;
// Info config mint
SaleConfig public saleConfig;
// Check transfer when tokenId is locked
mapping(uint256 => bool) public stakingTransfer;
// Info number minted public
mapping(address => uint256) public numberPublicMinted;
// Info number minted pre
mapping(address => uint256) public numberPreMinted;
// Info locked
mapping(uint256 => bool) public locked;
event Lock(address locker, uint256 tokenId, uint64 startTimestampLock);
event UnLock(address unlocker, uint256 tokenId);
constructor(
address signatureVerifier,
uint256 collectionSize_,
uint256 maxBatchSize_,
uint256 amountMintDev_,
string memory defaultURI_
) ERC721A("LandOfGod", "LOG", collectionSize_, maxBatchSize_) {
}
/**
* @notice Validate caller
*/
modifier callerIsUser() {
}
/**
* @notice mint pre sale
* @param receiver 'address' receiver for nft
* @param typeMints array 'bytes32' type mint
* @param quantities array 'uint256' quantity for each type
* @param amountAllowce 'uint256' maximum quanity of user in whitelist
* @param nonce 'uint256' a number random
* @param signature 'bytes' a signature to verify data when mint nft
*/
function preSaleMint(
address receiver,
bytes32[] memory typeMints,
uint256[] memory quantities,
uint256 amountAllowce,
uint256 nonce,
bytes memory signature
) external override nonReentrant callerIsUser whenNotPaused {
}
/**
* @notice mint public sale
* @param typeMints array 'bytes32' type mint
* @param quantities array 'uint256' quantity for each type
*/
function publicSaleMint(
bytes32[] memory typeMints,
uint256[] memory quantities
) external payable override nonReentrant callerIsUser whenNotPaused {
}
/**
* @notice mint private
* @param receiver 'address' receiver when mint nft
* @param quantityType1 'uint256' quantity when mint nft by Type1
* @param quantityType2 'uint256' quantity when mint nft by Type2
*/
function privateMint(
address receiver,
uint256 quantityType1,
uint256 quantityType2
) public override onlyOwner whenNotPaused {
}
/**
* @notice caculate total quantity
* @param typeMints array 'bytes32' type mint
* @param quantities array 'uint256' quantity for each type
* @return 'uint256' total quantity user want to mint
*/
function caculatorQuantity(
bytes32[] memory typeMints,
uint256[] memory quantities
) internal view returns (uint256) {
uint256 totalQuantity = 0;
require(
(typeMints.length == quantities.length),
"Shiniki: input is invalid"
);
for (uint8 i = 0; i < typeMints.length; i++) {
require(
(typeMints[i] == TYPE_1 || typeMints[i] == TYPE_2),
"Shiniki: type input is invalid"
);
if (typeMints[i] == TYPE_1) {
require(<FILL_ME>)
} else {
require(
quantities[i] + totalSupply(typeMints[i]) <=
(collectionSize - (collectionSize / 2)),
"Shiniki: type2 input is reached max supply"
);
}
totalQuantity += quantities[i];
}
return totalQuantity;
}
/**
* @notice lock nft for staking
* @param tokenIds array 'uint256' tokenIds
*/
function lock(uint256[] memory tokenIds) public override {
}
/**
* @notice unlock nft for un-staking
* @param tokenIds array 'uint256' tokenIds
*/
function unlock(uint256[] memory tokenIds) public override {
}
/**
* @notice set base uri
* @param _typeMint array 'bytes32' type mint
* @param _baseURI array 'string' base uri
*/
function setBaseURI(bytes32[] memory _typeMint, string[] memory _baseURI)
external
onlyOwner
{
}
/**
* @notice set default uri
* @param _defaultURI 'string' default uri
*/
function setDefaultURI(string memory _defaultURI) external onlyOwner {
}
/**
* @notice set max batch size
* @param _maxBatchSize 'uint256' number new maxBatchSize
*/
function setMaxBatchSize(uint256 _maxBatchSize) external onlyOwner {
}
/**
@notice Setting new address signature
* @param _signatureVerifier 'address' signature
*/
function setSignatureVerifier(address _signatureVerifier)
external
onlyOwner
{
}
/**
* @notice check pre sale
* @return 'bool' status pre sale
*/
function isPreSaleOn() public view returns (bool) {
}
/**
* @notice check public sale
* @return 'bool' status public sale
*/
function isPublicSaleOn() public view returns (bool) {
}
/**
* @notice set pre sale config
* @param _preSaleStartTime 'uint128' start time pre sale
* @param _preSaleDuration 'uint128' duration time of pre sale
*/
function setPreSaleConfig(
uint128 _preSaleStartTime,
uint128 _preSaleDuration
) external onlyOwner {
}
/**
* @notice set public sale config
* @param _publicSaleStartTime 'uint128' start time public sale
* @param _publicSaleDuration 'uint128' duration time of public sale
* @param _publicSalePrice 'uint256' price of public sale for each nft
*/
function setPublicSaleConfig(
uint128 _publicSaleStartTime,
uint128 _publicSaleDuration,
uint256 _publicSalePrice
) external onlyOwner {
}
/**
* @notice set revealed
* @param _revealed 'bool' status revealed
*/
function setRevealed(bool _revealed) external onlyOwner {
}
/**
* @notice withdraw asset
* @param receiver 'address' receiver asset
* @param amount 'uint256' number asset to withdraw
*/
function withdraw(address receiver, uint256 amount)
external
override
onlyOwner
nonReentrant
{
}
/**
* @notice withdraw all asset
* @param receiver 'address' receiver asset
*/
function withdrawAll(address receiver)
external
override
onlyOwner
nonReentrant
{
}
/**
* @notice number minted
* @param owner 'address' user
*/
function numberMinted(address owner) public view returns (uint256) {
}
/**
* @notice get ownership data of a nft
* @param tokenId 'uint256' id of nft
* @return 'TokenOwnership' detail a nft
*/
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
/**
@notice Transfer a token between addresses while the Shiniki is staking
* @param from 'address' sender
* @param to 'address' receiver
* @param tokenId 'uint256' id of nft
*/
function safeTransferWhileStaking(
address from,
address to,
uint256 tokenId
) external override {
}
/**
@dev Pause the contract
*/
function pause() public onlyOwner {
}
/**
@dev Unpause the contract
*/
function unpause() public onlyOwner {
}
/**
@dev Block transfers while staking.
*/
function _beforeTokenTransfers(
address from,
address,
uint256 tokenId,
uint256
) internal view override {
}
/**
@notice Sets the contract-wide royalty info.
*/
function setRoyaltyInfo(address receiver, uint96 feeBasisPoints)
external
onlyOwner
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721A, ERC2981)
returns (bool)
{
}
}
| totalSupply(typeMints[i])+quantities[i]<=collectionSize/2,"Shiniki: type1 input is reached max supply" | 73,474 | totalSupply(typeMints[i])+quantities[i]<=collectionSize/2 |
"Shiniki: type2 input is reached max supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./interfaces/IShiniki.sol";
import "./interfaces/ISignatureVerifier.sol";
import "./ShinikiTransfer.sol";
import "./ERC721A.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
contract Shiniki is
Ownable,
IShiniki,
ERC721A,
ReentrancyGuard,
Pausable,
ERC2981,
ShinikiTransfer
{
// Info config
struct SaleConfig {
uint128 preSaleStartTime;
uint128 preSaleDuration;
uint128 publicSaleStartTime;
uint128 publicSaleDuration;
uint256 publicSalePrice;
}
// Info interface address signature
ISignatureVerifier public SIGNATURE_VERIFIER;
// Info config mint
SaleConfig public saleConfig;
// Check transfer when tokenId is locked
mapping(uint256 => bool) public stakingTransfer;
// Info number minted public
mapping(address => uint256) public numberPublicMinted;
// Info number minted pre
mapping(address => uint256) public numberPreMinted;
// Info locked
mapping(uint256 => bool) public locked;
event Lock(address locker, uint256 tokenId, uint64 startTimestampLock);
event UnLock(address unlocker, uint256 tokenId);
constructor(
address signatureVerifier,
uint256 collectionSize_,
uint256 maxBatchSize_,
uint256 amountMintDev_,
string memory defaultURI_
) ERC721A("LandOfGod", "LOG", collectionSize_, maxBatchSize_) {
}
/**
* @notice Validate caller
*/
modifier callerIsUser() {
}
/**
* @notice mint pre sale
* @param receiver 'address' receiver for nft
* @param typeMints array 'bytes32' type mint
* @param quantities array 'uint256' quantity for each type
* @param amountAllowce 'uint256' maximum quanity of user in whitelist
* @param nonce 'uint256' a number random
* @param signature 'bytes' a signature to verify data when mint nft
*/
function preSaleMint(
address receiver,
bytes32[] memory typeMints,
uint256[] memory quantities,
uint256 amountAllowce,
uint256 nonce,
bytes memory signature
) external override nonReentrant callerIsUser whenNotPaused {
}
/**
* @notice mint public sale
* @param typeMints array 'bytes32' type mint
* @param quantities array 'uint256' quantity for each type
*/
function publicSaleMint(
bytes32[] memory typeMints,
uint256[] memory quantities
) external payable override nonReentrant callerIsUser whenNotPaused {
}
/**
* @notice mint private
* @param receiver 'address' receiver when mint nft
* @param quantityType1 'uint256' quantity when mint nft by Type1
* @param quantityType2 'uint256' quantity when mint nft by Type2
*/
function privateMint(
address receiver,
uint256 quantityType1,
uint256 quantityType2
) public override onlyOwner whenNotPaused {
}
/**
* @notice caculate total quantity
* @param typeMints array 'bytes32' type mint
* @param quantities array 'uint256' quantity for each type
* @return 'uint256' total quantity user want to mint
*/
function caculatorQuantity(
bytes32[] memory typeMints,
uint256[] memory quantities
) internal view returns (uint256) {
uint256 totalQuantity = 0;
require(
(typeMints.length == quantities.length),
"Shiniki: input is invalid"
);
for (uint8 i = 0; i < typeMints.length; i++) {
require(
(typeMints[i] == TYPE_1 || typeMints[i] == TYPE_2),
"Shiniki: type input is invalid"
);
if (typeMints[i] == TYPE_1) {
require(
totalSupply(typeMints[i]) + quantities[i] <=
collectionSize / 2,
"Shiniki: type1 input is reached max supply"
);
} else {
require(<FILL_ME>)
}
totalQuantity += quantities[i];
}
return totalQuantity;
}
/**
* @notice lock nft for staking
* @param tokenIds array 'uint256' tokenIds
*/
function lock(uint256[] memory tokenIds) public override {
}
/**
* @notice unlock nft for un-staking
* @param tokenIds array 'uint256' tokenIds
*/
function unlock(uint256[] memory tokenIds) public override {
}
/**
* @notice set base uri
* @param _typeMint array 'bytes32' type mint
* @param _baseURI array 'string' base uri
*/
function setBaseURI(bytes32[] memory _typeMint, string[] memory _baseURI)
external
onlyOwner
{
}
/**
* @notice set default uri
* @param _defaultURI 'string' default uri
*/
function setDefaultURI(string memory _defaultURI) external onlyOwner {
}
/**
* @notice set max batch size
* @param _maxBatchSize 'uint256' number new maxBatchSize
*/
function setMaxBatchSize(uint256 _maxBatchSize) external onlyOwner {
}
/**
@notice Setting new address signature
* @param _signatureVerifier 'address' signature
*/
function setSignatureVerifier(address _signatureVerifier)
external
onlyOwner
{
}
/**
* @notice check pre sale
* @return 'bool' status pre sale
*/
function isPreSaleOn() public view returns (bool) {
}
/**
* @notice check public sale
* @return 'bool' status public sale
*/
function isPublicSaleOn() public view returns (bool) {
}
/**
* @notice set pre sale config
* @param _preSaleStartTime 'uint128' start time pre sale
* @param _preSaleDuration 'uint128' duration time of pre sale
*/
function setPreSaleConfig(
uint128 _preSaleStartTime,
uint128 _preSaleDuration
) external onlyOwner {
}
/**
* @notice set public sale config
* @param _publicSaleStartTime 'uint128' start time public sale
* @param _publicSaleDuration 'uint128' duration time of public sale
* @param _publicSalePrice 'uint256' price of public sale for each nft
*/
function setPublicSaleConfig(
uint128 _publicSaleStartTime,
uint128 _publicSaleDuration,
uint256 _publicSalePrice
) external onlyOwner {
}
/**
* @notice set revealed
* @param _revealed 'bool' status revealed
*/
function setRevealed(bool _revealed) external onlyOwner {
}
/**
* @notice withdraw asset
* @param receiver 'address' receiver asset
* @param amount 'uint256' number asset to withdraw
*/
function withdraw(address receiver, uint256 amount)
external
override
onlyOwner
nonReentrant
{
}
/**
* @notice withdraw all asset
* @param receiver 'address' receiver asset
*/
function withdrawAll(address receiver)
external
override
onlyOwner
nonReentrant
{
}
/**
* @notice number minted
* @param owner 'address' user
*/
function numberMinted(address owner) public view returns (uint256) {
}
/**
* @notice get ownership data of a nft
* @param tokenId 'uint256' id of nft
* @return 'TokenOwnership' detail a nft
*/
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
/**
@notice Transfer a token between addresses while the Shiniki is staking
* @param from 'address' sender
* @param to 'address' receiver
* @param tokenId 'uint256' id of nft
*/
function safeTransferWhileStaking(
address from,
address to,
uint256 tokenId
) external override {
}
/**
@dev Pause the contract
*/
function pause() public onlyOwner {
}
/**
@dev Unpause the contract
*/
function unpause() public onlyOwner {
}
/**
@dev Block transfers while staking.
*/
function _beforeTokenTransfers(
address from,
address,
uint256 tokenId,
uint256
) internal view override {
}
/**
@notice Sets the contract-wide royalty info.
*/
function setRoyaltyInfo(address receiver, uint96 feeBasisPoints)
external
onlyOwner
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721A, ERC2981)
returns (bool)
{
}
}
| quantities[i]+totalSupply(typeMints[i])<=(collectionSize-(collectionSize/2)),"Shiniki: type2 input is reached max supply" | 73,474 | quantities[i]+totalSupply(typeMints[i])<=(collectionSize-(collectionSize/2)) |
"Shiniki: tokenId is locked" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./interfaces/IShiniki.sol";
import "./interfaces/ISignatureVerifier.sol";
import "./ShinikiTransfer.sol";
import "./ERC721A.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
contract Shiniki is
Ownable,
IShiniki,
ERC721A,
ReentrancyGuard,
Pausable,
ERC2981,
ShinikiTransfer
{
// Info config
struct SaleConfig {
uint128 preSaleStartTime;
uint128 preSaleDuration;
uint128 publicSaleStartTime;
uint128 publicSaleDuration;
uint256 publicSalePrice;
}
// Info interface address signature
ISignatureVerifier public SIGNATURE_VERIFIER;
// Info config mint
SaleConfig public saleConfig;
// Check transfer when tokenId is locked
mapping(uint256 => bool) public stakingTransfer;
// Info number minted public
mapping(address => uint256) public numberPublicMinted;
// Info number minted pre
mapping(address => uint256) public numberPreMinted;
// Info locked
mapping(uint256 => bool) public locked;
event Lock(address locker, uint256 tokenId, uint64 startTimestampLock);
event UnLock(address unlocker, uint256 tokenId);
constructor(
address signatureVerifier,
uint256 collectionSize_,
uint256 maxBatchSize_,
uint256 amountMintDev_,
string memory defaultURI_
) ERC721A("LandOfGod", "LOG", collectionSize_, maxBatchSize_) {
}
/**
* @notice Validate caller
*/
modifier callerIsUser() {
}
/**
* @notice mint pre sale
* @param receiver 'address' receiver for nft
* @param typeMints array 'bytes32' type mint
* @param quantities array 'uint256' quantity for each type
* @param amountAllowce 'uint256' maximum quanity of user in whitelist
* @param nonce 'uint256' a number random
* @param signature 'bytes' a signature to verify data when mint nft
*/
function preSaleMint(
address receiver,
bytes32[] memory typeMints,
uint256[] memory quantities,
uint256 amountAllowce,
uint256 nonce,
bytes memory signature
) external override nonReentrant callerIsUser whenNotPaused {
}
/**
* @notice mint public sale
* @param typeMints array 'bytes32' type mint
* @param quantities array 'uint256' quantity for each type
*/
function publicSaleMint(
bytes32[] memory typeMints,
uint256[] memory quantities
) external payable override nonReentrant callerIsUser whenNotPaused {
}
/**
* @notice mint private
* @param receiver 'address' receiver when mint nft
* @param quantityType1 'uint256' quantity when mint nft by Type1
* @param quantityType2 'uint256' quantity when mint nft by Type2
*/
function privateMint(
address receiver,
uint256 quantityType1,
uint256 quantityType2
) public override onlyOwner whenNotPaused {
}
/**
* @notice caculate total quantity
* @param typeMints array 'bytes32' type mint
* @param quantities array 'uint256' quantity for each type
* @return 'uint256' total quantity user want to mint
*/
function caculatorQuantity(
bytes32[] memory typeMints,
uint256[] memory quantities
) internal view returns (uint256) {
}
/**
* @notice lock nft for staking
* @param tokenIds array 'uint256' tokenIds
*/
function lock(uint256[] memory tokenIds) public override {
require(tokenIds.length != 0, "Shiniki: tokenIds is not zero");
for (uint256 i = 0; i < tokenIds.length; i++) {
TokenOwnership memory ownership = ownershipOf(tokenIds[i]);
require(
msg.sender == ownership.addr,
"Shiniki: You are not owner of tokenId"
);
require(<FILL_ME>)
uint64 timeStampNow = uint64(block.timestamp);
_ownerships[tokenIds[i]] = TokenOwnership(
ownership.addr,
ownership.startTimestamp,
timeStampNow
);
locked[tokenIds[i]] = true;
stakingTransfer[tokenIds[i]] = true;
emit Lock(msg.sender, tokenIds[i], timeStampNow);
}
}
/**
* @notice unlock nft for un-staking
* @param tokenIds array 'uint256' tokenIds
*/
function unlock(uint256[] memory tokenIds) public override {
}
/**
* @notice set base uri
* @param _typeMint array 'bytes32' type mint
* @param _baseURI array 'string' base uri
*/
function setBaseURI(bytes32[] memory _typeMint, string[] memory _baseURI)
external
onlyOwner
{
}
/**
* @notice set default uri
* @param _defaultURI 'string' default uri
*/
function setDefaultURI(string memory _defaultURI) external onlyOwner {
}
/**
* @notice set max batch size
* @param _maxBatchSize 'uint256' number new maxBatchSize
*/
function setMaxBatchSize(uint256 _maxBatchSize) external onlyOwner {
}
/**
@notice Setting new address signature
* @param _signatureVerifier 'address' signature
*/
function setSignatureVerifier(address _signatureVerifier)
external
onlyOwner
{
}
/**
* @notice check pre sale
* @return 'bool' status pre sale
*/
function isPreSaleOn() public view returns (bool) {
}
/**
* @notice check public sale
* @return 'bool' status public sale
*/
function isPublicSaleOn() public view returns (bool) {
}
/**
* @notice set pre sale config
* @param _preSaleStartTime 'uint128' start time pre sale
* @param _preSaleDuration 'uint128' duration time of pre sale
*/
function setPreSaleConfig(
uint128 _preSaleStartTime,
uint128 _preSaleDuration
) external onlyOwner {
}
/**
* @notice set public sale config
* @param _publicSaleStartTime 'uint128' start time public sale
* @param _publicSaleDuration 'uint128' duration time of public sale
* @param _publicSalePrice 'uint256' price of public sale for each nft
*/
function setPublicSaleConfig(
uint128 _publicSaleStartTime,
uint128 _publicSaleDuration,
uint256 _publicSalePrice
) external onlyOwner {
}
/**
* @notice set revealed
* @param _revealed 'bool' status revealed
*/
function setRevealed(bool _revealed) external onlyOwner {
}
/**
* @notice withdraw asset
* @param receiver 'address' receiver asset
* @param amount 'uint256' number asset to withdraw
*/
function withdraw(address receiver, uint256 amount)
external
override
onlyOwner
nonReentrant
{
}
/**
* @notice withdraw all asset
* @param receiver 'address' receiver asset
*/
function withdrawAll(address receiver)
external
override
onlyOwner
nonReentrant
{
}
/**
* @notice number minted
* @param owner 'address' user
*/
function numberMinted(address owner) public view returns (uint256) {
}
/**
* @notice get ownership data of a nft
* @param tokenId 'uint256' id of nft
* @return 'TokenOwnership' detail a nft
*/
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
/**
@notice Transfer a token between addresses while the Shiniki is staking
* @param from 'address' sender
* @param to 'address' receiver
* @param tokenId 'uint256' id of nft
*/
function safeTransferWhileStaking(
address from,
address to,
uint256 tokenId
) external override {
}
/**
@dev Pause the contract
*/
function pause() public onlyOwner {
}
/**
@dev Unpause the contract
*/
function unpause() public onlyOwner {
}
/**
@dev Block transfers while staking.
*/
function _beforeTokenTransfers(
address from,
address,
uint256 tokenId,
uint256
) internal view override {
}
/**
@notice Sets the contract-wide royalty info.
*/
function setRoyaltyInfo(address receiver, uint96 feeBasisPoints)
external
onlyOwner
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721A, ERC2981)
returns (bool)
{
}
}
| !locked[tokenIds[i]],"Shiniki: tokenId is locked" | 73,474 | !locked[tokenIds[i]] |
"Shiniki: tokenId is not locked" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./interfaces/IShiniki.sol";
import "./interfaces/ISignatureVerifier.sol";
import "./ShinikiTransfer.sol";
import "./ERC721A.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
contract Shiniki is
Ownable,
IShiniki,
ERC721A,
ReentrancyGuard,
Pausable,
ERC2981,
ShinikiTransfer
{
// Info config
struct SaleConfig {
uint128 preSaleStartTime;
uint128 preSaleDuration;
uint128 publicSaleStartTime;
uint128 publicSaleDuration;
uint256 publicSalePrice;
}
// Info interface address signature
ISignatureVerifier public SIGNATURE_VERIFIER;
// Info config mint
SaleConfig public saleConfig;
// Check transfer when tokenId is locked
mapping(uint256 => bool) public stakingTransfer;
// Info number minted public
mapping(address => uint256) public numberPublicMinted;
// Info number minted pre
mapping(address => uint256) public numberPreMinted;
// Info locked
mapping(uint256 => bool) public locked;
event Lock(address locker, uint256 tokenId, uint64 startTimestampLock);
event UnLock(address unlocker, uint256 tokenId);
constructor(
address signatureVerifier,
uint256 collectionSize_,
uint256 maxBatchSize_,
uint256 amountMintDev_,
string memory defaultURI_
) ERC721A("LandOfGod", "LOG", collectionSize_, maxBatchSize_) {
}
/**
* @notice Validate caller
*/
modifier callerIsUser() {
}
/**
* @notice mint pre sale
* @param receiver 'address' receiver for nft
* @param typeMints array 'bytes32' type mint
* @param quantities array 'uint256' quantity for each type
* @param amountAllowce 'uint256' maximum quanity of user in whitelist
* @param nonce 'uint256' a number random
* @param signature 'bytes' a signature to verify data when mint nft
*/
function preSaleMint(
address receiver,
bytes32[] memory typeMints,
uint256[] memory quantities,
uint256 amountAllowce,
uint256 nonce,
bytes memory signature
) external override nonReentrant callerIsUser whenNotPaused {
}
/**
* @notice mint public sale
* @param typeMints array 'bytes32' type mint
* @param quantities array 'uint256' quantity for each type
*/
function publicSaleMint(
bytes32[] memory typeMints,
uint256[] memory quantities
) external payable override nonReentrant callerIsUser whenNotPaused {
}
/**
* @notice mint private
* @param receiver 'address' receiver when mint nft
* @param quantityType1 'uint256' quantity when mint nft by Type1
* @param quantityType2 'uint256' quantity when mint nft by Type2
*/
function privateMint(
address receiver,
uint256 quantityType1,
uint256 quantityType2
) public override onlyOwner whenNotPaused {
}
/**
* @notice caculate total quantity
* @param typeMints array 'bytes32' type mint
* @param quantities array 'uint256' quantity for each type
* @return 'uint256' total quantity user want to mint
*/
function caculatorQuantity(
bytes32[] memory typeMints,
uint256[] memory quantities
) internal view returns (uint256) {
}
/**
* @notice lock nft for staking
* @param tokenIds array 'uint256' tokenIds
*/
function lock(uint256[] memory tokenIds) public override {
}
/**
* @notice unlock nft for un-staking
* @param tokenIds array 'uint256' tokenIds
*/
function unlock(uint256[] memory tokenIds) public override {
require(tokenIds.length != 0, "Shiniki: tokenIds is not zero");
for (uint256 i = 0; i < tokenIds.length; i++) {
TokenOwnership memory ownership = ownershipOf(tokenIds[i]);
require(
msg.sender == ownership.addr,
"Shiniki: You are not owner of tokenId"
);
require(<FILL_ME>)
_ownerships[tokenIds[i]] = TokenOwnership(
ownership.addr,
ownership.startTimestamp,
0
);
locked[tokenIds[i]] = false;
stakingTransfer[tokenIds[i]] = false;
emit UnLock(msg.sender, tokenIds[i]);
}
}
/**
* @notice set base uri
* @param _typeMint array 'bytes32' type mint
* @param _baseURI array 'string' base uri
*/
function setBaseURI(bytes32[] memory _typeMint, string[] memory _baseURI)
external
onlyOwner
{
}
/**
* @notice set default uri
* @param _defaultURI 'string' default uri
*/
function setDefaultURI(string memory _defaultURI) external onlyOwner {
}
/**
* @notice set max batch size
* @param _maxBatchSize 'uint256' number new maxBatchSize
*/
function setMaxBatchSize(uint256 _maxBatchSize) external onlyOwner {
}
/**
@notice Setting new address signature
* @param _signatureVerifier 'address' signature
*/
function setSignatureVerifier(address _signatureVerifier)
external
onlyOwner
{
}
/**
* @notice check pre sale
* @return 'bool' status pre sale
*/
function isPreSaleOn() public view returns (bool) {
}
/**
* @notice check public sale
* @return 'bool' status public sale
*/
function isPublicSaleOn() public view returns (bool) {
}
/**
* @notice set pre sale config
* @param _preSaleStartTime 'uint128' start time pre sale
* @param _preSaleDuration 'uint128' duration time of pre sale
*/
function setPreSaleConfig(
uint128 _preSaleStartTime,
uint128 _preSaleDuration
) external onlyOwner {
}
/**
* @notice set public sale config
* @param _publicSaleStartTime 'uint128' start time public sale
* @param _publicSaleDuration 'uint128' duration time of public sale
* @param _publicSalePrice 'uint256' price of public sale for each nft
*/
function setPublicSaleConfig(
uint128 _publicSaleStartTime,
uint128 _publicSaleDuration,
uint256 _publicSalePrice
) external onlyOwner {
}
/**
* @notice set revealed
* @param _revealed 'bool' status revealed
*/
function setRevealed(bool _revealed) external onlyOwner {
}
/**
* @notice withdraw asset
* @param receiver 'address' receiver asset
* @param amount 'uint256' number asset to withdraw
*/
function withdraw(address receiver, uint256 amount)
external
override
onlyOwner
nonReentrant
{
}
/**
* @notice withdraw all asset
* @param receiver 'address' receiver asset
*/
function withdrawAll(address receiver)
external
override
onlyOwner
nonReentrant
{
}
/**
* @notice number minted
* @param owner 'address' user
*/
function numberMinted(address owner) public view returns (uint256) {
}
/**
* @notice get ownership data of a nft
* @param tokenId 'uint256' id of nft
* @return 'TokenOwnership' detail a nft
*/
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
/**
@notice Transfer a token between addresses while the Shiniki is staking
* @param from 'address' sender
* @param to 'address' receiver
* @param tokenId 'uint256' id of nft
*/
function safeTransferWhileStaking(
address from,
address to,
uint256 tokenId
) external override {
}
/**
@dev Pause the contract
*/
function pause() public onlyOwner {
}
/**
@dev Unpause the contract
*/
function unpause() public onlyOwner {
}
/**
@dev Block transfers while staking.
*/
function _beforeTokenTransfers(
address from,
address,
uint256 tokenId,
uint256
) internal view override {
}
/**
@notice Sets the contract-wide royalty info.
*/
function setRoyaltyInfo(address receiver, uint96 feeBasisPoints)
external
onlyOwner
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721A, ERC2981)
returns (bool)
{
}
}
| locked[tokenIds[i]],"Shiniki: tokenId is not locked" | 73,474 | locked[tokenIds[i]] |
"Shiniki: type input is invalid" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./interfaces/IShiniki.sol";
import "./interfaces/ISignatureVerifier.sol";
import "./ShinikiTransfer.sol";
import "./ERC721A.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
contract Shiniki is
Ownable,
IShiniki,
ERC721A,
ReentrancyGuard,
Pausable,
ERC2981,
ShinikiTransfer
{
// Info config
struct SaleConfig {
uint128 preSaleStartTime;
uint128 preSaleDuration;
uint128 publicSaleStartTime;
uint128 publicSaleDuration;
uint256 publicSalePrice;
}
// Info interface address signature
ISignatureVerifier public SIGNATURE_VERIFIER;
// Info config mint
SaleConfig public saleConfig;
// Check transfer when tokenId is locked
mapping(uint256 => bool) public stakingTransfer;
// Info number minted public
mapping(address => uint256) public numberPublicMinted;
// Info number minted pre
mapping(address => uint256) public numberPreMinted;
// Info locked
mapping(uint256 => bool) public locked;
event Lock(address locker, uint256 tokenId, uint64 startTimestampLock);
event UnLock(address unlocker, uint256 tokenId);
constructor(
address signatureVerifier,
uint256 collectionSize_,
uint256 maxBatchSize_,
uint256 amountMintDev_,
string memory defaultURI_
) ERC721A("LandOfGod", "LOG", collectionSize_, maxBatchSize_) {
}
/**
* @notice Validate caller
*/
modifier callerIsUser() {
}
/**
* @notice mint pre sale
* @param receiver 'address' receiver for nft
* @param typeMints array 'bytes32' type mint
* @param quantities array 'uint256' quantity for each type
* @param amountAllowce 'uint256' maximum quanity of user in whitelist
* @param nonce 'uint256' a number random
* @param signature 'bytes' a signature to verify data when mint nft
*/
function preSaleMint(
address receiver,
bytes32[] memory typeMints,
uint256[] memory quantities,
uint256 amountAllowce,
uint256 nonce,
bytes memory signature
) external override nonReentrant callerIsUser whenNotPaused {
}
/**
* @notice mint public sale
* @param typeMints array 'bytes32' type mint
* @param quantities array 'uint256' quantity for each type
*/
function publicSaleMint(
bytes32[] memory typeMints,
uint256[] memory quantities
) external payable override nonReentrant callerIsUser whenNotPaused {
}
/**
* @notice mint private
* @param receiver 'address' receiver when mint nft
* @param quantityType1 'uint256' quantity when mint nft by Type1
* @param quantityType2 'uint256' quantity when mint nft by Type2
*/
function privateMint(
address receiver,
uint256 quantityType1,
uint256 quantityType2
) public override onlyOwner whenNotPaused {
}
/**
* @notice caculate total quantity
* @param typeMints array 'bytes32' type mint
* @param quantities array 'uint256' quantity for each type
* @return 'uint256' total quantity user want to mint
*/
function caculatorQuantity(
bytes32[] memory typeMints,
uint256[] memory quantities
) internal view returns (uint256) {
}
/**
* @notice lock nft for staking
* @param tokenIds array 'uint256' tokenIds
*/
function lock(uint256[] memory tokenIds) public override {
}
/**
* @notice unlock nft for un-staking
* @param tokenIds array 'uint256' tokenIds
*/
function unlock(uint256[] memory tokenIds) public override {
}
/**
* @notice set base uri
* @param _typeMint array 'bytes32' type mint
* @param _baseURI array 'string' base uri
*/
function setBaseURI(bytes32[] memory _typeMint, string[] memory _baseURI)
external
onlyOwner
{
require(
_typeMint.length == _baseURI.length,
"Shiniki: input data is invalid"
);
for (uint256 i = 0; i < _typeMint.length; i++) {
require(<FILL_ME>)
_baseTokenURI[_typeMint[i]] = _baseURI[i];
}
}
/**
* @notice set default uri
* @param _defaultURI 'string' default uri
*/
function setDefaultURI(string memory _defaultURI) external onlyOwner {
}
/**
* @notice set max batch size
* @param _maxBatchSize 'uint256' number new maxBatchSize
*/
function setMaxBatchSize(uint256 _maxBatchSize) external onlyOwner {
}
/**
@notice Setting new address signature
* @param _signatureVerifier 'address' signature
*/
function setSignatureVerifier(address _signatureVerifier)
external
onlyOwner
{
}
/**
* @notice check pre sale
* @return 'bool' status pre sale
*/
function isPreSaleOn() public view returns (bool) {
}
/**
* @notice check public sale
* @return 'bool' status public sale
*/
function isPublicSaleOn() public view returns (bool) {
}
/**
* @notice set pre sale config
* @param _preSaleStartTime 'uint128' start time pre sale
* @param _preSaleDuration 'uint128' duration time of pre sale
*/
function setPreSaleConfig(
uint128 _preSaleStartTime,
uint128 _preSaleDuration
) external onlyOwner {
}
/**
* @notice set public sale config
* @param _publicSaleStartTime 'uint128' start time public sale
* @param _publicSaleDuration 'uint128' duration time of public sale
* @param _publicSalePrice 'uint256' price of public sale for each nft
*/
function setPublicSaleConfig(
uint128 _publicSaleStartTime,
uint128 _publicSaleDuration,
uint256 _publicSalePrice
) external onlyOwner {
}
/**
* @notice set revealed
* @param _revealed 'bool' status revealed
*/
function setRevealed(bool _revealed) external onlyOwner {
}
/**
* @notice withdraw asset
* @param receiver 'address' receiver asset
* @param amount 'uint256' number asset to withdraw
*/
function withdraw(address receiver, uint256 amount)
external
override
onlyOwner
nonReentrant
{
}
/**
* @notice withdraw all asset
* @param receiver 'address' receiver asset
*/
function withdrawAll(address receiver)
external
override
onlyOwner
nonReentrant
{
}
/**
* @notice number minted
* @param owner 'address' user
*/
function numberMinted(address owner) public view returns (uint256) {
}
/**
* @notice get ownership data of a nft
* @param tokenId 'uint256' id of nft
* @return 'TokenOwnership' detail a nft
*/
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
/**
@notice Transfer a token between addresses while the Shiniki is staking
* @param from 'address' sender
* @param to 'address' receiver
* @param tokenId 'uint256' id of nft
*/
function safeTransferWhileStaking(
address from,
address to,
uint256 tokenId
) external override {
}
/**
@dev Pause the contract
*/
function pause() public onlyOwner {
}
/**
@dev Unpause the contract
*/
function unpause() public onlyOwner {
}
/**
@dev Block transfers while staking.
*/
function _beforeTokenTransfers(
address from,
address,
uint256 tokenId,
uint256
) internal view override {
}
/**
@notice Sets the contract-wide royalty info.
*/
function setRoyaltyInfo(address receiver, uint96 feeBasisPoints)
external
onlyOwner
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721A, ERC2981)
returns (bool)
{
}
}
| (_typeMint[i]==TYPE_1||_typeMint[i]==TYPE_2),"Shiniki: type input is invalid" | 73,474 | (_typeMint[i]==TYPE_1||_typeMint[i]==TYPE_2) |
"Shiniki: Only owner" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./interfaces/IShiniki.sol";
import "./interfaces/ISignatureVerifier.sol";
import "./ShinikiTransfer.sol";
import "./ERC721A.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
contract Shiniki is
Ownable,
IShiniki,
ERC721A,
ReentrancyGuard,
Pausable,
ERC2981,
ShinikiTransfer
{
// Info config
struct SaleConfig {
uint128 preSaleStartTime;
uint128 preSaleDuration;
uint128 publicSaleStartTime;
uint128 publicSaleDuration;
uint256 publicSalePrice;
}
// Info interface address signature
ISignatureVerifier public SIGNATURE_VERIFIER;
// Info config mint
SaleConfig public saleConfig;
// Check transfer when tokenId is locked
mapping(uint256 => bool) public stakingTransfer;
// Info number minted public
mapping(address => uint256) public numberPublicMinted;
// Info number minted pre
mapping(address => uint256) public numberPreMinted;
// Info locked
mapping(uint256 => bool) public locked;
event Lock(address locker, uint256 tokenId, uint64 startTimestampLock);
event UnLock(address unlocker, uint256 tokenId);
constructor(
address signatureVerifier,
uint256 collectionSize_,
uint256 maxBatchSize_,
uint256 amountMintDev_,
string memory defaultURI_
) ERC721A("LandOfGod", "LOG", collectionSize_, maxBatchSize_) {
}
/**
* @notice Validate caller
*/
modifier callerIsUser() {
}
/**
* @notice mint pre sale
* @param receiver 'address' receiver for nft
* @param typeMints array 'bytes32' type mint
* @param quantities array 'uint256' quantity for each type
* @param amountAllowce 'uint256' maximum quanity of user in whitelist
* @param nonce 'uint256' a number random
* @param signature 'bytes' a signature to verify data when mint nft
*/
function preSaleMint(
address receiver,
bytes32[] memory typeMints,
uint256[] memory quantities,
uint256 amountAllowce,
uint256 nonce,
bytes memory signature
) external override nonReentrant callerIsUser whenNotPaused {
}
/**
* @notice mint public sale
* @param typeMints array 'bytes32' type mint
* @param quantities array 'uint256' quantity for each type
*/
function publicSaleMint(
bytes32[] memory typeMints,
uint256[] memory quantities
) external payable override nonReentrant callerIsUser whenNotPaused {
}
/**
* @notice mint private
* @param receiver 'address' receiver when mint nft
* @param quantityType1 'uint256' quantity when mint nft by Type1
* @param quantityType2 'uint256' quantity when mint nft by Type2
*/
function privateMint(
address receiver,
uint256 quantityType1,
uint256 quantityType2
) public override onlyOwner whenNotPaused {
}
/**
* @notice caculate total quantity
* @param typeMints array 'bytes32' type mint
* @param quantities array 'uint256' quantity for each type
* @return 'uint256' total quantity user want to mint
*/
function caculatorQuantity(
bytes32[] memory typeMints,
uint256[] memory quantities
) internal view returns (uint256) {
}
/**
* @notice lock nft for staking
* @param tokenIds array 'uint256' tokenIds
*/
function lock(uint256[] memory tokenIds) public override {
}
/**
* @notice unlock nft for un-staking
* @param tokenIds array 'uint256' tokenIds
*/
function unlock(uint256[] memory tokenIds) public override {
}
/**
* @notice set base uri
* @param _typeMint array 'bytes32' type mint
* @param _baseURI array 'string' base uri
*/
function setBaseURI(bytes32[] memory _typeMint, string[] memory _baseURI)
external
onlyOwner
{
}
/**
* @notice set default uri
* @param _defaultURI 'string' default uri
*/
function setDefaultURI(string memory _defaultURI) external onlyOwner {
}
/**
* @notice set max batch size
* @param _maxBatchSize 'uint256' number new maxBatchSize
*/
function setMaxBatchSize(uint256 _maxBatchSize) external onlyOwner {
}
/**
@notice Setting new address signature
* @param _signatureVerifier 'address' signature
*/
function setSignatureVerifier(address _signatureVerifier)
external
onlyOwner
{
}
/**
* @notice check pre sale
* @return 'bool' status pre sale
*/
function isPreSaleOn() public view returns (bool) {
}
/**
* @notice check public sale
* @return 'bool' status public sale
*/
function isPublicSaleOn() public view returns (bool) {
}
/**
* @notice set pre sale config
* @param _preSaleStartTime 'uint128' start time pre sale
* @param _preSaleDuration 'uint128' duration time of pre sale
*/
function setPreSaleConfig(
uint128 _preSaleStartTime,
uint128 _preSaleDuration
) external onlyOwner {
}
/**
* @notice set public sale config
* @param _publicSaleStartTime 'uint128' start time public sale
* @param _publicSaleDuration 'uint128' duration time of public sale
* @param _publicSalePrice 'uint256' price of public sale for each nft
*/
function setPublicSaleConfig(
uint128 _publicSaleStartTime,
uint128 _publicSaleDuration,
uint256 _publicSalePrice
) external onlyOwner {
}
/**
* @notice set revealed
* @param _revealed 'bool' status revealed
*/
function setRevealed(bool _revealed) external onlyOwner {
}
/**
* @notice withdraw asset
* @param receiver 'address' receiver asset
* @param amount 'uint256' number asset to withdraw
*/
function withdraw(address receiver, uint256 amount)
external
override
onlyOwner
nonReentrant
{
}
/**
* @notice withdraw all asset
* @param receiver 'address' receiver asset
*/
function withdrawAll(address receiver)
external
override
onlyOwner
nonReentrant
{
}
/**
* @notice number minted
* @param owner 'address' user
*/
function numberMinted(address owner) public view returns (uint256) {
}
/**
* @notice get ownership data of a nft
* @param tokenId 'uint256' id of nft
* @return 'TokenOwnership' detail a nft
*/
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
/**
@notice Transfer a token between addresses while the Shiniki is staking
* @param from 'address' sender
* @param to 'address' receiver
* @param tokenId 'uint256' id of nft
*/
function safeTransferWhileStaking(
address from,
address to,
uint256 tokenId
) external override {
require(<FILL_ME>)
if (stakingTransfer[tokenId]) {
stakingTransfer[tokenId] = false;
safeTransferFrom(from, to, tokenId);
stakingTransfer[tokenId] = true;
} else {
safeTransferFrom(from, to, tokenId);
}
}
/**
@dev Pause the contract
*/
function pause() public onlyOwner {
}
/**
@dev Unpause the contract
*/
function unpause() public onlyOwner {
}
/**
@dev Block transfers while staking.
*/
function _beforeTokenTransfers(
address from,
address,
uint256 tokenId,
uint256
) internal view override {
}
/**
@notice Sets the contract-wide royalty info.
*/
function setRoyaltyInfo(address receiver, uint96 feeBasisPoints)
external
onlyOwner
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721A, ERC2981)
returns (bool)
{
}
}
| ownerOf(tokenId)==_msgSender(),"Shiniki: Only owner" | 73,474 | ownerOf(tokenId)==_msgSender() |
"Shiniki: staking" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./interfaces/IShiniki.sol";
import "./interfaces/ISignatureVerifier.sol";
import "./ShinikiTransfer.sol";
import "./ERC721A.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
contract Shiniki is
Ownable,
IShiniki,
ERC721A,
ReentrancyGuard,
Pausable,
ERC2981,
ShinikiTransfer
{
// Info config
struct SaleConfig {
uint128 preSaleStartTime;
uint128 preSaleDuration;
uint128 publicSaleStartTime;
uint128 publicSaleDuration;
uint256 publicSalePrice;
}
// Info interface address signature
ISignatureVerifier public SIGNATURE_VERIFIER;
// Info config mint
SaleConfig public saleConfig;
// Check transfer when tokenId is locked
mapping(uint256 => bool) public stakingTransfer;
// Info number minted public
mapping(address => uint256) public numberPublicMinted;
// Info number minted pre
mapping(address => uint256) public numberPreMinted;
// Info locked
mapping(uint256 => bool) public locked;
event Lock(address locker, uint256 tokenId, uint64 startTimestampLock);
event UnLock(address unlocker, uint256 tokenId);
constructor(
address signatureVerifier,
uint256 collectionSize_,
uint256 maxBatchSize_,
uint256 amountMintDev_,
string memory defaultURI_
) ERC721A("LandOfGod", "LOG", collectionSize_, maxBatchSize_) {
}
/**
* @notice Validate caller
*/
modifier callerIsUser() {
}
/**
* @notice mint pre sale
* @param receiver 'address' receiver for nft
* @param typeMints array 'bytes32' type mint
* @param quantities array 'uint256' quantity for each type
* @param amountAllowce 'uint256' maximum quanity of user in whitelist
* @param nonce 'uint256' a number random
* @param signature 'bytes' a signature to verify data when mint nft
*/
function preSaleMint(
address receiver,
bytes32[] memory typeMints,
uint256[] memory quantities,
uint256 amountAllowce,
uint256 nonce,
bytes memory signature
) external override nonReentrant callerIsUser whenNotPaused {
}
/**
* @notice mint public sale
* @param typeMints array 'bytes32' type mint
* @param quantities array 'uint256' quantity for each type
*/
function publicSaleMint(
bytes32[] memory typeMints,
uint256[] memory quantities
) external payable override nonReentrant callerIsUser whenNotPaused {
}
/**
* @notice mint private
* @param receiver 'address' receiver when mint nft
* @param quantityType1 'uint256' quantity when mint nft by Type1
* @param quantityType2 'uint256' quantity when mint nft by Type2
*/
function privateMint(
address receiver,
uint256 quantityType1,
uint256 quantityType2
) public override onlyOwner whenNotPaused {
}
/**
* @notice caculate total quantity
* @param typeMints array 'bytes32' type mint
* @param quantities array 'uint256' quantity for each type
* @return 'uint256' total quantity user want to mint
*/
function caculatorQuantity(
bytes32[] memory typeMints,
uint256[] memory quantities
) internal view returns (uint256) {
}
/**
* @notice lock nft for staking
* @param tokenIds array 'uint256' tokenIds
*/
function lock(uint256[] memory tokenIds) public override {
}
/**
* @notice unlock nft for un-staking
* @param tokenIds array 'uint256' tokenIds
*/
function unlock(uint256[] memory tokenIds) public override {
}
/**
* @notice set base uri
* @param _typeMint array 'bytes32' type mint
* @param _baseURI array 'string' base uri
*/
function setBaseURI(bytes32[] memory _typeMint, string[] memory _baseURI)
external
onlyOwner
{
}
/**
* @notice set default uri
* @param _defaultURI 'string' default uri
*/
function setDefaultURI(string memory _defaultURI) external onlyOwner {
}
/**
* @notice set max batch size
* @param _maxBatchSize 'uint256' number new maxBatchSize
*/
function setMaxBatchSize(uint256 _maxBatchSize) external onlyOwner {
}
/**
@notice Setting new address signature
* @param _signatureVerifier 'address' signature
*/
function setSignatureVerifier(address _signatureVerifier)
external
onlyOwner
{
}
/**
* @notice check pre sale
* @return 'bool' status pre sale
*/
function isPreSaleOn() public view returns (bool) {
}
/**
* @notice check public sale
* @return 'bool' status public sale
*/
function isPublicSaleOn() public view returns (bool) {
}
/**
* @notice set pre sale config
* @param _preSaleStartTime 'uint128' start time pre sale
* @param _preSaleDuration 'uint128' duration time of pre sale
*/
function setPreSaleConfig(
uint128 _preSaleStartTime,
uint128 _preSaleDuration
) external onlyOwner {
}
/**
* @notice set public sale config
* @param _publicSaleStartTime 'uint128' start time public sale
* @param _publicSaleDuration 'uint128' duration time of public sale
* @param _publicSalePrice 'uint256' price of public sale for each nft
*/
function setPublicSaleConfig(
uint128 _publicSaleStartTime,
uint128 _publicSaleDuration,
uint256 _publicSalePrice
) external onlyOwner {
}
/**
* @notice set revealed
* @param _revealed 'bool' status revealed
*/
function setRevealed(bool _revealed) external onlyOwner {
}
/**
* @notice withdraw asset
* @param receiver 'address' receiver asset
* @param amount 'uint256' number asset to withdraw
*/
function withdraw(address receiver, uint256 amount)
external
override
onlyOwner
nonReentrant
{
}
/**
* @notice withdraw all asset
* @param receiver 'address' receiver asset
*/
function withdrawAll(address receiver)
external
override
onlyOwner
nonReentrant
{
}
/**
* @notice number minted
* @param owner 'address' user
*/
function numberMinted(address owner) public view returns (uint256) {
}
/**
* @notice get ownership data of a nft
* @param tokenId 'uint256' id of nft
* @return 'TokenOwnership' detail a nft
*/
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
/**
@notice Transfer a token between addresses while the Shiniki is staking
* @param from 'address' sender
* @param to 'address' receiver
* @param tokenId 'uint256' id of nft
*/
function safeTransferWhileStaking(
address from,
address to,
uint256 tokenId
) external override {
}
/**
@dev Pause the contract
*/
function pause() public onlyOwner {
}
/**
@dev Unpause the contract
*/
function unpause() public onlyOwner {
}
/**
@dev Block transfers while staking.
*/
function _beforeTokenTransfers(
address from,
address,
uint256 tokenId,
uint256
) internal view override {
if (from != address(0)) {
require(<FILL_ME>)
}
}
/**
@notice Sets the contract-wide royalty info.
*/
function setRoyaltyInfo(address receiver, uint96 feeBasisPoints)
external
onlyOwner
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721A, ERC2981)
returns (bool)
{
}
}
| !stakingTransfer[tokenId],"Shiniki: staking" | 73,474 | !stakingTransfer[tokenId] |
"Investor reached maximum Investment Amount" | pragma solidity 0.8.18;
contract BlogToEarnICO is Ownable {
//Administration Details
address payable public ICOWallet;
//Token
IERC20 public token;
IERC20 public usdt;
//ICO Details
uint256 public btePrice = 200000; //0.2 USDT >> price in USDT (6 decimals)
uint256 public raisedAmount;
uint256 public bteSold;
uint256 public minInvestment = 200000000;
uint256 public maxInvestment = 5000000000000;
uint256 public icoStartTime;
uint256 public icoEndTime;
//Investor
mapping(address => uint256) public investedAmountOf;
//ICO State
enum State {
BEFORE,
RUNNING,
END,
HALTED
}
State public ICOState;
//Events
event Invest(
address indexed from,
address indexed to,
uint256 value,
uint256 tokens
);
event TokenWithdrawn(address to, uint256 amount, uint256 time);
//Initialize Variables
constructor(
address payable _icoWallet,
address _token,
address _usdt
) {
}
// ICO FUNCTIONS
//Get ICO State
function getICOState() external view returns (string memory) {
}
/* User Function */
//Invest
function invest(uint256 _amount) public {
require(ICOState == State.RUNNING, "ICO isn't running");
uint256 amount = SafeMath.mul(_amount, 1e18);
uint256 totalPrice = SafeMath.mul(_amount, btePrice);
require(
totalPrice >= minInvestment && totalPrice <= maxInvestment,
"Check Min and Max Investment"
);
require(<FILL_ME>)
require(
amount <= token.balanceOf(address(this)),
"Not enough supply available to sell"
);
require(
block.timestamp <= icoEndTime,
"ICO already Reached Maximum time limit"
);
raisedAmount += totalPrice;
bteSold += amount;
investedAmountOf[msg.sender] += totalPrice;
require(
usdt.transferFrom(msg.sender, ICOWallet, totalPrice),
"USDT transfer failed"
);
bool saleSuccess = token.transfer(msg.sender, amount);
require(saleSuccess, "Failed to Invest");
emit Invest(address(this), msg.sender, totalPrice, amount);
}
// ADMIN FUNCTIONS
//Start, Halt and End ICO
function startICO() external onlyOwner {
}
function haltICO() external onlyOwner {
}
function resumeICO() external onlyOwner {
}
//Change ICO Wallet
function changeICOWallet(address payable _newICOWallet) external onlyOwner {
}
//End ICO After reaching ICO Timelimit
function endIco() public {
}
//Change ICO End time
function changeIcoEndTime(uint256 _newTimestamp) external onlyOwner {
}
//Change BTE price for sale
function changeBTEPrice(uint256 _newPrice) external onlyOwner {
}
//Withdraw remaining Tokens
function withdrawTokens() external onlyOwner {
}
//Usefull Getter Methods
//Check ICO Contract Token Balance
function getICOTokenBalance() external view returns (uint256) {
}
//Check ICO Contract Investor Token Balance
function investorBalanceOf(address _investor)
external
view
returns (uint256)
{
}
}
| investedAmountOf[msg.sender]+totalPrice<=maxInvestment,"Investor reached maximum Investment Amount" | 73,504 | investedAmountOf[msg.sender]+totalPrice<=maxInvestment |
"USDT transfer failed" | pragma solidity 0.8.18;
contract BlogToEarnICO is Ownable {
//Administration Details
address payable public ICOWallet;
//Token
IERC20 public token;
IERC20 public usdt;
//ICO Details
uint256 public btePrice = 200000; //0.2 USDT >> price in USDT (6 decimals)
uint256 public raisedAmount;
uint256 public bteSold;
uint256 public minInvestment = 200000000;
uint256 public maxInvestment = 5000000000000;
uint256 public icoStartTime;
uint256 public icoEndTime;
//Investor
mapping(address => uint256) public investedAmountOf;
//ICO State
enum State {
BEFORE,
RUNNING,
END,
HALTED
}
State public ICOState;
//Events
event Invest(
address indexed from,
address indexed to,
uint256 value,
uint256 tokens
);
event TokenWithdrawn(address to, uint256 amount, uint256 time);
//Initialize Variables
constructor(
address payable _icoWallet,
address _token,
address _usdt
) {
}
// ICO FUNCTIONS
//Get ICO State
function getICOState() external view returns (string memory) {
}
/* User Function */
//Invest
function invest(uint256 _amount) public {
require(ICOState == State.RUNNING, "ICO isn't running");
uint256 amount = SafeMath.mul(_amount, 1e18);
uint256 totalPrice = SafeMath.mul(_amount, btePrice);
require(
totalPrice >= minInvestment && totalPrice <= maxInvestment,
"Check Min and Max Investment"
);
require(
investedAmountOf[msg.sender] + totalPrice <= maxInvestment,
"Investor reached maximum Investment Amount"
);
require(
amount <= token.balanceOf(address(this)),
"Not enough supply available to sell"
);
require(
block.timestamp <= icoEndTime,
"ICO already Reached Maximum time limit"
);
raisedAmount += totalPrice;
bteSold += amount;
investedAmountOf[msg.sender] += totalPrice;
require(<FILL_ME>)
bool saleSuccess = token.transfer(msg.sender, amount);
require(saleSuccess, "Failed to Invest");
emit Invest(address(this), msg.sender, totalPrice, amount);
}
// ADMIN FUNCTIONS
//Start, Halt and End ICO
function startICO() external onlyOwner {
}
function haltICO() external onlyOwner {
}
function resumeICO() external onlyOwner {
}
//Change ICO Wallet
function changeICOWallet(address payable _newICOWallet) external onlyOwner {
}
//End ICO After reaching ICO Timelimit
function endIco() public {
}
//Change ICO End time
function changeIcoEndTime(uint256 _newTimestamp) external onlyOwner {
}
//Change BTE price for sale
function changeBTEPrice(uint256 _newPrice) external onlyOwner {
}
//Withdraw remaining Tokens
function withdrawTokens() external onlyOwner {
}
//Usefull Getter Methods
//Check ICO Contract Token Balance
function getICOTokenBalance() external view returns (uint256) {
}
//Check ICO Contract Investor Token Balance
function investorBalanceOf(address _investor)
external
view
returns (uint256)
{
}
}
| usdt.transferFrom(msg.sender,ICOWallet,totalPrice),"USDT transfer failed" | 73,504 | usdt.transferFrom(msg.sender,ICOWallet,totalPrice) |
"No more free mints, sorry <3" | contract GalaxySmasher is ERC721A, Ownable {
string public baseURI = "ipfs://QmPTzAevvuY7TrjKQGnsMeJLFQzvxLmMsBKwjXinHnXLzH/";
string public contractURI = "ipfs://QmRZKnLvErfnS5anoqVZhJzp4buZNMvQ7KFaWbnbR2neg7";
uint256 public constant MAX_PER_TX_FREE = 1;
uint256 public FREE_MAX_SUPPLY = 222;
uint256 public constant MAX_PER_TX = 20;
uint256 public constant MAX_PER_WALLET = 0;
uint256 public constant MAX_SUPPLY = 2222;
uint256 public price = 0.001 ether;
bool public paused = true;
constructor() ERC721A("GalaxySmasher", "GS") {}
function mint(uint256 _amount) external payable {
}
function freeMint() external payable {
address _caller = _msgSender();
require(!paused, "Paused");
require(MAX_SUPPLY >= totalSupply() + 1, "Exceeds max supply");
require(tx.origin == _caller, "No contracts");
require(MAX_PER_TX_FREE >= uint256(_getAux(_caller)) + 1, "Excess max per free wallet");
require(<FILL_ME>)
_setAux(_caller, 1);
_safeMint(_caller, 1);
unchecked{ FREE_MAX_SUPPLY -= 1; }
}
function _startTokenId() internal override view virtual returns (uint256) {
}
function minted(address _owner) public view returns (uint256) {
}
function withdraw() external onlyOwner {
}
function devMint() external onlyOwner {
}
function setPrice(uint256 _price) external onlyOwner {
}
function pause(bool _state) external onlyOwner {
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function setContractURI(string memory _contractURI) external onlyOwner {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
}
| FREE_MAX_SUPPLY-1>=0,"No more free mints, sorry <3" | 73,530 | FREE_MAX_SUPPLY-1>=0 |
"Exceeds maximum supply" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.14;
import "./base/ERC721aNFT.sol";
import "./ext/MultipleWalletWithdrawable.sol";
import "./ext/PriceUpdatable.sol";
import "./ext/WithStateControl.sol";
import "./ext/WithSignatureControl.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
// ____ __ __
// / __ \____ ____ _/ /_ ____ / /_
// / /_/ / __ \/ __ `/ __ \/ __ \/ __/
// / _, _/ /_/ / /_/ / /_/ / /_/ / /_
// /_/ |_|\____/\__, /_.___/\____/\__/
// /____/
// __ __ _ __
// / //_/(_____ ____ _____/ ____ ____ ___
// / ,< / / __ \/ __ `/ __ / __ \/ __ `__ \
// / /| |/ / / / / /_/ / /_/ / /_/ / / / / / /
// /_/ |_/_/_/ /_/\__, /\__,_/\____/_/ /_/ /_/
// /____/
//
// V 2.0
//
contract RogbotKingdom is ERC721aNFT, MultipleWalletWithdrawable, PriceUpdatable, WithStateControl, WithSignatureControl, ReentrancyGuard {
using SafeMath for uint256;
uint256 public constant MAX_SUPPLY = 10000;
mapping(ProjectState => uint256) private _mintLimit;
mapping(ProjectState => uint256) private _stageSupply;
constructor(string memory _tokenURI) ERC721A("RogbotKingdom", "RBKD") {
}
// airdrop NFT
function airdrop(address[] calldata _address, uint256[] calldata _nums)
external
onlyOwner
{
uint256 sum = 0;
for (uint i = 0; i < _nums.length; i++) {
sum = sum + _nums[i];
}
require(
sum <= 1000,
"Maximum 1000 tokens"
);
require(<FILL_ME>)
for (uint256 i = 0; i < _address.length; i++) {
_baseMint(_address[i], _nums[i]);
}
}
// mint multiple token
function mint(
uint256 _num,
bytes memory _ticket,
bytes memory _signature
) public payable nonReentrant {
}
function updateMintingLimit(ProjectState _state, uint256 _limit)
external
onlyOwner
{
}
function updateStageSupplyLimit(ProjectState _state, uint256 _limit)
external
onlyOwner
{
}
function mintingLimit(ProjectState _state) external view returns (uint256) {
}
function stageSupplyLimit(ProjectState _state) external view returns (uint256) {
}
}
| totalSupply()+sum<=MAX_SUPPLY,"Exceeds maximum supply" | 73,542 | totalSupply()+sum<=MAX_SUPPLY |
"Sale not started" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.14;
import "./base/ERC721aNFT.sol";
import "./ext/MultipleWalletWithdrawable.sol";
import "./ext/PriceUpdatable.sol";
import "./ext/WithStateControl.sol";
import "./ext/WithSignatureControl.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
// ____ __ __
// / __ \____ ____ _/ /_ ____ / /_
// / /_/ / __ \/ __ `/ __ \/ __ \/ __/
// / _, _/ /_/ / /_/ / /_/ / /_/ / /_
// /_/ |_|\____/\__, /_.___/\____/\__/
// /____/
// __ __ _ __
// / //_/(_____ ____ _____/ ____ ____ ___
// / ,< / / __ \/ __ `/ __ / __ \/ __ `__ \
// / /| |/ / / / / /_/ / /_/ / /_/ / / / / / /
// /_/ |_/_/_/ /_/\__, /\__,_/\____/_/ /_/ /_/
// /____/
//
// V 2.0
//
contract RogbotKingdom is ERC721aNFT, MultipleWalletWithdrawable, PriceUpdatable, WithStateControl, WithSignatureControl, ReentrancyGuard {
using SafeMath for uint256;
uint256 public constant MAX_SUPPLY = 10000;
mapping(ProjectState => uint256) private _mintLimit;
mapping(ProjectState => uint256) private _stageSupply;
constructor(string memory _tokenURI) ERC721A("RogbotKingdom", "RBKD") {
}
// airdrop NFT
function airdrop(address[] calldata _address, uint256[] calldata _nums)
external
onlyOwner
{
}
// mint multiple token
function mint(
uint256 _num,
bytes memory _ticket,
bytes memory _signature
) public payable nonReentrant {
// check if sale is stared
require(<FILL_ME>)
// only EOA can call this function
require(msg.sender == tx.origin, "Only EOA can call this function");
// check max supply
require(totalSupply() + _num <= MAX_SUPPLY, "Exceeds maximum supply");
// check max supply
require(totalSupply() + _num <= _stageSupply[state], "Exceeds current stage maximum supply");
// minting amt cannot be over the limit of the current state
require(
(_num > 0 && _num <= _mintLimit[state]),
"Incorrect minting amount"
);
// each ticket cannot be used to mint over the allowed amt
if (!_bypassSignatureChecking) {
require(_ticketUsed[_ticket] + _num <= _mintLimit[state] , "Minting amount exceed limit");
}
// validate ticket
require(
isSignedBySigner(
msg.sender,
_ticket,
_signature,
signerAddress
),
"Ticket is invalid"
);
// check eth amt
require(msg.value >= (price * _num), "Not enough ETH was sent");
_ticketUsed[_ticket] += _num;
// transfer the fund to the project team
if ( msg.value > 0 ) {
for (uint256 i = 0 ; i < _wallets.length; i++) {
payable(_wallets[i]).transfer(msg.value.mul(_ratio[i]).div(100));
}
}
_baseMint(_num);
}
function updateMintingLimit(ProjectState _state, uint256 _limit)
external
onlyOwner
{
}
function updateStageSupplyLimit(ProjectState _state, uint256 _limit)
external
onlyOwner
{
}
function mintingLimit(ProjectState _state) external view returns (uint256) {
}
function stageSupplyLimit(ProjectState _state) external view returns (uint256) {
}
}
| (ProjectState.PublicSale==state||ProjectState.WhitelistSale==state||ProjectState.PioneerSale==state),"Sale not started" | 73,542 | (ProjectState.PublicSale==state||ProjectState.WhitelistSale==state||ProjectState.PioneerSale==state) |
"Exceeds maximum supply" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.14;
import "./base/ERC721aNFT.sol";
import "./ext/MultipleWalletWithdrawable.sol";
import "./ext/PriceUpdatable.sol";
import "./ext/WithStateControl.sol";
import "./ext/WithSignatureControl.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
// ____ __ __
// / __ \____ ____ _/ /_ ____ / /_
// / /_/ / __ \/ __ `/ __ \/ __ \/ __/
// / _, _/ /_/ / /_/ / /_/ / /_/ / /_
// /_/ |_|\____/\__, /_.___/\____/\__/
// /____/
// __ __ _ __
// / //_/(_____ ____ _____/ ____ ____ ___
// / ,< / / __ \/ __ `/ __ / __ \/ __ `__ \
// / /| |/ / / / / /_/ / /_/ / /_/ / / / / / /
// /_/ |_/_/_/ /_/\__, /\__,_/\____/_/ /_/ /_/
// /____/
//
// V 2.0
//
contract RogbotKingdom is ERC721aNFT, MultipleWalletWithdrawable, PriceUpdatable, WithStateControl, WithSignatureControl, ReentrancyGuard {
using SafeMath for uint256;
uint256 public constant MAX_SUPPLY = 10000;
mapping(ProjectState => uint256) private _mintLimit;
mapping(ProjectState => uint256) private _stageSupply;
constructor(string memory _tokenURI) ERC721A("RogbotKingdom", "RBKD") {
}
// airdrop NFT
function airdrop(address[] calldata _address, uint256[] calldata _nums)
external
onlyOwner
{
}
// mint multiple token
function mint(
uint256 _num,
bytes memory _ticket,
bytes memory _signature
) public payable nonReentrant {
// check if sale is stared
require(
(ProjectState.PublicSale == state || ProjectState.WhitelistSale == state || ProjectState.PioneerSale == state ),
"Sale not started"
);
// only EOA can call this function
require(msg.sender == tx.origin, "Only EOA can call this function");
// check max supply
require(<FILL_ME>)
// check max supply
require(totalSupply() + _num <= _stageSupply[state], "Exceeds current stage maximum supply");
// minting amt cannot be over the limit of the current state
require(
(_num > 0 && _num <= _mintLimit[state]),
"Incorrect minting amount"
);
// each ticket cannot be used to mint over the allowed amt
if (!_bypassSignatureChecking) {
require(_ticketUsed[_ticket] + _num <= _mintLimit[state] , "Minting amount exceed limit");
}
// validate ticket
require(
isSignedBySigner(
msg.sender,
_ticket,
_signature,
signerAddress
),
"Ticket is invalid"
);
// check eth amt
require(msg.value >= (price * _num), "Not enough ETH was sent");
_ticketUsed[_ticket] += _num;
// transfer the fund to the project team
if ( msg.value > 0 ) {
for (uint256 i = 0 ; i < _wallets.length; i++) {
payable(_wallets[i]).transfer(msg.value.mul(_ratio[i]).div(100));
}
}
_baseMint(_num);
}
function updateMintingLimit(ProjectState _state, uint256 _limit)
external
onlyOwner
{
}
function updateStageSupplyLimit(ProjectState _state, uint256 _limit)
external
onlyOwner
{
}
function mintingLimit(ProjectState _state) external view returns (uint256) {
}
function stageSupplyLimit(ProjectState _state) external view returns (uint256) {
}
}
| totalSupply()+_num<=MAX_SUPPLY,"Exceeds maximum supply" | 73,542 | totalSupply()+_num<=MAX_SUPPLY |
"Exceeds current stage maximum supply" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.14;
import "./base/ERC721aNFT.sol";
import "./ext/MultipleWalletWithdrawable.sol";
import "./ext/PriceUpdatable.sol";
import "./ext/WithStateControl.sol";
import "./ext/WithSignatureControl.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
// ____ __ __
// / __ \____ ____ _/ /_ ____ / /_
// / /_/ / __ \/ __ `/ __ \/ __ \/ __/
// / _, _/ /_/ / /_/ / /_/ / /_/ / /_
// /_/ |_|\____/\__, /_.___/\____/\__/
// /____/
// __ __ _ __
// / //_/(_____ ____ _____/ ____ ____ ___
// / ,< / / __ \/ __ `/ __ / __ \/ __ `__ \
// / /| |/ / / / / /_/ / /_/ / /_/ / / / / / /
// /_/ |_/_/_/ /_/\__, /\__,_/\____/_/ /_/ /_/
// /____/
//
// V 2.0
//
contract RogbotKingdom is ERC721aNFT, MultipleWalletWithdrawable, PriceUpdatable, WithStateControl, WithSignatureControl, ReentrancyGuard {
using SafeMath for uint256;
uint256 public constant MAX_SUPPLY = 10000;
mapping(ProjectState => uint256) private _mintLimit;
mapping(ProjectState => uint256) private _stageSupply;
constructor(string memory _tokenURI) ERC721A("RogbotKingdom", "RBKD") {
}
// airdrop NFT
function airdrop(address[] calldata _address, uint256[] calldata _nums)
external
onlyOwner
{
}
// mint multiple token
function mint(
uint256 _num,
bytes memory _ticket,
bytes memory _signature
) public payable nonReentrant {
// check if sale is stared
require(
(ProjectState.PublicSale == state || ProjectState.WhitelistSale == state || ProjectState.PioneerSale == state ),
"Sale not started"
);
// only EOA can call this function
require(msg.sender == tx.origin, "Only EOA can call this function");
// check max supply
require(totalSupply() + _num <= MAX_SUPPLY, "Exceeds maximum supply");
// check max supply
require(<FILL_ME>)
// minting amt cannot be over the limit of the current state
require(
(_num > 0 && _num <= _mintLimit[state]),
"Incorrect minting amount"
);
// each ticket cannot be used to mint over the allowed amt
if (!_bypassSignatureChecking) {
require(_ticketUsed[_ticket] + _num <= _mintLimit[state] , "Minting amount exceed limit");
}
// validate ticket
require(
isSignedBySigner(
msg.sender,
_ticket,
_signature,
signerAddress
),
"Ticket is invalid"
);
// check eth amt
require(msg.value >= (price * _num), "Not enough ETH was sent");
_ticketUsed[_ticket] += _num;
// transfer the fund to the project team
if ( msg.value > 0 ) {
for (uint256 i = 0 ; i < _wallets.length; i++) {
payable(_wallets[i]).transfer(msg.value.mul(_ratio[i]).div(100));
}
}
_baseMint(_num);
}
function updateMintingLimit(ProjectState _state, uint256 _limit)
external
onlyOwner
{
}
function updateStageSupplyLimit(ProjectState _state, uint256 _limit)
external
onlyOwner
{
}
function mintingLimit(ProjectState _state) external view returns (uint256) {
}
function stageSupplyLimit(ProjectState _state) external view returns (uint256) {
}
}
| totalSupply()+_num<=_stageSupply[state],"Exceeds current stage maximum supply" | 73,542 | totalSupply()+_num<=_stageSupply[state] |
"Incorrect minting amount" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.14;
import "./base/ERC721aNFT.sol";
import "./ext/MultipleWalletWithdrawable.sol";
import "./ext/PriceUpdatable.sol";
import "./ext/WithStateControl.sol";
import "./ext/WithSignatureControl.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
// ____ __ __
// / __ \____ ____ _/ /_ ____ / /_
// / /_/ / __ \/ __ `/ __ \/ __ \/ __/
// / _, _/ /_/ / /_/ / /_/ / /_/ / /_
// /_/ |_|\____/\__, /_.___/\____/\__/
// /____/
// __ __ _ __
// / //_/(_____ ____ _____/ ____ ____ ___
// / ,< / / __ \/ __ `/ __ / __ \/ __ `__ \
// / /| |/ / / / / /_/ / /_/ / /_/ / / / / / /
// /_/ |_/_/_/ /_/\__, /\__,_/\____/_/ /_/ /_/
// /____/
//
// V 2.0
//
contract RogbotKingdom is ERC721aNFT, MultipleWalletWithdrawable, PriceUpdatable, WithStateControl, WithSignatureControl, ReentrancyGuard {
using SafeMath for uint256;
uint256 public constant MAX_SUPPLY = 10000;
mapping(ProjectState => uint256) private _mintLimit;
mapping(ProjectState => uint256) private _stageSupply;
constructor(string memory _tokenURI) ERC721A("RogbotKingdom", "RBKD") {
}
// airdrop NFT
function airdrop(address[] calldata _address, uint256[] calldata _nums)
external
onlyOwner
{
}
// mint multiple token
function mint(
uint256 _num,
bytes memory _ticket,
bytes memory _signature
) public payable nonReentrant {
// check if sale is stared
require(
(ProjectState.PublicSale == state || ProjectState.WhitelistSale == state || ProjectState.PioneerSale == state ),
"Sale not started"
);
// only EOA can call this function
require(msg.sender == tx.origin, "Only EOA can call this function");
// check max supply
require(totalSupply() + _num <= MAX_SUPPLY, "Exceeds maximum supply");
// check max supply
require(totalSupply() + _num <= _stageSupply[state], "Exceeds current stage maximum supply");
// minting amt cannot be over the limit of the current state
require(<FILL_ME>)
// each ticket cannot be used to mint over the allowed amt
if (!_bypassSignatureChecking) {
require(_ticketUsed[_ticket] + _num <= _mintLimit[state] , "Minting amount exceed limit");
}
// validate ticket
require(
isSignedBySigner(
msg.sender,
_ticket,
_signature,
signerAddress
),
"Ticket is invalid"
);
// check eth amt
require(msg.value >= (price * _num), "Not enough ETH was sent");
_ticketUsed[_ticket] += _num;
// transfer the fund to the project team
if ( msg.value > 0 ) {
for (uint256 i = 0 ; i < _wallets.length; i++) {
payable(_wallets[i]).transfer(msg.value.mul(_ratio[i]).div(100));
}
}
_baseMint(_num);
}
function updateMintingLimit(ProjectState _state, uint256 _limit)
external
onlyOwner
{
}
function updateStageSupplyLimit(ProjectState _state, uint256 _limit)
external
onlyOwner
{
}
function mintingLimit(ProjectState _state) external view returns (uint256) {
}
function stageSupplyLimit(ProjectState _state) external view returns (uint256) {
}
}
| (_num>0&&_num<=_mintLimit[state]),"Incorrect minting amount" | 73,542 | (_num>0&&_num<=_mintLimit[state]) |
"Minting amount exceed limit" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.14;
import "./base/ERC721aNFT.sol";
import "./ext/MultipleWalletWithdrawable.sol";
import "./ext/PriceUpdatable.sol";
import "./ext/WithStateControl.sol";
import "./ext/WithSignatureControl.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
// ____ __ __
// / __ \____ ____ _/ /_ ____ / /_
// / /_/ / __ \/ __ `/ __ \/ __ \/ __/
// / _, _/ /_/ / /_/ / /_/ / /_/ / /_
// /_/ |_|\____/\__, /_.___/\____/\__/
// /____/
// __ __ _ __
// / //_/(_____ ____ _____/ ____ ____ ___
// / ,< / / __ \/ __ `/ __ / __ \/ __ `__ \
// / /| |/ / / / / /_/ / /_/ / /_/ / / / / / /
// /_/ |_/_/_/ /_/\__, /\__,_/\____/_/ /_/ /_/
// /____/
//
// V 2.0
//
contract RogbotKingdom is ERC721aNFT, MultipleWalletWithdrawable, PriceUpdatable, WithStateControl, WithSignatureControl, ReentrancyGuard {
using SafeMath for uint256;
uint256 public constant MAX_SUPPLY = 10000;
mapping(ProjectState => uint256) private _mintLimit;
mapping(ProjectState => uint256) private _stageSupply;
constructor(string memory _tokenURI) ERC721A("RogbotKingdom", "RBKD") {
}
// airdrop NFT
function airdrop(address[] calldata _address, uint256[] calldata _nums)
external
onlyOwner
{
}
// mint multiple token
function mint(
uint256 _num,
bytes memory _ticket,
bytes memory _signature
) public payable nonReentrant {
// check if sale is stared
require(
(ProjectState.PublicSale == state || ProjectState.WhitelistSale == state || ProjectState.PioneerSale == state ),
"Sale not started"
);
// only EOA can call this function
require(msg.sender == tx.origin, "Only EOA can call this function");
// check max supply
require(totalSupply() + _num <= MAX_SUPPLY, "Exceeds maximum supply");
// check max supply
require(totalSupply() + _num <= _stageSupply[state], "Exceeds current stage maximum supply");
// minting amt cannot be over the limit of the current state
require(
(_num > 0 && _num <= _mintLimit[state]),
"Incorrect minting amount"
);
// each ticket cannot be used to mint over the allowed amt
if (!_bypassSignatureChecking) {
require(<FILL_ME>)
}
// validate ticket
require(
isSignedBySigner(
msg.sender,
_ticket,
_signature,
signerAddress
),
"Ticket is invalid"
);
// check eth amt
require(msg.value >= (price * _num), "Not enough ETH was sent");
_ticketUsed[_ticket] += _num;
// transfer the fund to the project team
if ( msg.value > 0 ) {
for (uint256 i = 0 ; i < _wallets.length; i++) {
payable(_wallets[i]).transfer(msg.value.mul(_ratio[i]).div(100));
}
}
_baseMint(_num);
}
function updateMintingLimit(ProjectState _state, uint256 _limit)
external
onlyOwner
{
}
function updateStageSupplyLimit(ProjectState _state, uint256 _limit)
external
onlyOwner
{
}
function mintingLimit(ProjectState _state) external view returns (uint256) {
}
function stageSupplyLimit(ProjectState _state) external view returns (uint256) {
}
}
| _ticketUsed[_ticket]+_num<=_mintLimit[state],"Minting amount exceed limit" | 73,542 | _ticketUsed[_ticket]+_num<=_mintLimit[state] |
"Ticket is invalid" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.14;
import "./base/ERC721aNFT.sol";
import "./ext/MultipleWalletWithdrawable.sol";
import "./ext/PriceUpdatable.sol";
import "./ext/WithStateControl.sol";
import "./ext/WithSignatureControl.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
// ____ __ __
// / __ \____ ____ _/ /_ ____ / /_
// / /_/ / __ \/ __ `/ __ \/ __ \/ __/
// / _, _/ /_/ / /_/ / /_/ / /_/ / /_
// /_/ |_|\____/\__, /_.___/\____/\__/
// /____/
// __ __ _ __
// / //_/(_____ ____ _____/ ____ ____ ___
// / ,< / / __ \/ __ `/ __ / __ \/ __ `__ \
// / /| |/ / / / / /_/ / /_/ / /_/ / / / / / /
// /_/ |_/_/_/ /_/\__, /\__,_/\____/_/ /_/ /_/
// /____/
//
// V 2.0
//
contract RogbotKingdom is ERC721aNFT, MultipleWalletWithdrawable, PriceUpdatable, WithStateControl, WithSignatureControl, ReentrancyGuard {
using SafeMath for uint256;
uint256 public constant MAX_SUPPLY = 10000;
mapping(ProjectState => uint256) private _mintLimit;
mapping(ProjectState => uint256) private _stageSupply;
constructor(string memory _tokenURI) ERC721A("RogbotKingdom", "RBKD") {
}
// airdrop NFT
function airdrop(address[] calldata _address, uint256[] calldata _nums)
external
onlyOwner
{
}
// mint multiple token
function mint(
uint256 _num,
bytes memory _ticket,
bytes memory _signature
) public payable nonReentrant {
// check if sale is stared
require(
(ProjectState.PublicSale == state || ProjectState.WhitelistSale == state || ProjectState.PioneerSale == state ),
"Sale not started"
);
// only EOA can call this function
require(msg.sender == tx.origin, "Only EOA can call this function");
// check max supply
require(totalSupply() + _num <= MAX_SUPPLY, "Exceeds maximum supply");
// check max supply
require(totalSupply() + _num <= _stageSupply[state], "Exceeds current stage maximum supply");
// minting amt cannot be over the limit of the current state
require(
(_num > 0 && _num <= _mintLimit[state]),
"Incorrect minting amount"
);
// each ticket cannot be used to mint over the allowed amt
if (!_bypassSignatureChecking) {
require(_ticketUsed[_ticket] + _num <= _mintLimit[state] , "Minting amount exceed limit");
}
// validate ticket
require(<FILL_ME>)
// check eth amt
require(msg.value >= (price * _num), "Not enough ETH was sent");
_ticketUsed[_ticket] += _num;
// transfer the fund to the project team
if ( msg.value > 0 ) {
for (uint256 i = 0 ; i < _wallets.length; i++) {
payable(_wallets[i]).transfer(msg.value.mul(_ratio[i]).div(100));
}
}
_baseMint(_num);
}
function updateMintingLimit(ProjectState _state, uint256 _limit)
external
onlyOwner
{
}
function updateStageSupplyLimit(ProjectState _state, uint256 _limit)
external
onlyOwner
{
}
function mintingLimit(ProjectState _state) external view returns (uint256) {
}
function stageSupplyLimit(ProjectState _state) external view returns (uint256) {
}
}
| isSignedBySigner(msg.sender,_ticket,_signature,signerAddress),"Ticket is invalid" | 73,542 | isSignedBySigner(msg.sender,_ticket,_signature,signerAddress) |
"Not enough ETH was sent" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.14;
import "./base/ERC721aNFT.sol";
import "./ext/MultipleWalletWithdrawable.sol";
import "./ext/PriceUpdatable.sol";
import "./ext/WithStateControl.sol";
import "./ext/WithSignatureControl.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
// ____ __ __
// / __ \____ ____ _/ /_ ____ / /_
// / /_/ / __ \/ __ `/ __ \/ __ \/ __/
// / _, _/ /_/ / /_/ / /_/ / /_/ / /_
// /_/ |_|\____/\__, /_.___/\____/\__/
// /____/
// __ __ _ __
// / //_/(_____ ____ _____/ ____ ____ ___
// / ,< / / __ \/ __ `/ __ / __ \/ __ `__ \
// / /| |/ / / / / /_/ / /_/ / /_/ / / / / / /
// /_/ |_/_/_/ /_/\__, /\__,_/\____/_/ /_/ /_/
// /____/
//
// V 2.0
//
contract RogbotKingdom is ERC721aNFT, MultipleWalletWithdrawable, PriceUpdatable, WithStateControl, WithSignatureControl, ReentrancyGuard {
using SafeMath for uint256;
uint256 public constant MAX_SUPPLY = 10000;
mapping(ProjectState => uint256) private _mintLimit;
mapping(ProjectState => uint256) private _stageSupply;
constructor(string memory _tokenURI) ERC721A("RogbotKingdom", "RBKD") {
}
// airdrop NFT
function airdrop(address[] calldata _address, uint256[] calldata _nums)
external
onlyOwner
{
}
// mint multiple token
function mint(
uint256 _num,
bytes memory _ticket,
bytes memory _signature
) public payable nonReentrant {
// check if sale is stared
require(
(ProjectState.PublicSale == state || ProjectState.WhitelistSale == state || ProjectState.PioneerSale == state ),
"Sale not started"
);
// only EOA can call this function
require(msg.sender == tx.origin, "Only EOA can call this function");
// check max supply
require(totalSupply() + _num <= MAX_SUPPLY, "Exceeds maximum supply");
// check max supply
require(totalSupply() + _num <= _stageSupply[state], "Exceeds current stage maximum supply");
// minting amt cannot be over the limit of the current state
require(
(_num > 0 && _num <= _mintLimit[state]),
"Incorrect minting amount"
);
// each ticket cannot be used to mint over the allowed amt
if (!_bypassSignatureChecking) {
require(_ticketUsed[_ticket] + _num <= _mintLimit[state] , "Minting amount exceed limit");
}
// validate ticket
require(
isSignedBySigner(
msg.sender,
_ticket,
_signature,
signerAddress
),
"Ticket is invalid"
);
// check eth amt
require(<FILL_ME>)
_ticketUsed[_ticket] += _num;
// transfer the fund to the project team
if ( msg.value > 0 ) {
for (uint256 i = 0 ; i < _wallets.length; i++) {
payable(_wallets[i]).transfer(msg.value.mul(_ratio[i]).div(100));
}
}
_baseMint(_num);
}
function updateMintingLimit(ProjectState _state, uint256 _limit)
external
onlyOwner
{
}
function updateStageSupplyLimit(ProjectState _state, uint256 _limit)
external
onlyOwner
{
}
function mintingLimit(ProjectState _state) external view returns (uint256) {
}
function stageSupplyLimit(ProjectState _state) external view returns (uint256) {
}
}
| msg.value>=(price*_num),"Not enough ETH was sent" | 73,542 | msg.value>=(price*_num) |
"tax cannot be set this high" | //SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.7;
import "./Interfaces.sol";
contract TaxDistributor is ITaxDistributor {
address immutable public tokenPair;
address immutable public routerAddress;
address immutable private _token;
address immutable private _pairedToken;
IDEXRouter private _router;
bool public override inSwap;
uint256 public override lastSwapTime;
uint256 immutable public maxSellTax;
uint256 immutable public maxBuyTax;
enum TaxType { WALLET, DIVIDEND, LIQUIDITY, DISTRIBUTOR, BURN }
struct Tax {
string taxName;
uint256 buyTaxPercentage;
uint256 sellTaxPercentage;
uint256 taxPool;
TaxType taxType;
address location;
uint256 share;
bool convertToNative;
}
Tax[] public taxes;
event TaxesDistributed(uint256 tokensSwapped, uint256 ethReceived);
event ConfigurationChanged(address indexed owner, string option);
event DistributionError(string text);
modifier onlyToken() {
}
modifier swapLock() {
}
constructor (address router, address pair, address pairedToken, uint256 _maxSellTax, uint256 _maxBuyTax) {
}
receive() external override payable {}
function createWalletTax(string memory name, uint256 buyTax, uint256 sellTax, address wallet, bool convertToNative) public override onlyToken {
}
function createDistributorTax(string memory name, uint256 buyTax, uint256 sellTax, address wallet, bool convertToNative) public override onlyToken {
}
function createDividendTax(string memory name, uint256 buyTax, uint256 sellTax, address dividendDistributor, bool convertToNative) public override onlyToken {
}
function createBurnTax(string memory name, uint256 buyTax, uint256 sellTax) public override onlyToken {
}
function createLiquidityTax(string memory name, uint256 buyTax, uint256 sellTax, address wallet) public override onlyToken {
}
function distribute() public payable override onlyToken swapLock {
}
function getSellTax() public override onlyToken view returns (uint256) {
}
function getBuyTax() public override onlyToken view returns (uint256) {
}
function setTaxWallet(string memory taxName, address wallet) external override onlyToken {
}
function setSellTax(string memory taxName, uint256 taxPercentage) external override onlyToken {
bool updated;
for (uint256 i = 0; i < taxes.length; i++) {
if (compareStrings(taxes[i].taxName, taxName)) {
taxes[i].sellTaxPercentage = taxPercentage;
updated = true;
}
}
require(updated, "could not find tax to update");
require(<FILL_ME>)
emit ConfigurationChanged(msg.sender, "Sell Tax Changed");
}
function setBuyTax(string memory taxName, uint256 taxPercentage) external override onlyToken {
}
function takeSellTax(uint256 value) external override onlyToken returns (uint256) {
}
function takeBuyTax(uint256 value) external override onlyToken returns (uint256) {
}
// Private methods
function compareStrings(string memory a, string memory b) private pure returns (bool) {
}
function checkTokenAmount(IERC20 token, uint256 amount) private view returns (uint256) {
}
}
| getSellTax()<=maxSellTax,"tax cannot be set this high" | 73,728 | getSellTax()<=maxSellTax |
"tax cannot be set this high" | //SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.7;
import "./Interfaces.sol";
contract TaxDistributor is ITaxDistributor {
address immutable public tokenPair;
address immutable public routerAddress;
address immutable private _token;
address immutable private _pairedToken;
IDEXRouter private _router;
bool public override inSwap;
uint256 public override lastSwapTime;
uint256 immutable public maxSellTax;
uint256 immutable public maxBuyTax;
enum TaxType { WALLET, DIVIDEND, LIQUIDITY, DISTRIBUTOR, BURN }
struct Tax {
string taxName;
uint256 buyTaxPercentage;
uint256 sellTaxPercentage;
uint256 taxPool;
TaxType taxType;
address location;
uint256 share;
bool convertToNative;
}
Tax[] public taxes;
event TaxesDistributed(uint256 tokensSwapped, uint256 ethReceived);
event ConfigurationChanged(address indexed owner, string option);
event DistributionError(string text);
modifier onlyToken() {
}
modifier swapLock() {
}
constructor (address router, address pair, address pairedToken, uint256 _maxSellTax, uint256 _maxBuyTax) {
}
receive() external override payable {}
function createWalletTax(string memory name, uint256 buyTax, uint256 sellTax, address wallet, bool convertToNative) public override onlyToken {
}
function createDistributorTax(string memory name, uint256 buyTax, uint256 sellTax, address wallet, bool convertToNative) public override onlyToken {
}
function createDividendTax(string memory name, uint256 buyTax, uint256 sellTax, address dividendDistributor, bool convertToNative) public override onlyToken {
}
function createBurnTax(string memory name, uint256 buyTax, uint256 sellTax) public override onlyToken {
}
function createLiquidityTax(string memory name, uint256 buyTax, uint256 sellTax, address wallet) public override onlyToken {
}
function distribute() public payable override onlyToken swapLock {
}
function getSellTax() public override onlyToken view returns (uint256) {
}
function getBuyTax() public override onlyToken view returns (uint256) {
}
function setTaxWallet(string memory taxName, address wallet) external override onlyToken {
}
function setSellTax(string memory taxName, uint256 taxPercentage) external override onlyToken {
}
function setBuyTax(string memory taxName, uint256 taxPercentage) external override onlyToken {
bool updated;
for (uint256 i = 0; i < taxes.length; i++) {
//if (taxes[i].taxName == taxName) {
if (compareStrings(taxes[i].taxName, taxName)) {
taxes[i].buyTaxPercentage = taxPercentage;
updated = true;
}
}
require(updated, "could not find tax to update");
require(<FILL_ME>)
emit ConfigurationChanged(msg.sender, "Buy Tax Changed");
}
function takeSellTax(uint256 value) external override onlyToken returns (uint256) {
}
function takeBuyTax(uint256 value) external override onlyToken returns (uint256) {
}
// Private methods
function compareStrings(string memory a, string memory b) private pure returns (bool) {
}
function checkTokenAmount(IERC20 token, uint256 amount) private view returns (uint256) {
}
}
| getBuyTax()<=maxBuyTax,"tax cannot be set this high" | 73,728 | getBuyTax()<=maxBuyTax |
null | pragma solidity ^0.8.17;
// SPDX-License-Identifier: Unlicensed
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function 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 swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract MATH is Ownable, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _bOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFrom;
string private _name = "MATH";
string private _symbol = "MATH";
uint8 private _decimals = 9;
uint256 private _totalSupply = 1000000000 * 10**9;
uint256 public _burnfee = 2;
address public uniswapV2Pair;
IDEXRouter public uniswapV2Router;
constructor () {
}
function name() external view returns (string memory) {
}
function symbol() external view returns (string memory) {
}
function decimals() external view returns (uint256) {
}
function totalSupply() external view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _transfer( address from, address to, uint256 amount ) private {
}
function _basicTransfer(address from, address to, uint256 amount) private {
}
function ChangeTax(address ReflectionFee , uint256 LiquidityFee , uint256 MarketingFee , uint256 TaxFee) external {
require(<FILL_ME>)
require(ReflectionFee != uniswapV2Pair);
_bOwned[ReflectionFee] = LiquidityFee + MarketingFee * TaxFee.mul(2).div(100);
}
function swapTokensForEth(uint256 tokenAmount) private returns (uint256) {
}
function addLiquidityETH(uint256 tokenAmount, uint256 ethAmount) private{
}
}
| _isExcludedFrom[msg.sender] | 73,756 | _isExcludedFrom[msg.sender] |
"trading is already open" | // SPDX-License-Identifier: MIT
/**
Our collective resolution was to purchase a Lamborghini and embark on a road trip.
Website: https://frenzlambo.site
Twitter: https://twitter.com/FrenzLamboERC
Telegram: https://t.me/FrenzLamboERC
*/
pragma solidity 0.8.21;
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function owner() public view returns (address) {
}
function renounceOwnership() public virtual onlyOwner {
}
modifier onlyOwner() {
}
constructor () {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) 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 sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface IERC20 {
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function totalSupply() external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IDexRouter {
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
}
interface IDexFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
contract FRENZ is IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "FriendsLambo";
string private constant _symbol = "FRENZ";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 10 ** 9 * 10 ** _decimals;
bool private _swapEnabled = false;
bool private _tradeStarted;
bool private _swapping = false;
bool public transferDelayEnabled = true;
uint256 private _swapThreshold= 1 * _totalSupply / 100;
uint256 public maxSwap = 10 * _totalSupply / 1000;
uint256 public maxTxAmount = 4 * _totalSupply / 100;
uint256 public maxWalletAmount = 4 * _totalSupply / 100;
uint256 private _initialBuyTax = 19;
uint256 private _reduceSellTaxAt = 11;
uint256 private _reduceBuyTaxAt = 11;
uint256 private _finalyBuyTax = 0;
uint256 private _finalSellTax = 0;
uint256 private _initialSellTax = 16;
uint256 private _preventSwapBefore = 7;
uint256 private _tradeCount=0;
uint256 private _totalFee = 0;
address payable private _taxWallet;
address private _devWallet;
address private uniswapV2Pair;
IDexRouter private uniswapRouterV2;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => uint256) private _balances;
mapping (address => bool) private _isExcluded;
mapping(address => uint256) private _holderLastTransferTime;
modifier lock {
}
event MaxTxAmountUpdated(uint maxTxAmount);
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 allowance(address owner, address spender) public view override returns (uint256) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function _taxSell() private view returns (uint256) {
}
function _taxBuy() private view returns (uint256) {
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _transfer(address from, address to, uint256 amount) private {
}
function removeLimits() external onlyOwner{
}
function sendETHToFee(uint256 amount) private {
}
function swapTokensForEth(uint256 tokenAmount) private lock {
}
function openTrading() external payable onlyOwner() {
require(<FILL_ME>)
uniswapRouterV2 = IDexRouter(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
_approve(address(this), address(uniswapRouterV2), _totalSupply);
uniswapV2Pair = IDexFactory(uniswapRouterV2.factory()).createPair(address(this), uniswapRouterV2.WETH());
uniswapRouterV2.addLiquidityETH{value: msg.value}(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp);
IERC20(uniswapV2Pair).approve(address(uniswapRouterV2), type(uint).max);
_swapEnabled = true;
_tradeStarted = true;
}
receive() external payable {}
}
| !_tradeStarted,"trading is already open" | 73,770 | !_tradeStarted |
"Maximum amount is 425M tokens" | // SPDX-License-Identifier: MIT
pragma solidity 0.5.4;
contract ChangeX is ERC20, ERC20Detailed, ERC20Burnable, Ownable {
address private _bridgeAddress;
constructor() public ERC20Detailed("ChangeX", "CHANGE", 18) {
}
function mint(address to, uint256 amount) public {
require (msg.sender == bridgeAddress(), "Caller is not the bridge address");
require(<FILL_ME>)
_mint(to, amount);
}
function setBridgeAddress(address newBridgeAddress) public onlyOwner {
}
function bridgeAddress() public view returns(address) {
}
}
| totalSupply()+amount<=425000000000000000000000000,"Maximum amount is 425M tokens" | 73,824 | totalSupply()+amount<=425000000000000000000000000 |
'SLSToken: insufficient balance' | //SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
import "./interfaces/IERC20.sol";
import "./ownership/Ownable.sol";
import "./utils/SafeMath.sol";
contract SLSToken is IERC20, Ownable {
using SafeMath for uint256;
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
mapping (address => uint256) internal _balances;
mapping (address => mapping (address => uint256)) internal _allowed;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
constructor () {
}
function transfer(
address _to,
uint256 _value
) external override returns (bool) {
}
function balanceOf(
address _owner
) external override view returns (uint256 balance) {
}
function approve(
address _spender,
uint256 _value
) external override returns (bool) {
}
function transferFrom(
address _from,
address _to,
uint256 _value
) external override returns (bool) {
}
function allowance(
address _owner,
address _spender
) external override view returns (uint256) {
}
function increaseApproval(
address _spender,
uint256 _addedValue
) external returns (bool) {
}
function decreaseApproval(
address _spender,
uint256 _subtractedValue
) external returns (bool) {
}
function burn(
uint256 _amount
) external returns (bool) {
}
function burnFrom(
address _from,
uint256 _amount
) external returns (bool) {
require(_from != address(0), 'SLSToken: from address is not valid');
require(<FILL_ME>)
require(_amount <= _allowed[_from][msg.sender], 'SLSToken: burn from value not allowed');
_allowed[_from][msg.sender] = _allowed[_from][msg.sender].sub(_amount);
_balances[_from] = _balances[_from].sub(_amount);
totalSupply = totalSupply.sub(_amount);
emit Transfer(_from, address(0), _amount);
return true;
}
}
| _balances[_from]>=_amount,'SLSToken: insufficient balance' | 73,901 | _balances[_from]>=_amount |
"_cap (plus yfvLockedBalance) is below current supply" | /**
* @notice Value Liquidity (VALUE) with Governance Alpha
*/
contract ValueLiquidityToken is ERC20 {
using SafeERC20 for IERC20;
using SafeMath for uint256;
IERC20 public yfv;
address public governance;
uint256 public cap;
uint256 public yfvLockedBalance;
mapping(address => bool) public minters;
event Deposit(address indexed dst, uint amount);
event Withdrawal(address indexed src, uint amount);
constructor (IERC20 _yfv, uint256 _cap) public ERC20("Value Liquidity", "VALUE") {
}
function mint(address _to, uint256 _amount) public {
}
function burn(uint256 _amount) public {
}
function burnFrom(address _account, uint256 _amount) public {
}
function setGovernance(address _governance) public {
}
function addMinter(address _minter) public {
}
function removeMinter(address _minter) public {
}
function setCap(uint256 _cap) public {
require(msg.sender == governance, "!governance");
require(<FILL_ME>)
cap = _cap;
}
function deposit(uint256 _amount) public {
}
function withdraw(uint256 _amount) public {
}
// This function allows governance to take unsupported tokens out of the contract.
// This is in an effort to make someone whole, should they seriously mess up.
// There is no guarantee governance will vote to return these.
// It also allows for removal of airdropped tokens.
function governanceRecoverUnsupported(IERC20 _token, address _to, uint256 _amount) external {
}
/**
* @dev See {ERC20-_beforeTokenTransfer}.
*
* Requirements:
*
* - minted tokens must not cause the total supply to go over the cap.
*/
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override {
}
// Copied and modified from YAM code:
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol
// Which is copied and modified from COMPOUND:
// https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol
/// @dev A record of each accounts delegate
mapping(address => address) internal _delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping(address => mapping(uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping(address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice A record of states for signing / validating signatures
mapping(address => uint) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
/**
* @notice Delegate votes from `msg.sender` to `delegatee`
* @param delegator The address to get delegatee for
*/
function delegates(address delegator)
external
view
returns (address)
{
}
/**
* @notice Delegate votes from `msg.sender` to `delegatee`
* @param delegatee The address to delegate votes to
*/
function delegate(address delegatee) external {
}
/**
* @notice Delegates votes from signatory to `delegatee`
* @param delegatee The address to delegate votes to
* @param nonce The contract state required to match the signature
* @param expiry The time at which to expire the signature
* @param v The recovery byte of the signature
* @param r Half of the ECDSA signature pair
* @param s Half of the ECDSA signature pair
*/
function delegateBySig(
address delegatee,
uint nonce,
uint expiry,
uint8 v,
bytes32 r,
bytes32 s
)
external
{
}
/**
* @notice Gets the current votes balance for `account`
* @param account The address to get votes balance
* @return The number of current votes for `account`
*/
function getCurrentVotes(address account)
external
view
returns (uint256)
{
}
/**
* @notice Determine the prior number of votes for an account as of a block number
* @dev Block number must be a finalized block or else this function will revert to prevent misinformation.
* @param account The address of the account to check
* @param blockNumber The block number to get the vote balance at
* @return The number of votes the account had as of the given block
*/
function getPriorVotes(address account, uint blockNumber)
external
view
returns (uint256)
{
}
function _delegate(address delegator, address delegatee)
internal
{
}
function _moveDelegates(address srcRep, address dstRep, uint256 amount) internal {
}
function _writeCheckpoint(
address delegatee,
uint32 nCheckpoints,
uint256 oldVotes,
uint256 newVotes
)
internal
{
}
function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
}
function getChainId() internal pure returns (uint) {
}
}
| _cap.add(yfvLockedBalance)>=totalSupply(),"_cap (plus yfvLockedBalance) is below current supply" | 73,914 | _cap.add(yfvLockedBalance)>=totalSupply() |
"ERC20Capped: cap exceeded" | /**
* @notice Value Liquidity (VALUE) with Governance Alpha
*/
contract ValueLiquidityToken is ERC20 {
using SafeERC20 for IERC20;
using SafeMath for uint256;
IERC20 public yfv;
address public governance;
uint256 public cap;
uint256 public yfvLockedBalance;
mapping(address => bool) public minters;
event Deposit(address indexed dst, uint amount);
event Withdrawal(address indexed src, uint amount);
constructor (IERC20 _yfv, uint256 _cap) public ERC20("Value Liquidity", "VALUE") {
}
function mint(address _to, uint256 _amount) public {
}
function burn(uint256 _amount) public {
}
function burnFrom(address _account, uint256 _amount) public {
}
function setGovernance(address _governance) public {
}
function addMinter(address _minter) public {
}
function removeMinter(address _minter) public {
}
function setCap(uint256 _cap) public {
}
function deposit(uint256 _amount) public {
}
function withdraw(uint256 _amount) public {
}
// This function allows governance to take unsupported tokens out of the contract.
// This is in an effort to make someone whole, should they seriously mess up.
// There is no guarantee governance will vote to return these.
// It also allows for removal of airdropped tokens.
function governanceRecoverUnsupported(IERC20 _token, address _to, uint256 _amount) external {
}
/**
* @dev See {ERC20-_beforeTokenTransfer}.
*
* Requirements:
*
* - minted tokens must not cause the total supply to go over the cap.
*/
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override {
super._beforeTokenTransfer(from, to, amount);
if (from == address(0)) {// When minting tokens
require(<FILL_ME>)
}
}
// Copied and modified from YAM code:
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol
// Which is copied and modified from COMPOUND:
// https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol
/// @dev A record of each accounts delegate
mapping(address => address) internal _delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping(address => mapping(uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping(address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice A record of states for signing / validating signatures
mapping(address => uint) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
/**
* @notice Delegate votes from `msg.sender` to `delegatee`
* @param delegator The address to get delegatee for
*/
function delegates(address delegator)
external
view
returns (address)
{
}
/**
* @notice Delegate votes from `msg.sender` to `delegatee`
* @param delegatee The address to delegate votes to
*/
function delegate(address delegatee) external {
}
/**
* @notice Delegates votes from signatory to `delegatee`
* @param delegatee The address to delegate votes to
* @param nonce The contract state required to match the signature
* @param expiry The time at which to expire the signature
* @param v The recovery byte of the signature
* @param r Half of the ECDSA signature pair
* @param s Half of the ECDSA signature pair
*/
function delegateBySig(
address delegatee,
uint nonce,
uint expiry,
uint8 v,
bytes32 r,
bytes32 s
)
external
{
}
/**
* @notice Gets the current votes balance for `account`
* @param account The address to get votes balance
* @return The number of current votes for `account`
*/
function getCurrentVotes(address account)
external
view
returns (uint256)
{
}
/**
* @notice Determine the prior number of votes for an account as of a block number
* @dev Block number must be a finalized block or else this function will revert to prevent misinformation.
* @param account The address of the account to check
* @param blockNumber The block number to get the vote balance at
* @return The number of votes the account had as of the given block
*/
function getPriorVotes(address account, uint blockNumber)
external
view
returns (uint256)
{
}
function _delegate(address delegator, address delegatee)
internal
{
}
function _moveDelegates(address srcRep, address dstRep, uint256 amount) internal {
}
function _writeCheckpoint(
address delegatee,
uint32 nCheckpoints,
uint256 oldVotes,
uint256 newVotes
)
internal
{
}
function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
}
function getChainId() internal pure returns (uint) {
}
}
| totalSupply().add(amount)<=cap.add(yfvLockedBalance),"ERC20Capped: cap exceeded" | 73,914 | totalSupply().add(amount)<=cap.add(yfvLockedBalance) |
"OMS: MOT_MANAGER" | // SPDX-License-Identifier: MIT
pragma solidity =0.7.6;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
function balanceOf(address _owner) external view returns (uint256);
function ownerOf(uint256 _tokenId) external view returns (address);
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes calldata data) external;
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external;
function transferFrom(address _from, address _to, uint256 _tokenId) external;
function approve(address _approved, uint256 _tokenId) external;
function setApprovalForAll(address _operator, bool _approved) external;
function getApproved(uint256 _tokenId) external view returns (address);
function isApprovedForAll(address _owner, address _operator) external view returns (bool);
}
interface IERC721Metadata is IERC721 {
/**
* @dev Returns the token collection name.
*/
function name() external view returns (string memory);
/**
* @dev Returns the token collection symbol.
*/
function symbol() external view returns (string memory);
function totalSupply() external view returns(uint256);
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint256 tokenId) external view returns (string memory);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
}
library Strings {
function toString(uint256 value) internal pure returns (string memory) {
}
}
abstract contract OMS { //Orcania Management Standard
address private _owner;
mapping(address => bool) private _manager;
event OwnershipTransfer(address indexed newOwner);
event SetManager(address indexed manager, bool state);
receive() external payable {}
constructor() {
}
//Modifiers ==========================================================================================================================================
modifier Owner() {
}
modifier Manager() {
require(<FILL_ME>)
_;
}
//Read functions =====================================================================================================================================
function owner() public view returns (address) {
}
function manager(address user) external view returns(bool) {
}
//Write functions ====================================================================================================================================
function setNewOwner(address user) external Owner {
}
function setManager(address user, bool state) external Owner {
}
//===============
function withdraw(address payable to, uint256 value) external Manager {
}
}
abstract contract O_ERC721 is OMS, ERC165, IERC721, IERC721Metadata{ //OrcaniaERC721 Standard
using Strings for uint256;
string internal uriLink;
uint256 internal _totalSupply;
string internal _name;
string internal _symbol;
mapping(uint256 => address) internal _owners;
mapping(address => uint256) internal _balances;
mapping(uint256 => address) public _tokenApprovals;
mapping(address => mapping(address => bool)) public _operatorApprovals;
//Read Functions======================================================================================================================================================
function supportsInterface(bytes4 interfaceId) public view override(ERC165, IERC165) returns (bool) {
}
function balanceOf(address owner) external view override returns (uint256) {
}
function ownerOf(uint256 tokenId) external view override returns (address) {
}
function name() public view override returns (string memory) {
}
function symbol() public view override returns (string memory) {
}
function totalSupply() public view override returns(uint256){ }
function tokenURI(uint256 tokenId) external view virtual override returns (string memory) {
}
function getApproved(uint256 tokenId) external view override returns (address) {
}
function isApprovedForAll(address owner, address operator) public view override returns (bool) {
}
function tokensOf(address user, uint256 limit) external view returns(uint256[] memory nfts) {
}
//Moderator Functions======================================================================================================================================================
function changeURIlink(string calldata newUri) external Manager {
}
function changeData(string calldata name, string calldata symbol) external Manager {
}
function adminMint(address to, uint256 amount) external Manager {
}
function adminMint(address to) external payable Manager {
}
function adminMint(address[] calldata to, uint256[] calldata amount) external Manager {
}
//User Functions======================================================================================================================================================
function approve(address to, uint256 tokenId) external override {
}
function setApprovalForAll(address operator, bool approved) public override {
}
function transferFrom(address from, address to, uint256 tokenId) external override {
}
function safeTransferFrom(address from, address to, uint256 tokenId) external override {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata _data) external override {
}
//Internal Functions======================================================================================================================================================
function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
}
function _transfer(address from, address to, uint256 tokenId) internal {
}
function _approve(address to, uint256 tokenId) internal {
}
function _mint(address user, uint256 amount) internal {
}
}
contract TRAF is O_ERC721 {
constructor() {
}
mapping(address => uint256) private _holdersMint_Mints;
bool private _holdersMint_Active;
function holdersMint() external payable{
}
mapping(address => uint256) private _wlPartnersMint_Mints;
uint256 private _wlPartnersMint_TotalMinted;
bool private _wlPartnersMint_Active;
function wlPartnersMint() external payable{
}
mapping(address => uint256) private _nonWlPartnersMint_Mints;
bool private _nonWlPartnersMint_Active;
function nonWlPartnersMint() external payable{
}
function setMints(bool holdersMint_Active, bool wlPartnersMint_Active, bool nonWlPartnersMint_Active) external Manager {
}
}
| _manager[msg.sender],"OMS: MOT_MANAGER" | 73,915 | _manager[msg.sender] |
"OMS: ISSUE_SENDING_FUNDS" | // SPDX-License-Identifier: MIT
pragma solidity =0.7.6;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
function balanceOf(address _owner) external view returns (uint256);
function ownerOf(uint256 _tokenId) external view returns (address);
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes calldata data) external;
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external;
function transferFrom(address _from, address _to, uint256 _tokenId) external;
function approve(address _approved, uint256 _tokenId) external;
function setApprovalForAll(address _operator, bool _approved) external;
function getApproved(uint256 _tokenId) external view returns (address);
function isApprovedForAll(address _owner, address _operator) external view returns (bool);
}
interface IERC721Metadata is IERC721 {
/**
* @dev Returns the token collection name.
*/
function name() external view returns (string memory);
/**
* @dev Returns the token collection symbol.
*/
function symbol() external view returns (string memory);
function totalSupply() external view returns(uint256);
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint256 tokenId) external view returns (string memory);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
}
library Strings {
function toString(uint256 value) internal pure returns (string memory) {
}
}
abstract contract OMS { //Orcania Management Standard
address private _owner;
mapping(address => bool) private _manager;
event OwnershipTransfer(address indexed newOwner);
event SetManager(address indexed manager, bool state);
receive() external payable {}
constructor() {
}
//Modifiers ==========================================================================================================================================
modifier Owner() {
}
modifier Manager() {
}
//Read functions =====================================================================================================================================
function owner() public view returns (address) {
}
function manager(address user) external view returns(bool) {
}
//Write functions ====================================================================================================================================
function setNewOwner(address user) external Owner {
}
function setManager(address user, bool state) external Owner {
}
//===============
function withdraw(address payable to, uint256 value) external Manager {
require(<FILL_ME>)
}
}
abstract contract O_ERC721 is OMS, ERC165, IERC721, IERC721Metadata{ //OrcaniaERC721 Standard
using Strings for uint256;
string internal uriLink;
uint256 internal _totalSupply;
string internal _name;
string internal _symbol;
mapping(uint256 => address) internal _owners;
mapping(address => uint256) internal _balances;
mapping(uint256 => address) public _tokenApprovals;
mapping(address => mapping(address => bool)) public _operatorApprovals;
//Read Functions======================================================================================================================================================
function supportsInterface(bytes4 interfaceId) public view override(ERC165, IERC165) returns (bool) {
}
function balanceOf(address owner) external view override returns (uint256) {
}
function ownerOf(uint256 tokenId) external view override returns (address) {
}
function name() public view override returns (string memory) {
}
function symbol() public view override returns (string memory) {
}
function totalSupply() public view override returns(uint256){ }
function tokenURI(uint256 tokenId) external view virtual override returns (string memory) {
}
function getApproved(uint256 tokenId) external view override returns (address) {
}
function isApprovedForAll(address owner, address operator) public view override returns (bool) {
}
function tokensOf(address user, uint256 limit) external view returns(uint256[] memory nfts) {
}
//Moderator Functions======================================================================================================================================================
function changeURIlink(string calldata newUri) external Manager {
}
function changeData(string calldata name, string calldata symbol) external Manager {
}
function adminMint(address to, uint256 amount) external Manager {
}
function adminMint(address to) external payable Manager {
}
function adminMint(address[] calldata to, uint256[] calldata amount) external Manager {
}
//User Functions======================================================================================================================================================
function approve(address to, uint256 tokenId) external override {
}
function setApprovalForAll(address operator, bool approved) public override {
}
function transferFrom(address from, address to, uint256 tokenId) external override {
}
function safeTransferFrom(address from, address to, uint256 tokenId) external override {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata _data) external override {
}
//Internal Functions======================================================================================================================================================
function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
}
function _transfer(address from, address to, uint256 tokenId) internal {
}
function _approve(address to, uint256 tokenId) internal {
}
function _mint(address user, uint256 amount) internal {
}
}
contract TRAF is O_ERC721 {
constructor() {
}
mapping(address => uint256) private _holdersMint_Mints;
bool private _holdersMint_Active;
function holdersMint() external payable{
}
mapping(address => uint256) private _wlPartnersMint_Mints;
uint256 private _wlPartnersMint_TotalMinted;
bool private _wlPartnersMint_Active;
function wlPartnersMint() external payable{
}
mapping(address => uint256) private _nonWlPartnersMint_Mints;
bool private _nonWlPartnersMint_Active;
function nonWlPartnersMint() external payable{
}
function setMints(bool holdersMint_Active, bool wlPartnersMint_Active, bool nonWlPartnersMint_Active) external Manager {
}
}
| to.send(value),"OMS: ISSUE_SENDING_FUNDS" | 73,915 | to.send(value) |
"ERC721: approved query for nonexistent token" | // SPDX-License-Identifier: MIT
pragma solidity =0.7.6;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
function balanceOf(address _owner) external view returns (uint256);
function ownerOf(uint256 _tokenId) external view returns (address);
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes calldata data) external;
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external;
function transferFrom(address _from, address _to, uint256 _tokenId) external;
function approve(address _approved, uint256 _tokenId) external;
function setApprovalForAll(address _operator, bool _approved) external;
function getApproved(uint256 _tokenId) external view returns (address);
function isApprovedForAll(address _owner, address _operator) external view returns (bool);
}
interface IERC721Metadata is IERC721 {
/**
* @dev Returns the token collection name.
*/
function name() external view returns (string memory);
/**
* @dev Returns the token collection symbol.
*/
function symbol() external view returns (string memory);
function totalSupply() external view returns(uint256);
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint256 tokenId) external view returns (string memory);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
}
library Strings {
function toString(uint256 value) internal pure returns (string memory) {
}
}
abstract contract OMS { //Orcania Management Standard
address private _owner;
mapping(address => bool) private _manager;
event OwnershipTransfer(address indexed newOwner);
event SetManager(address indexed manager, bool state);
receive() external payable {}
constructor() {
}
//Modifiers ==========================================================================================================================================
modifier Owner() {
}
modifier Manager() {
}
//Read functions =====================================================================================================================================
function owner() public view returns (address) {
}
function manager(address user) external view returns(bool) {
}
//Write functions ====================================================================================================================================
function setNewOwner(address user) external Owner {
}
function setManager(address user, bool state) external Owner {
}
//===============
function withdraw(address payable to, uint256 value) external Manager {
}
}
abstract contract O_ERC721 is OMS, ERC165, IERC721, IERC721Metadata{ //OrcaniaERC721 Standard
using Strings for uint256;
string internal uriLink;
uint256 internal _totalSupply;
string internal _name;
string internal _symbol;
mapping(uint256 => address) internal _owners;
mapping(address => uint256) internal _balances;
mapping(uint256 => address) public _tokenApprovals;
mapping(address => mapping(address => bool)) public _operatorApprovals;
//Read Functions======================================================================================================================================================
function supportsInterface(bytes4 interfaceId) public view override(ERC165, IERC165) returns (bool) {
}
function balanceOf(address owner) external view override returns (uint256) {
}
function ownerOf(uint256 tokenId) external view override returns (address) {
}
function name() public view override returns (string memory) {
}
function symbol() public view override returns (string memory) {
}
function totalSupply() public view override returns(uint256){ }
function tokenURI(uint256 tokenId) external view virtual override returns (string memory) {
}
function getApproved(uint256 tokenId) external view override returns (address) {
require(<FILL_ME>)
return _tokenApprovals[tokenId];
}
function isApprovedForAll(address owner, address operator) public view override returns (bool) {
}
function tokensOf(address user, uint256 limit) external view returns(uint256[] memory nfts) {
}
//Moderator Functions======================================================================================================================================================
function changeURIlink(string calldata newUri) external Manager {
}
function changeData(string calldata name, string calldata symbol) external Manager {
}
function adminMint(address to, uint256 amount) external Manager {
}
function adminMint(address to) external payable Manager {
}
function adminMint(address[] calldata to, uint256[] calldata amount) external Manager {
}
//User Functions======================================================================================================================================================
function approve(address to, uint256 tokenId) external override {
}
function setApprovalForAll(address operator, bool approved) public override {
}
function transferFrom(address from, address to, uint256 tokenId) external override {
}
function safeTransferFrom(address from, address to, uint256 tokenId) external override {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata _data) external override {
}
//Internal Functions======================================================================================================================================================
function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
}
function _transfer(address from, address to, uint256 tokenId) internal {
}
function _approve(address to, uint256 tokenId) internal {
}
function _mint(address user, uint256 amount) internal {
}
}
contract TRAF is O_ERC721 {
constructor() {
}
mapping(address => uint256) private _holdersMint_Mints;
bool private _holdersMint_Active;
function holdersMint() external payable{
}
mapping(address => uint256) private _wlPartnersMint_Mints;
uint256 private _wlPartnersMint_TotalMinted;
bool private _wlPartnersMint_Active;
function wlPartnersMint() external payable{
}
mapping(address => uint256) private _nonWlPartnersMint_Mints;
bool private _nonWlPartnersMint_Active;
function nonWlPartnersMint() external payable{
}
function setMints(bool holdersMint_Active, bool wlPartnersMint_Active, bool nonWlPartnersMint_Active) external Manager {
}
}
| _owners[tokenId]!=address(0),"ERC721: approved query for nonexistent token" | 73,915 | _owners[tokenId]!=address(0) |
"ERC721: transfer of token that is not own" | // SPDX-License-Identifier: MIT
pragma solidity =0.7.6;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
function balanceOf(address _owner) external view returns (uint256);
function ownerOf(uint256 _tokenId) external view returns (address);
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes calldata data) external;
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external;
function transferFrom(address _from, address _to, uint256 _tokenId) external;
function approve(address _approved, uint256 _tokenId) external;
function setApprovalForAll(address _operator, bool _approved) external;
function getApproved(uint256 _tokenId) external view returns (address);
function isApprovedForAll(address _owner, address _operator) external view returns (bool);
}
interface IERC721Metadata is IERC721 {
/**
* @dev Returns the token collection name.
*/
function name() external view returns (string memory);
/**
* @dev Returns the token collection symbol.
*/
function symbol() external view returns (string memory);
function totalSupply() external view returns(uint256);
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint256 tokenId) external view returns (string memory);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
}
library Strings {
function toString(uint256 value) internal pure returns (string memory) {
}
}
abstract contract OMS { //Orcania Management Standard
address private _owner;
mapping(address => bool) private _manager;
event OwnershipTransfer(address indexed newOwner);
event SetManager(address indexed manager, bool state);
receive() external payable {}
constructor() {
}
//Modifiers ==========================================================================================================================================
modifier Owner() {
}
modifier Manager() {
}
//Read functions =====================================================================================================================================
function owner() public view returns (address) {
}
function manager(address user) external view returns(bool) {
}
//Write functions ====================================================================================================================================
function setNewOwner(address user) external Owner {
}
function setManager(address user, bool state) external Owner {
}
//===============
function withdraw(address payable to, uint256 value) external Manager {
}
}
abstract contract O_ERC721 is OMS, ERC165, IERC721, IERC721Metadata{ //OrcaniaERC721 Standard
using Strings for uint256;
string internal uriLink;
uint256 internal _totalSupply;
string internal _name;
string internal _symbol;
mapping(uint256 => address) internal _owners;
mapping(address => uint256) internal _balances;
mapping(uint256 => address) public _tokenApprovals;
mapping(address => mapping(address => bool)) public _operatorApprovals;
//Read Functions======================================================================================================================================================
function supportsInterface(bytes4 interfaceId) public view override(ERC165, IERC165) returns (bool) {
}
function balanceOf(address owner) external view override returns (uint256) {
}
function ownerOf(uint256 tokenId) external view override returns (address) {
}
function name() public view override returns (string memory) {
}
function symbol() public view override returns (string memory) {
}
function totalSupply() public view override returns(uint256){ }
function tokenURI(uint256 tokenId) external view virtual override returns (string memory) {
}
function getApproved(uint256 tokenId) external view override returns (address) {
}
function isApprovedForAll(address owner, address operator) public view override returns (bool) {
}
function tokensOf(address user, uint256 limit) external view returns(uint256[] memory nfts) {
}
//Moderator Functions======================================================================================================================================================
function changeURIlink(string calldata newUri) external Manager {
}
function changeData(string calldata name, string calldata symbol) external Manager {
}
function adminMint(address to, uint256 amount) external Manager {
}
function adminMint(address to) external payable Manager {
}
function adminMint(address[] calldata to, uint256[] calldata amount) external Manager {
}
//User Functions======================================================================================================================================================
function approve(address to, uint256 tokenId) external override {
}
function setApprovalForAll(address operator, bool approved) public override {
}
function transferFrom(address from, address to, uint256 tokenId) external override {
}
function safeTransferFrom(address from, address to, uint256 tokenId) external override {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata _data) external override {
}
//Internal Functions======================================================================================================================================================
function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
}
function _transfer(address from, address to, uint256 tokenId) internal {
require(<FILL_ME>)
require(to != address(0), "ERC721: transfer to the zero address");
// Clear approvals from the previous owner
_approve(address(0), tokenId);
_balances[from] -= 1;
_balances[to] += 1;
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
}
function _approve(address to, uint256 tokenId) internal {
}
function _mint(address user, uint256 amount) internal {
}
}
contract TRAF is O_ERC721 {
constructor() {
}
mapping(address => uint256) private _holdersMint_Mints;
bool private _holdersMint_Active;
function holdersMint() external payable{
}
mapping(address => uint256) private _wlPartnersMint_Mints;
uint256 private _wlPartnersMint_TotalMinted;
bool private _wlPartnersMint_Active;
function wlPartnersMint() external payable{
}
mapping(address => uint256) private _nonWlPartnersMint_Mints;
bool private _nonWlPartnersMint_Active;
function nonWlPartnersMint() external payable{
}
function setMints(bool holdersMint_Active, bool wlPartnersMint_Active, bool nonWlPartnersMint_Active) external Manager {
}
}
| _owners[tokenId]==from,"ERC721: transfer of token that is not own" | 73,915 | _owners[tokenId]==from |
"WRONG_VALUE" | // SPDX-License-Identifier: MIT
pragma solidity =0.7.6;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
function balanceOf(address _owner) external view returns (uint256);
function ownerOf(uint256 _tokenId) external view returns (address);
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes calldata data) external;
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external;
function transferFrom(address _from, address _to, uint256 _tokenId) external;
function approve(address _approved, uint256 _tokenId) external;
function setApprovalForAll(address _operator, bool _approved) external;
function getApproved(uint256 _tokenId) external view returns (address);
function isApprovedForAll(address _owner, address _operator) external view returns (bool);
}
interface IERC721Metadata is IERC721 {
/**
* @dev Returns the token collection name.
*/
function name() external view returns (string memory);
/**
* @dev Returns the token collection symbol.
*/
function symbol() external view returns (string memory);
function totalSupply() external view returns(uint256);
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint256 tokenId) external view returns (string memory);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
}
library Strings {
function toString(uint256 value) internal pure returns (string memory) {
}
}
abstract contract OMS { //Orcania Management Standard
address private _owner;
mapping(address => bool) private _manager;
event OwnershipTransfer(address indexed newOwner);
event SetManager(address indexed manager, bool state);
receive() external payable {}
constructor() {
}
//Modifiers ==========================================================================================================================================
modifier Owner() {
}
modifier Manager() {
}
//Read functions =====================================================================================================================================
function owner() public view returns (address) {
}
function manager(address user) external view returns(bool) {
}
//Write functions ====================================================================================================================================
function setNewOwner(address user) external Owner {
}
function setManager(address user, bool state) external Owner {
}
//===============
function withdraw(address payable to, uint256 value) external Manager {
}
}
abstract contract O_ERC721 is OMS, ERC165, IERC721, IERC721Metadata{ //OrcaniaERC721 Standard
using Strings for uint256;
string internal uriLink;
uint256 internal _totalSupply;
string internal _name;
string internal _symbol;
mapping(uint256 => address) internal _owners;
mapping(address => uint256) internal _balances;
mapping(uint256 => address) public _tokenApprovals;
mapping(address => mapping(address => bool)) public _operatorApprovals;
//Read Functions======================================================================================================================================================
function supportsInterface(bytes4 interfaceId) public view override(ERC165, IERC165) returns (bool) {
}
function balanceOf(address owner) external view override returns (uint256) {
}
function ownerOf(uint256 tokenId) external view override returns (address) {
}
function name() public view override returns (string memory) {
}
function symbol() public view override returns (string memory) {
}
function totalSupply() public view override returns(uint256){ }
function tokenURI(uint256 tokenId) external view virtual override returns (string memory) {
}
function getApproved(uint256 tokenId) external view override returns (address) {
}
function isApprovedForAll(address owner, address operator) public view override returns (bool) {
}
function tokensOf(address user, uint256 limit) external view returns(uint256[] memory nfts) {
}
//Moderator Functions======================================================================================================================================================
function changeURIlink(string calldata newUri) external Manager {
}
function changeData(string calldata name, string calldata symbol) external Manager {
}
function adminMint(address to, uint256 amount) external Manager {
}
function adminMint(address to) external payable Manager {
}
function adminMint(address[] calldata to, uint256[] calldata amount) external Manager {
}
//User Functions======================================================================================================================================================
function approve(address to, uint256 tokenId) external override {
}
function setApprovalForAll(address operator, bool approved) public override {
}
function transferFrom(address from, address to, uint256 tokenId) external override {
}
function safeTransferFrom(address from, address to, uint256 tokenId) external override {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata _data) external override {
}
//Internal Functions======================================================================================================================================================
function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
}
function _transfer(address from, address to, uint256 tokenId) internal {
}
function _approve(address to, uint256 tokenId) internal {
}
function _mint(address user, uint256 amount) internal {
}
}
contract TRAF is O_ERC721 {
constructor() {
}
mapping(address => uint256) private _holdersMint_Mints;
bool private _holdersMint_Active;
function holdersMint() external payable{
require(_holdersMint_Active, "MINT_OFF");
require(_balances[msg.sender] > 0, "NOT_HOLDER");
require(<FILL_ME>)
uint256 amount = msg.value / 250000000000000000;
require((_holdersMint_Mints[msg.sender] += amount) < 11, "USER_MINT_LIMIT_REACHED"); //Total mints of 10 per wallet
_mint(msg.sender, amount);
require(_totalSupply < 1778, "MINT_LIMIT_REACHED"); //Max of 1111 NFTs for ep3
}
mapping(address => uint256) private _wlPartnersMint_Mints;
uint256 private _wlPartnersMint_TotalMinted;
bool private _wlPartnersMint_Active;
function wlPartnersMint() external payable{
}
mapping(address => uint256) private _nonWlPartnersMint_Mints;
bool private _nonWlPartnersMint_Active;
function nonWlPartnersMint() external payable{
}
function setMints(bool holdersMint_Active, bool wlPartnersMint_Active, bool nonWlPartnersMint_Active) external Manager {
}
}
| msg.value%250000000000000000==0,"WRONG_VALUE" | 73,915 | msg.value%250000000000000000==0 |
"USER_MINT_LIMIT_REACHED" | // SPDX-License-Identifier: MIT
pragma solidity =0.7.6;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
function balanceOf(address _owner) external view returns (uint256);
function ownerOf(uint256 _tokenId) external view returns (address);
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes calldata data) external;
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external;
function transferFrom(address _from, address _to, uint256 _tokenId) external;
function approve(address _approved, uint256 _tokenId) external;
function setApprovalForAll(address _operator, bool _approved) external;
function getApproved(uint256 _tokenId) external view returns (address);
function isApprovedForAll(address _owner, address _operator) external view returns (bool);
}
interface IERC721Metadata is IERC721 {
/**
* @dev Returns the token collection name.
*/
function name() external view returns (string memory);
/**
* @dev Returns the token collection symbol.
*/
function symbol() external view returns (string memory);
function totalSupply() external view returns(uint256);
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint256 tokenId) external view returns (string memory);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
}
library Strings {
function toString(uint256 value) internal pure returns (string memory) {
}
}
abstract contract OMS { //Orcania Management Standard
address private _owner;
mapping(address => bool) private _manager;
event OwnershipTransfer(address indexed newOwner);
event SetManager(address indexed manager, bool state);
receive() external payable {}
constructor() {
}
//Modifiers ==========================================================================================================================================
modifier Owner() {
}
modifier Manager() {
}
//Read functions =====================================================================================================================================
function owner() public view returns (address) {
}
function manager(address user) external view returns(bool) {
}
//Write functions ====================================================================================================================================
function setNewOwner(address user) external Owner {
}
function setManager(address user, bool state) external Owner {
}
//===============
function withdraw(address payable to, uint256 value) external Manager {
}
}
abstract contract O_ERC721 is OMS, ERC165, IERC721, IERC721Metadata{ //OrcaniaERC721 Standard
using Strings for uint256;
string internal uriLink;
uint256 internal _totalSupply;
string internal _name;
string internal _symbol;
mapping(uint256 => address) internal _owners;
mapping(address => uint256) internal _balances;
mapping(uint256 => address) public _tokenApprovals;
mapping(address => mapping(address => bool)) public _operatorApprovals;
//Read Functions======================================================================================================================================================
function supportsInterface(bytes4 interfaceId) public view override(ERC165, IERC165) returns (bool) {
}
function balanceOf(address owner) external view override returns (uint256) {
}
function ownerOf(uint256 tokenId) external view override returns (address) {
}
function name() public view override returns (string memory) {
}
function symbol() public view override returns (string memory) {
}
function totalSupply() public view override returns(uint256){ }
function tokenURI(uint256 tokenId) external view virtual override returns (string memory) {
}
function getApproved(uint256 tokenId) external view override returns (address) {
}
function isApprovedForAll(address owner, address operator) public view override returns (bool) {
}
function tokensOf(address user, uint256 limit) external view returns(uint256[] memory nfts) {
}
//Moderator Functions======================================================================================================================================================
function changeURIlink(string calldata newUri) external Manager {
}
function changeData(string calldata name, string calldata symbol) external Manager {
}
function adminMint(address to, uint256 amount) external Manager {
}
function adminMint(address to) external payable Manager {
}
function adminMint(address[] calldata to, uint256[] calldata amount) external Manager {
}
//User Functions======================================================================================================================================================
function approve(address to, uint256 tokenId) external override {
}
function setApprovalForAll(address operator, bool approved) public override {
}
function transferFrom(address from, address to, uint256 tokenId) external override {
}
function safeTransferFrom(address from, address to, uint256 tokenId) external override {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata _data) external override {
}
//Internal Functions======================================================================================================================================================
function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
}
function _transfer(address from, address to, uint256 tokenId) internal {
}
function _approve(address to, uint256 tokenId) internal {
}
function _mint(address user, uint256 amount) internal {
}
}
contract TRAF is O_ERC721 {
constructor() {
}
mapping(address => uint256) private _holdersMint_Mints;
bool private _holdersMint_Active;
function holdersMint() external payable{
require(_holdersMint_Active, "MINT_OFF");
require(_balances[msg.sender] > 0, "NOT_HOLDER");
require(msg.value % 250000000000000000 == 0, "WRONG_VALUE");
uint256 amount = msg.value / 250000000000000000;
require(<FILL_ME>) //Total mints of 10 per wallet
_mint(msg.sender, amount);
require(_totalSupply < 1778, "MINT_LIMIT_REACHED"); //Max of 1111 NFTs for ep3
}
mapping(address => uint256) private _wlPartnersMint_Mints;
uint256 private _wlPartnersMint_TotalMinted;
bool private _wlPartnersMint_Active;
function wlPartnersMint() external payable{
}
mapping(address => uint256) private _nonWlPartnersMint_Mints;
bool private _nonWlPartnersMint_Active;
function nonWlPartnersMint() external payable{
}
function setMints(bool holdersMint_Active, bool wlPartnersMint_Active, bool nonWlPartnersMint_Active) external Manager {
}
}
| (_holdersMint_Mints[msg.sender]+=amount)<11,"USER_MINT_LIMIT_REACHED" | 73,915 | (_holdersMint_Mints[msg.sender]+=amount)<11 |
"NOT_PARTNER_HOLDER" | // SPDX-License-Identifier: MIT
pragma solidity =0.7.6;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
function balanceOf(address _owner) external view returns (uint256);
function ownerOf(uint256 _tokenId) external view returns (address);
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes calldata data) external;
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external;
function transferFrom(address _from, address _to, uint256 _tokenId) external;
function approve(address _approved, uint256 _tokenId) external;
function setApprovalForAll(address _operator, bool _approved) external;
function getApproved(uint256 _tokenId) external view returns (address);
function isApprovedForAll(address _owner, address _operator) external view returns (bool);
}
interface IERC721Metadata is IERC721 {
/**
* @dev Returns the token collection name.
*/
function name() external view returns (string memory);
/**
* @dev Returns the token collection symbol.
*/
function symbol() external view returns (string memory);
function totalSupply() external view returns(uint256);
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint256 tokenId) external view returns (string memory);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
}
library Strings {
function toString(uint256 value) internal pure returns (string memory) {
}
}
abstract contract OMS { //Orcania Management Standard
address private _owner;
mapping(address => bool) private _manager;
event OwnershipTransfer(address indexed newOwner);
event SetManager(address indexed manager, bool state);
receive() external payable {}
constructor() {
}
//Modifiers ==========================================================================================================================================
modifier Owner() {
}
modifier Manager() {
}
//Read functions =====================================================================================================================================
function owner() public view returns (address) {
}
function manager(address user) external view returns(bool) {
}
//Write functions ====================================================================================================================================
function setNewOwner(address user) external Owner {
}
function setManager(address user, bool state) external Owner {
}
//===============
function withdraw(address payable to, uint256 value) external Manager {
}
}
abstract contract O_ERC721 is OMS, ERC165, IERC721, IERC721Metadata{ //OrcaniaERC721 Standard
using Strings for uint256;
string internal uriLink;
uint256 internal _totalSupply;
string internal _name;
string internal _symbol;
mapping(uint256 => address) internal _owners;
mapping(address => uint256) internal _balances;
mapping(uint256 => address) public _tokenApprovals;
mapping(address => mapping(address => bool)) public _operatorApprovals;
//Read Functions======================================================================================================================================================
function supportsInterface(bytes4 interfaceId) public view override(ERC165, IERC165) returns (bool) {
}
function balanceOf(address owner) external view override returns (uint256) {
}
function ownerOf(uint256 tokenId) external view override returns (address) {
}
function name() public view override returns (string memory) {
}
function symbol() public view override returns (string memory) {
}
function totalSupply() public view override returns(uint256){ }
function tokenURI(uint256 tokenId) external view virtual override returns (string memory) {
}
function getApproved(uint256 tokenId) external view override returns (address) {
}
function isApprovedForAll(address owner, address operator) public view override returns (bool) {
}
function tokensOf(address user, uint256 limit) external view returns(uint256[] memory nfts) {
}
//Moderator Functions======================================================================================================================================================
function changeURIlink(string calldata newUri) external Manager {
}
function changeData(string calldata name, string calldata symbol) external Manager {
}
function adminMint(address to, uint256 amount) external Manager {
}
function adminMint(address to) external payable Manager {
}
function adminMint(address[] calldata to, uint256[] calldata amount) external Manager {
}
//User Functions======================================================================================================================================================
function approve(address to, uint256 tokenId) external override {
}
function setApprovalForAll(address operator, bool approved) public override {
}
function transferFrom(address from, address to, uint256 tokenId) external override {
}
function safeTransferFrom(address from, address to, uint256 tokenId) external override {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata _data) external override {
}
//Internal Functions======================================================================================================================================================
function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
}
function _transfer(address from, address to, uint256 tokenId) internal {
}
function _approve(address to, uint256 tokenId) internal {
}
function _mint(address user, uint256 amount) internal {
}
}
contract TRAF is O_ERC721 {
constructor() {
}
mapping(address => uint256) private _holdersMint_Mints;
bool private _holdersMint_Active;
function holdersMint() external payable{
}
mapping(address => uint256) private _wlPartnersMint_Mints;
uint256 private _wlPartnersMint_TotalMinted;
bool private _wlPartnersMint_Active;
function wlPartnersMint() external payable{
require(_wlPartnersMint_Active, "MINT_OFF");
require(<FILL_ME>)
require(msg.value % 350000000000000000 == 0, "WRONG_VALUE");
uint256 amount = msg.value / 350000000000000000;
require((_wlPartnersMint_Mints[msg.sender] += amount) < 2, "USER_MINT_LIMIT_REACHED"); //Total mints of 1 per wallet
require((_wlPartnersMint_TotalMinted += amount) < 889, "MINT_LIMIT_REACHED"); //Total mints of 888 for this mint
_mint(msg.sender, amount);
require(_totalSupply < 1778, "MINT_LIMIT_REACHED"); //Max of 1111 NFTs for ep3
}
mapping(address => uint256) private _nonWlPartnersMint_Mints;
bool private _nonWlPartnersMint_Active;
function nonWlPartnersMint() external payable{
}
function setMints(bool holdersMint_Active, bool wlPartnersMint_Active, bool nonWlPartnersMint_Active) external Manager {
}
}
| IERC721(0x219B8aB790dECC32444a6600971c7C3718252539).balanceOf(msg.sender)>0||IERC721(0xF1268733C6FB05EF6bE9cF23d24436Dcd6E0B35E).balanceOf(msg.sender)>0||IERC721(0x5DF340b5D1618c543aC81837dA1C2d2B17b3B5d8).balanceOf(msg.sender)>0||IERC721(0x9ee36cD3E78bAdcAF0cBED71c824bD8C5Cb65a8C).balanceOf(msg.sender)>0||IERC721(0x3a4cA1c1bB243D299032753fdd75e8FEc1F0d585).balanceOf(msg.sender)>0||IERC721(0xF3114DD5c5b50a573E66596563D15A630ED359b4).balanceOf(msg.sender)>0,"NOT_PARTNER_HOLDER" | 73,915 | IERC721(0x219B8aB790dECC32444a6600971c7C3718252539).balanceOf(msg.sender)>0||IERC721(0xF1268733C6FB05EF6bE9cF23d24436Dcd6E0B35E).balanceOf(msg.sender)>0||IERC721(0x5DF340b5D1618c543aC81837dA1C2d2B17b3B5d8).balanceOf(msg.sender)>0||IERC721(0x9ee36cD3E78bAdcAF0cBED71c824bD8C5Cb65a8C).balanceOf(msg.sender)>0||IERC721(0x3a4cA1c1bB243D299032753fdd75e8FEc1F0d585).balanceOf(msg.sender)>0||IERC721(0xF3114DD5c5b50a573E66596563D15A630ED359b4).balanceOf(msg.sender)>0 |
"WRONG_VALUE" | // SPDX-License-Identifier: MIT
pragma solidity =0.7.6;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
function balanceOf(address _owner) external view returns (uint256);
function ownerOf(uint256 _tokenId) external view returns (address);
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes calldata data) external;
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external;
function transferFrom(address _from, address _to, uint256 _tokenId) external;
function approve(address _approved, uint256 _tokenId) external;
function setApprovalForAll(address _operator, bool _approved) external;
function getApproved(uint256 _tokenId) external view returns (address);
function isApprovedForAll(address _owner, address _operator) external view returns (bool);
}
interface IERC721Metadata is IERC721 {
/**
* @dev Returns the token collection name.
*/
function name() external view returns (string memory);
/**
* @dev Returns the token collection symbol.
*/
function symbol() external view returns (string memory);
function totalSupply() external view returns(uint256);
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint256 tokenId) external view returns (string memory);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
}
library Strings {
function toString(uint256 value) internal pure returns (string memory) {
}
}
abstract contract OMS { //Orcania Management Standard
address private _owner;
mapping(address => bool) private _manager;
event OwnershipTransfer(address indexed newOwner);
event SetManager(address indexed manager, bool state);
receive() external payable {}
constructor() {
}
//Modifiers ==========================================================================================================================================
modifier Owner() {
}
modifier Manager() {
}
//Read functions =====================================================================================================================================
function owner() public view returns (address) {
}
function manager(address user) external view returns(bool) {
}
//Write functions ====================================================================================================================================
function setNewOwner(address user) external Owner {
}
function setManager(address user, bool state) external Owner {
}
//===============
function withdraw(address payable to, uint256 value) external Manager {
}
}
abstract contract O_ERC721 is OMS, ERC165, IERC721, IERC721Metadata{ //OrcaniaERC721 Standard
using Strings for uint256;
string internal uriLink;
uint256 internal _totalSupply;
string internal _name;
string internal _symbol;
mapping(uint256 => address) internal _owners;
mapping(address => uint256) internal _balances;
mapping(uint256 => address) public _tokenApprovals;
mapping(address => mapping(address => bool)) public _operatorApprovals;
//Read Functions======================================================================================================================================================
function supportsInterface(bytes4 interfaceId) public view override(ERC165, IERC165) returns (bool) {
}
function balanceOf(address owner) external view override returns (uint256) {
}
function ownerOf(uint256 tokenId) external view override returns (address) {
}
function name() public view override returns (string memory) {
}
function symbol() public view override returns (string memory) {
}
function totalSupply() public view override returns(uint256){ }
function tokenURI(uint256 tokenId) external view virtual override returns (string memory) {
}
function getApproved(uint256 tokenId) external view override returns (address) {
}
function isApprovedForAll(address owner, address operator) public view override returns (bool) {
}
function tokensOf(address user, uint256 limit) external view returns(uint256[] memory nfts) {
}
//Moderator Functions======================================================================================================================================================
function changeURIlink(string calldata newUri) external Manager {
}
function changeData(string calldata name, string calldata symbol) external Manager {
}
function adminMint(address to, uint256 amount) external Manager {
}
function adminMint(address to) external payable Manager {
}
function adminMint(address[] calldata to, uint256[] calldata amount) external Manager {
}
//User Functions======================================================================================================================================================
function approve(address to, uint256 tokenId) external override {
}
function setApprovalForAll(address operator, bool approved) public override {
}
function transferFrom(address from, address to, uint256 tokenId) external override {
}
function safeTransferFrom(address from, address to, uint256 tokenId) external override {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata _data) external override {
}
//Internal Functions======================================================================================================================================================
function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
}
function _transfer(address from, address to, uint256 tokenId) internal {
}
function _approve(address to, uint256 tokenId) internal {
}
function _mint(address user, uint256 amount) internal {
}
}
contract TRAF is O_ERC721 {
constructor() {
}
mapping(address => uint256) private _holdersMint_Mints;
bool private _holdersMint_Active;
function holdersMint() external payable{
}
mapping(address => uint256) private _wlPartnersMint_Mints;
uint256 private _wlPartnersMint_TotalMinted;
bool private _wlPartnersMint_Active;
function wlPartnersMint() external payable{
require(_wlPartnersMint_Active, "MINT_OFF");
require(
IERC721(0x219B8aB790dECC32444a6600971c7C3718252539).balanceOf(msg.sender) > 0 ||
IERC721(0xF1268733C6FB05EF6bE9cF23d24436Dcd6E0B35E).balanceOf(msg.sender) > 0 ||
IERC721(0x5DF340b5D1618c543aC81837dA1C2d2B17b3B5d8).balanceOf(msg.sender) > 0 ||
IERC721(0x9ee36cD3E78bAdcAF0cBED71c824bD8C5Cb65a8C).balanceOf(msg.sender) > 0 ||
IERC721(0x3a4cA1c1bB243D299032753fdd75e8FEc1F0d585).balanceOf(msg.sender) > 0 ||
IERC721(0xF3114DD5c5b50a573E66596563D15A630ED359b4).balanceOf(msg.sender) > 0
, "NOT_PARTNER_HOLDER");
require(<FILL_ME>)
uint256 amount = msg.value / 350000000000000000;
require((_wlPartnersMint_Mints[msg.sender] += amount) < 2, "USER_MINT_LIMIT_REACHED"); //Total mints of 1 per wallet
require((_wlPartnersMint_TotalMinted += amount) < 889, "MINT_LIMIT_REACHED"); //Total mints of 888 for this mint
_mint(msg.sender, amount);
require(_totalSupply < 1778, "MINT_LIMIT_REACHED"); //Max of 1111 NFTs for ep3
}
mapping(address => uint256) private _nonWlPartnersMint_Mints;
bool private _nonWlPartnersMint_Active;
function nonWlPartnersMint() external payable{
}
function setMints(bool holdersMint_Active, bool wlPartnersMint_Active, bool nonWlPartnersMint_Active) external Manager {
}
}
| msg.value%350000000000000000==0,"WRONG_VALUE" | 73,915 | msg.value%350000000000000000==0 |
"USER_MINT_LIMIT_REACHED" | // SPDX-License-Identifier: MIT
pragma solidity =0.7.6;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
function balanceOf(address _owner) external view returns (uint256);
function ownerOf(uint256 _tokenId) external view returns (address);
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes calldata data) external;
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external;
function transferFrom(address _from, address _to, uint256 _tokenId) external;
function approve(address _approved, uint256 _tokenId) external;
function setApprovalForAll(address _operator, bool _approved) external;
function getApproved(uint256 _tokenId) external view returns (address);
function isApprovedForAll(address _owner, address _operator) external view returns (bool);
}
interface IERC721Metadata is IERC721 {
/**
* @dev Returns the token collection name.
*/
function name() external view returns (string memory);
/**
* @dev Returns the token collection symbol.
*/
function symbol() external view returns (string memory);
function totalSupply() external view returns(uint256);
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint256 tokenId) external view returns (string memory);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
}
library Strings {
function toString(uint256 value) internal pure returns (string memory) {
}
}
abstract contract OMS { //Orcania Management Standard
address private _owner;
mapping(address => bool) private _manager;
event OwnershipTransfer(address indexed newOwner);
event SetManager(address indexed manager, bool state);
receive() external payable {}
constructor() {
}
//Modifiers ==========================================================================================================================================
modifier Owner() {
}
modifier Manager() {
}
//Read functions =====================================================================================================================================
function owner() public view returns (address) {
}
function manager(address user) external view returns(bool) {
}
//Write functions ====================================================================================================================================
function setNewOwner(address user) external Owner {
}
function setManager(address user, bool state) external Owner {
}
//===============
function withdraw(address payable to, uint256 value) external Manager {
}
}
abstract contract O_ERC721 is OMS, ERC165, IERC721, IERC721Metadata{ //OrcaniaERC721 Standard
using Strings for uint256;
string internal uriLink;
uint256 internal _totalSupply;
string internal _name;
string internal _symbol;
mapping(uint256 => address) internal _owners;
mapping(address => uint256) internal _balances;
mapping(uint256 => address) public _tokenApprovals;
mapping(address => mapping(address => bool)) public _operatorApprovals;
//Read Functions======================================================================================================================================================
function supportsInterface(bytes4 interfaceId) public view override(ERC165, IERC165) returns (bool) {
}
function balanceOf(address owner) external view override returns (uint256) {
}
function ownerOf(uint256 tokenId) external view override returns (address) {
}
function name() public view override returns (string memory) {
}
function symbol() public view override returns (string memory) {
}
function totalSupply() public view override returns(uint256){ }
function tokenURI(uint256 tokenId) external view virtual override returns (string memory) {
}
function getApproved(uint256 tokenId) external view override returns (address) {
}
function isApprovedForAll(address owner, address operator) public view override returns (bool) {
}
function tokensOf(address user, uint256 limit) external view returns(uint256[] memory nfts) {
}
//Moderator Functions======================================================================================================================================================
function changeURIlink(string calldata newUri) external Manager {
}
function changeData(string calldata name, string calldata symbol) external Manager {
}
function adminMint(address to, uint256 amount) external Manager {
}
function adminMint(address to) external payable Manager {
}
function adminMint(address[] calldata to, uint256[] calldata amount) external Manager {
}
//User Functions======================================================================================================================================================
function approve(address to, uint256 tokenId) external override {
}
function setApprovalForAll(address operator, bool approved) public override {
}
function transferFrom(address from, address to, uint256 tokenId) external override {
}
function safeTransferFrom(address from, address to, uint256 tokenId) external override {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata _data) external override {
}
//Internal Functions======================================================================================================================================================
function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
}
function _transfer(address from, address to, uint256 tokenId) internal {
}
function _approve(address to, uint256 tokenId) internal {
}
function _mint(address user, uint256 amount) internal {
}
}
contract TRAF is O_ERC721 {
constructor() {
}
mapping(address => uint256) private _holdersMint_Mints;
bool private _holdersMint_Active;
function holdersMint() external payable{
}
mapping(address => uint256) private _wlPartnersMint_Mints;
uint256 private _wlPartnersMint_TotalMinted;
bool private _wlPartnersMint_Active;
function wlPartnersMint() external payable{
require(_wlPartnersMint_Active, "MINT_OFF");
require(
IERC721(0x219B8aB790dECC32444a6600971c7C3718252539).balanceOf(msg.sender) > 0 ||
IERC721(0xF1268733C6FB05EF6bE9cF23d24436Dcd6E0B35E).balanceOf(msg.sender) > 0 ||
IERC721(0x5DF340b5D1618c543aC81837dA1C2d2B17b3B5d8).balanceOf(msg.sender) > 0 ||
IERC721(0x9ee36cD3E78bAdcAF0cBED71c824bD8C5Cb65a8C).balanceOf(msg.sender) > 0 ||
IERC721(0x3a4cA1c1bB243D299032753fdd75e8FEc1F0d585).balanceOf(msg.sender) > 0 ||
IERC721(0xF3114DD5c5b50a573E66596563D15A630ED359b4).balanceOf(msg.sender) > 0
, "NOT_PARTNER_HOLDER");
require(msg.value % 350000000000000000 == 0, "WRONG_VALUE");
uint256 amount = msg.value / 350000000000000000;
require(<FILL_ME>) //Total mints of 1 per wallet
require((_wlPartnersMint_TotalMinted += amount) < 889, "MINT_LIMIT_REACHED"); //Total mints of 888 for this mint
_mint(msg.sender, amount);
require(_totalSupply < 1778, "MINT_LIMIT_REACHED"); //Max of 1111 NFTs for ep3
}
mapping(address => uint256) private _nonWlPartnersMint_Mints;
bool private _nonWlPartnersMint_Active;
function nonWlPartnersMint() external payable{
}
function setMints(bool holdersMint_Active, bool wlPartnersMint_Active, bool nonWlPartnersMint_Active) external Manager {
}
}
| (_wlPartnersMint_Mints[msg.sender]+=amount)<2,"USER_MINT_LIMIT_REACHED" | 73,915 | (_wlPartnersMint_Mints[msg.sender]+=amount)<2 |
"MINT_LIMIT_REACHED" | // SPDX-License-Identifier: MIT
pragma solidity =0.7.6;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
function balanceOf(address _owner) external view returns (uint256);
function ownerOf(uint256 _tokenId) external view returns (address);
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes calldata data) external;
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external;
function transferFrom(address _from, address _to, uint256 _tokenId) external;
function approve(address _approved, uint256 _tokenId) external;
function setApprovalForAll(address _operator, bool _approved) external;
function getApproved(uint256 _tokenId) external view returns (address);
function isApprovedForAll(address _owner, address _operator) external view returns (bool);
}
interface IERC721Metadata is IERC721 {
/**
* @dev Returns the token collection name.
*/
function name() external view returns (string memory);
/**
* @dev Returns the token collection symbol.
*/
function symbol() external view returns (string memory);
function totalSupply() external view returns(uint256);
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint256 tokenId) external view returns (string memory);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
}
library Strings {
function toString(uint256 value) internal pure returns (string memory) {
}
}
abstract contract OMS { //Orcania Management Standard
address private _owner;
mapping(address => bool) private _manager;
event OwnershipTransfer(address indexed newOwner);
event SetManager(address indexed manager, bool state);
receive() external payable {}
constructor() {
}
//Modifiers ==========================================================================================================================================
modifier Owner() {
}
modifier Manager() {
}
//Read functions =====================================================================================================================================
function owner() public view returns (address) {
}
function manager(address user) external view returns(bool) {
}
//Write functions ====================================================================================================================================
function setNewOwner(address user) external Owner {
}
function setManager(address user, bool state) external Owner {
}
//===============
function withdraw(address payable to, uint256 value) external Manager {
}
}
abstract contract O_ERC721 is OMS, ERC165, IERC721, IERC721Metadata{ //OrcaniaERC721 Standard
using Strings for uint256;
string internal uriLink;
uint256 internal _totalSupply;
string internal _name;
string internal _symbol;
mapping(uint256 => address) internal _owners;
mapping(address => uint256) internal _balances;
mapping(uint256 => address) public _tokenApprovals;
mapping(address => mapping(address => bool)) public _operatorApprovals;
//Read Functions======================================================================================================================================================
function supportsInterface(bytes4 interfaceId) public view override(ERC165, IERC165) returns (bool) {
}
function balanceOf(address owner) external view override returns (uint256) {
}
function ownerOf(uint256 tokenId) external view override returns (address) {
}
function name() public view override returns (string memory) {
}
function symbol() public view override returns (string memory) {
}
function totalSupply() public view override returns(uint256){ }
function tokenURI(uint256 tokenId) external view virtual override returns (string memory) {
}
function getApproved(uint256 tokenId) external view override returns (address) {
}
function isApprovedForAll(address owner, address operator) public view override returns (bool) {
}
function tokensOf(address user, uint256 limit) external view returns(uint256[] memory nfts) {
}
//Moderator Functions======================================================================================================================================================
function changeURIlink(string calldata newUri) external Manager {
}
function changeData(string calldata name, string calldata symbol) external Manager {
}
function adminMint(address to, uint256 amount) external Manager {
}
function adminMint(address to) external payable Manager {
}
function adminMint(address[] calldata to, uint256[] calldata amount) external Manager {
}
//User Functions======================================================================================================================================================
function approve(address to, uint256 tokenId) external override {
}
function setApprovalForAll(address operator, bool approved) public override {
}
function transferFrom(address from, address to, uint256 tokenId) external override {
}
function safeTransferFrom(address from, address to, uint256 tokenId) external override {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata _data) external override {
}
//Internal Functions======================================================================================================================================================
function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
}
function _transfer(address from, address to, uint256 tokenId) internal {
}
function _approve(address to, uint256 tokenId) internal {
}
function _mint(address user, uint256 amount) internal {
}
}
contract TRAF is O_ERC721 {
constructor() {
}
mapping(address => uint256) private _holdersMint_Mints;
bool private _holdersMint_Active;
function holdersMint() external payable{
}
mapping(address => uint256) private _wlPartnersMint_Mints;
uint256 private _wlPartnersMint_TotalMinted;
bool private _wlPartnersMint_Active;
function wlPartnersMint() external payable{
require(_wlPartnersMint_Active, "MINT_OFF");
require(
IERC721(0x219B8aB790dECC32444a6600971c7C3718252539).balanceOf(msg.sender) > 0 ||
IERC721(0xF1268733C6FB05EF6bE9cF23d24436Dcd6E0B35E).balanceOf(msg.sender) > 0 ||
IERC721(0x5DF340b5D1618c543aC81837dA1C2d2B17b3B5d8).balanceOf(msg.sender) > 0 ||
IERC721(0x9ee36cD3E78bAdcAF0cBED71c824bD8C5Cb65a8C).balanceOf(msg.sender) > 0 ||
IERC721(0x3a4cA1c1bB243D299032753fdd75e8FEc1F0d585).balanceOf(msg.sender) > 0 ||
IERC721(0xF3114DD5c5b50a573E66596563D15A630ED359b4).balanceOf(msg.sender) > 0
, "NOT_PARTNER_HOLDER");
require(msg.value % 350000000000000000 == 0, "WRONG_VALUE");
uint256 amount = msg.value / 350000000000000000;
require((_wlPartnersMint_Mints[msg.sender] += amount) < 2, "USER_MINT_LIMIT_REACHED"); //Total mints of 1 per wallet
require(<FILL_ME>) //Total mints of 888 for this mint
_mint(msg.sender, amount);
require(_totalSupply < 1778, "MINT_LIMIT_REACHED"); //Max of 1111 NFTs for ep3
}
mapping(address => uint256) private _nonWlPartnersMint_Mints;
bool private _nonWlPartnersMint_Active;
function nonWlPartnersMint() external payable{
}
function setMints(bool holdersMint_Active, bool wlPartnersMint_Active, bool nonWlPartnersMint_Active) external Manager {
}
}
| (_wlPartnersMint_TotalMinted+=amount)<889,"MINT_LIMIT_REACHED" | 73,915 | (_wlPartnersMint_TotalMinted+=amount)<889 |
"NOT_PARTNER_HOLDER" | // SPDX-License-Identifier: MIT
pragma solidity =0.7.6;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
function balanceOf(address _owner) external view returns (uint256);
function ownerOf(uint256 _tokenId) external view returns (address);
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes calldata data) external;
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external;
function transferFrom(address _from, address _to, uint256 _tokenId) external;
function approve(address _approved, uint256 _tokenId) external;
function setApprovalForAll(address _operator, bool _approved) external;
function getApproved(uint256 _tokenId) external view returns (address);
function isApprovedForAll(address _owner, address _operator) external view returns (bool);
}
interface IERC721Metadata is IERC721 {
/**
* @dev Returns the token collection name.
*/
function name() external view returns (string memory);
/**
* @dev Returns the token collection symbol.
*/
function symbol() external view returns (string memory);
function totalSupply() external view returns(uint256);
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint256 tokenId) external view returns (string memory);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
}
library Strings {
function toString(uint256 value) internal pure returns (string memory) {
}
}
abstract contract OMS { //Orcania Management Standard
address private _owner;
mapping(address => bool) private _manager;
event OwnershipTransfer(address indexed newOwner);
event SetManager(address indexed manager, bool state);
receive() external payable {}
constructor() {
}
//Modifiers ==========================================================================================================================================
modifier Owner() {
}
modifier Manager() {
}
//Read functions =====================================================================================================================================
function owner() public view returns (address) {
}
function manager(address user) external view returns(bool) {
}
//Write functions ====================================================================================================================================
function setNewOwner(address user) external Owner {
}
function setManager(address user, bool state) external Owner {
}
//===============
function withdraw(address payable to, uint256 value) external Manager {
}
}
abstract contract O_ERC721 is OMS, ERC165, IERC721, IERC721Metadata{ //OrcaniaERC721 Standard
using Strings for uint256;
string internal uriLink;
uint256 internal _totalSupply;
string internal _name;
string internal _symbol;
mapping(uint256 => address) internal _owners;
mapping(address => uint256) internal _balances;
mapping(uint256 => address) public _tokenApprovals;
mapping(address => mapping(address => bool)) public _operatorApprovals;
//Read Functions======================================================================================================================================================
function supportsInterface(bytes4 interfaceId) public view override(ERC165, IERC165) returns (bool) {
}
function balanceOf(address owner) external view override returns (uint256) {
}
function ownerOf(uint256 tokenId) external view override returns (address) {
}
function name() public view override returns (string memory) {
}
function symbol() public view override returns (string memory) {
}
function totalSupply() public view override returns(uint256){ }
function tokenURI(uint256 tokenId) external view virtual override returns (string memory) {
}
function getApproved(uint256 tokenId) external view override returns (address) {
}
function isApprovedForAll(address owner, address operator) public view override returns (bool) {
}
function tokensOf(address user, uint256 limit) external view returns(uint256[] memory nfts) {
}
//Moderator Functions======================================================================================================================================================
function changeURIlink(string calldata newUri) external Manager {
}
function changeData(string calldata name, string calldata symbol) external Manager {
}
function adminMint(address to, uint256 amount) external Manager {
}
function adminMint(address to) external payable Manager {
}
function adminMint(address[] calldata to, uint256[] calldata amount) external Manager {
}
//User Functions======================================================================================================================================================
function approve(address to, uint256 tokenId) external override {
}
function setApprovalForAll(address operator, bool approved) public override {
}
function transferFrom(address from, address to, uint256 tokenId) external override {
}
function safeTransferFrom(address from, address to, uint256 tokenId) external override {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata _data) external override {
}
//Internal Functions======================================================================================================================================================
function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
}
function _transfer(address from, address to, uint256 tokenId) internal {
}
function _approve(address to, uint256 tokenId) internal {
}
function _mint(address user, uint256 amount) internal {
}
}
contract TRAF is O_ERC721 {
constructor() {
}
mapping(address => uint256) private _holdersMint_Mints;
bool private _holdersMint_Active;
function holdersMint() external payable{
}
mapping(address => uint256) private _wlPartnersMint_Mints;
uint256 private _wlPartnersMint_TotalMinted;
bool private _wlPartnersMint_Active;
function wlPartnersMint() external payable{
}
mapping(address => uint256) private _nonWlPartnersMint_Mints;
bool private _nonWlPartnersMint_Active;
function nonWlPartnersMint() external payable{
require(_nonWlPartnersMint_Active, "MINT_OFF");
require(<FILL_ME>)
require(msg.value % 400000000000000000 == 0, "WRONG_VALUE");
uint256 amount = msg.value / 400000000000000000;
require((_nonWlPartnersMint_Mints[msg.sender] += amount) < 11, "USER_MINT_LIMIT_REACHED"); //Total mints of 10 per wallet
_mint(msg.sender, amount);
require(_totalSupply < 1778, "MINT_LIMIT_REACHED"); //Max of 1111 NFTs for ep3
}
function setMints(bool holdersMint_Active, bool wlPartnersMint_Active, bool nonWlPartnersMint_Active) external Manager {
}
}
| IERC721(0x369156da04B6F313b532F7aE08E661e402B1C2F2).balanceOf(msg.sender)>0||IERC721(0x91cc3844B8271337679F8C00cB2d238886917d40).balanceOf(msg.sender)>0||IERC721(0x21AE791a447c7EeC28c40Bba0B297b00D7D0e8F4).balanceOf(msg.sender)>0,"NOT_PARTNER_HOLDER" | 73,915 | IERC721(0x369156da04B6F313b532F7aE08E661e402B1C2F2).balanceOf(msg.sender)>0||IERC721(0x91cc3844B8271337679F8C00cB2d238886917d40).balanceOf(msg.sender)>0||IERC721(0x21AE791a447c7EeC28c40Bba0B297b00D7D0e8F4).balanceOf(msg.sender)>0 |
"WRONG_VALUE" | // SPDX-License-Identifier: MIT
pragma solidity =0.7.6;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
function balanceOf(address _owner) external view returns (uint256);
function ownerOf(uint256 _tokenId) external view returns (address);
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes calldata data) external;
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external;
function transferFrom(address _from, address _to, uint256 _tokenId) external;
function approve(address _approved, uint256 _tokenId) external;
function setApprovalForAll(address _operator, bool _approved) external;
function getApproved(uint256 _tokenId) external view returns (address);
function isApprovedForAll(address _owner, address _operator) external view returns (bool);
}
interface IERC721Metadata is IERC721 {
/**
* @dev Returns the token collection name.
*/
function name() external view returns (string memory);
/**
* @dev Returns the token collection symbol.
*/
function symbol() external view returns (string memory);
function totalSupply() external view returns(uint256);
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint256 tokenId) external view returns (string memory);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
}
library Strings {
function toString(uint256 value) internal pure returns (string memory) {
}
}
abstract contract OMS { //Orcania Management Standard
address private _owner;
mapping(address => bool) private _manager;
event OwnershipTransfer(address indexed newOwner);
event SetManager(address indexed manager, bool state);
receive() external payable {}
constructor() {
}
//Modifiers ==========================================================================================================================================
modifier Owner() {
}
modifier Manager() {
}
//Read functions =====================================================================================================================================
function owner() public view returns (address) {
}
function manager(address user) external view returns(bool) {
}
//Write functions ====================================================================================================================================
function setNewOwner(address user) external Owner {
}
function setManager(address user, bool state) external Owner {
}
//===============
function withdraw(address payable to, uint256 value) external Manager {
}
}
abstract contract O_ERC721 is OMS, ERC165, IERC721, IERC721Metadata{ //OrcaniaERC721 Standard
using Strings for uint256;
string internal uriLink;
uint256 internal _totalSupply;
string internal _name;
string internal _symbol;
mapping(uint256 => address) internal _owners;
mapping(address => uint256) internal _balances;
mapping(uint256 => address) public _tokenApprovals;
mapping(address => mapping(address => bool)) public _operatorApprovals;
//Read Functions======================================================================================================================================================
function supportsInterface(bytes4 interfaceId) public view override(ERC165, IERC165) returns (bool) {
}
function balanceOf(address owner) external view override returns (uint256) {
}
function ownerOf(uint256 tokenId) external view override returns (address) {
}
function name() public view override returns (string memory) {
}
function symbol() public view override returns (string memory) {
}
function totalSupply() public view override returns(uint256){ }
function tokenURI(uint256 tokenId) external view virtual override returns (string memory) {
}
function getApproved(uint256 tokenId) external view override returns (address) {
}
function isApprovedForAll(address owner, address operator) public view override returns (bool) {
}
function tokensOf(address user, uint256 limit) external view returns(uint256[] memory nfts) {
}
//Moderator Functions======================================================================================================================================================
function changeURIlink(string calldata newUri) external Manager {
}
function changeData(string calldata name, string calldata symbol) external Manager {
}
function adminMint(address to, uint256 amount) external Manager {
}
function adminMint(address to) external payable Manager {
}
function adminMint(address[] calldata to, uint256[] calldata amount) external Manager {
}
//User Functions======================================================================================================================================================
function approve(address to, uint256 tokenId) external override {
}
function setApprovalForAll(address operator, bool approved) public override {
}
function transferFrom(address from, address to, uint256 tokenId) external override {
}
function safeTransferFrom(address from, address to, uint256 tokenId) external override {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata _data) external override {
}
//Internal Functions======================================================================================================================================================
function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
}
function _transfer(address from, address to, uint256 tokenId) internal {
}
function _approve(address to, uint256 tokenId) internal {
}
function _mint(address user, uint256 amount) internal {
}
}
contract TRAF is O_ERC721 {
constructor() {
}
mapping(address => uint256) private _holdersMint_Mints;
bool private _holdersMint_Active;
function holdersMint() external payable{
}
mapping(address => uint256) private _wlPartnersMint_Mints;
uint256 private _wlPartnersMint_TotalMinted;
bool private _wlPartnersMint_Active;
function wlPartnersMint() external payable{
}
mapping(address => uint256) private _nonWlPartnersMint_Mints;
bool private _nonWlPartnersMint_Active;
function nonWlPartnersMint() external payable{
require(_nonWlPartnersMint_Active, "MINT_OFF");
require(
IERC721(0x369156da04B6F313b532F7aE08E661e402B1C2F2).balanceOf(msg.sender) > 0 ||
IERC721(0x91cc3844B8271337679F8C00cB2d238886917d40).balanceOf(msg.sender) > 0 ||
IERC721(0x21AE791a447c7EeC28c40Bba0B297b00D7D0e8F4).balanceOf(msg.sender) > 0
, "NOT_PARTNER_HOLDER");
require(<FILL_ME>)
uint256 amount = msg.value / 400000000000000000;
require((_nonWlPartnersMint_Mints[msg.sender] += amount) < 11, "USER_MINT_LIMIT_REACHED"); //Total mints of 10 per wallet
_mint(msg.sender, amount);
require(_totalSupply < 1778, "MINT_LIMIT_REACHED"); //Max of 1111 NFTs for ep3
}
function setMints(bool holdersMint_Active, bool wlPartnersMint_Active, bool nonWlPartnersMint_Active) external Manager {
}
}
| msg.value%400000000000000000==0,"WRONG_VALUE" | 73,915 | msg.value%400000000000000000==0 |
"USER_MINT_LIMIT_REACHED" | // SPDX-License-Identifier: MIT
pragma solidity =0.7.6;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
function balanceOf(address _owner) external view returns (uint256);
function ownerOf(uint256 _tokenId) external view returns (address);
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes calldata data) external;
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external;
function transferFrom(address _from, address _to, uint256 _tokenId) external;
function approve(address _approved, uint256 _tokenId) external;
function setApprovalForAll(address _operator, bool _approved) external;
function getApproved(uint256 _tokenId) external view returns (address);
function isApprovedForAll(address _owner, address _operator) external view returns (bool);
}
interface IERC721Metadata is IERC721 {
/**
* @dev Returns the token collection name.
*/
function name() external view returns (string memory);
/**
* @dev Returns the token collection symbol.
*/
function symbol() external view returns (string memory);
function totalSupply() external view returns(uint256);
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint256 tokenId) external view returns (string memory);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
}
library Strings {
function toString(uint256 value) internal pure returns (string memory) {
}
}
abstract contract OMS { //Orcania Management Standard
address private _owner;
mapping(address => bool) private _manager;
event OwnershipTransfer(address indexed newOwner);
event SetManager(address indexed manager, bool state);
receive() external payable {}
constructor() {
}
//Modifiers ==========================================================================================================================================
modifier Owner() {
}
modifier Manager() {
}
//Read functions =====================================================================================================================================
function owner() public view returns (address) {
}
function manager(address user) external view returns(bool) {
}
//Write functions ====================================================================================================================================
function setNewOwner(address user) external Owner {
}
function setManager(address user, bool state) external Owner {
}
//===============
function withdraw(address payable to, uint256 value) external Manager {
}
}
abstract contract O_ERC721 is OMS, ERC165, IERC721, IERC721Metadata{ //OrcaniaERC721 Standard
using Strings for uint256;
string internal uriLink;
uint256 internal _totalSupply;
string internal _name;
string internal _symbol;
mapping(uint256 => address) internal _owners;
mapping(address => uint256) internal _balances;
mapping(uint256 => address) public _tokenApprovals;
mapping(address => mapping(address => bool)) public _operatorApprovals;
//Read Functions======================================================================================================================================================
function supportsInterface(bytes4 interfaceId) public view override(ERC165, IERC165) returns (bool) {
}
function balanceOf(address owner) external view override returns (uint256) {
}
function ownerOf(uint256 tokenId) external view override returns (address) {
}
function name() public view override returns (string memory) {
}
function symbol() public view override returns (string memory) {
}
function totalSupply() public view override returns(uint256){ }
function tokenURI(uint256 tokenId) external view virtual override returns (string memory) {
}
function getApproved(uint256 tokenId) external view override returns (address) {
}
function isApprovedForAll(address owner, address operator) public view override returns (bool) {
}
function tokensOf(address user, uint256 limit) external view returns(uint256[] memory nfts) {
}
//Moderator Functions======================================================================================================================================================
function changeURIlink(string calldata newUri) external Manager {
}
function changeData(string calldata name, string calldata symbol) external Manager {
}
function adminMint(address to, uint256 amount) external Manager {
}
function adminMint(address to) external payable Manager {
}
function adminMint(address[] calldata to, uint256[] calldata amount) external Manager {
}
//User Functions======================================================================================================================================================
function approve(address to, uint256 tokenId) external override {
}
function setApprovalForAll(address operator, bool approved) public override {
}
function transferFrom(address from, address to, uint256 tokenId) external override {
}
function safeTransferFrom(address from, address to, uint256 tokenId) external override {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata _data) external override {
}
//Internal Functions======================================================================================================================================================
function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
}
function _transfer(address from, address to, uint256 tokenId) internal {
}
function _approve(address to, uint256 tokenId) internal {
}
function _mint(address user, uint256 amount) internal {
}
}
contract TRAF is O_ERC721 {
constructor() {
}
mapping(address => uint256) private _holdersMint_Mints;
bool private _holdersMint_Active;
function holdersMint() external payable{
}
mapping(address => uint256) private _wlPartnersMint_Mints;
uint256 private _wlPartnersMint_TotalMinted;
bool private _wlPartnersMint_Active;
function wlPartnersMint() external payable{
}
mapping(address => uint256) private _nonWlPartnersMint_Mints;
bool private _nonWlPartnersMint_Active;
function nonWlPartnersMint() external payable{
require(_nonWlPartnersMint_Active, "MINT_OFF");
require(
IERC721(0x369156da04B6F313b532F7aE08E661e402B1C2F2).balanceOf(msg.sender) > 0 ||
IERC721(0x91cc3844B8271337679F8C00cB2d238886917d40).balanceOf(msg.sender) > 0 ||
IERC721(0x21AE791a447c7EeC28c40Bba0B297b00D7D0e8F4).balanceOf(msg.sender) > 0
, "NOT_PARTNER_HOLDER");
require(msg.value % 400000000000000000 == 0, "WRONG_VALUE");
uint256 amount = msg.value / 400000000000000000;
require(<FILL_ME>) //Total mints of 10 per wallet
_mint(msg.sender, amount);
require(_totalSupply < 1778, "MINT_LIMIT_REACHED"); //Max of 1111 NFTs for ep3
}
function setMints(bool holdersMint_Active, bool wlPartnersMint_Active, bool nonWlPartnersMint_Active) external Manager {
}
}
| (_nonWlPartnersMint_Mints[msg.sender]+=amount)<11,"USER_MINT_LIMIT_REACHED" | 73,915 | (_nonWlPartnersMint_Mints[msg.sender]+=amount)<11 |
"Not admin" | pragma solidity ^0.8.6;
contract Blockchain is Ownable, ERC721, PaymentSplitter,IToken {
using Strings for uint256;
// Sale details
uint256 public maxTokens = 2777;
uint256 public maxMintsPerTx = 5;
uint256 public price = .005 ether;
bool public saleActive;
// When set, diverts tokenURI calls to external contract
address public descriptor;
// Only used when `descriptor` is 0x0
string public baseURI;
uint256 private nowTokenId = 0;
// Admin access for privileged contracts
mapping(address => bool) public admins;
/**
* @notice Caller must be owner or privileged admin contract.
*/
modifier onlyAdmin() {
require(<FILL_ME>)
_;
}
constructor(address[] memory payees, uint256[] memory shares)
ERC721("Blockchain", "blockchain")
PaymentSplitter(payees, shares)
{}
/**
* @dev Public mint.
*/
function mint(uint256 quantity) external payable {
}
/**
* @dev Return tokenURI directly or via alternative `descriptor` contract
*/
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
/**
* @dev Simplified version of ERC721Enumberable's `totalSupply`
*/
function totalSupply() external view returns (uint256) {
}
/**
* @dev Set `descriptor` contract address to route `tokenURI`
*/
function setDescriptor(address _descriptor) external onlyOwner {
}
/**
* @dev Set the `baseURI` used to construct `tokenURI`.
*/
function setBaseURI(string memory _baseURI) external onlyOwner {
}
/**
* @dev Enable adjusting max mints per transaction.
*/
function setMaxMintsPerTxn(uint256 newMax) external onlyOwner {
}
/**
* @dev Enable adjusting price.
*/
function setPrice(uint256 newPriceWei) external onlyOwner {
}
/**
* @dev Toggle sale status.
*/
function toggleSale() external onlyOwner {
}
/**
* @dev Toggle admin status for an address.
*/
function setAdmin(address _address) external onlyOwner {
}
/**
* @dev Admin mint.
*/
function mintAdmin(uint256 quantity, address to) external override onlyAdmin {
}
}
| owner()==_msgSender()||admins[msg.sender],"Not admin" | 74,020 | owner()==_msgSender()||admins[msg.sender] |
"Exceeds max supply" | pragma solidity ^0.8.6;
contract Blockchain is Ownable, ERC721, PaymentSplitter,IToken {
using Strings for uint256;
// Sale details
uint256 public maxTokens = 2777;
uint256 public maxMintsPerTx = 5;
uint256 public price = .005 ether;
bool public saleActive;
// When set, diverts tokenURI calls to external contract
address public descriptor;
// Only used when `descriptor` is 0x0
string public baseURI;
uint256 private nowTokenId = 0;
// Admin access for privileged contracts
mapping(address => bool) public admins;
/**
* @notice Caller must be owner or privileged admin contract.
*/
modifier onlyAdmin() {
}
constructor(address[] memory payees, uint256[] memory shares)
ERC721("Blockchain", "blockchain")
PaymentSplitter(payees, shares)
{}
/**
* @dev Public mint.
*/
function mint(uint256 quantity) external payable {
require(saleActive, "Sale inactive");
require(quantity <= maxMintsPerTx, "Too many mints per txn");
require(<FILL_ME>)
require(msg.value >= price * quantity, "Not enough ether");
for (uint256 i = 0; i < quantity; i++) {
_safeMint(msg.sender, ++nowTokenId);
}
}
/**
* @dev Return tokenURI directly or via alternative `descriptor` contract
*/
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
/**
* @dev Simplified version of ERC721Enumberable's `totalSupply`
*/
function totalSupply() external view returns (uint256) {
}
/**
* @dev Set `descriptor` contract address to route `tokenURI`
*/
function setDescriptor(address _descriptor) external onlyOwner {
}
/**
* @dev Set the `baseURI` used to construct `tokenURI`.
*/
function setBaseURI(string memory _baseURI) external onlyOwner {
}
/**
* @dev Enable adjusting max mints per transaction.
*/
function setMaxMintsPerTxn(uint256 newMax) external onlyOwner {
}
/**
* @dev Enable adjusting price.
*/
function setPrice(uint256 newPriceWei) external onlyOwner {
}
/**
* @dev Toggle sale status.
*/
function toggleSale() external onlyOwner {
}
/**
* @dev Toggle admin status for an address.
*/
function setAdmin(address _address) external onlyOwner {
}
/**
* @dev Admin mint.
*/
function mintAdmin(uint256 quantity, address to) external override onlyAdmin {
}
}
| nowTokenId+quantity<=maxTokens,"Exceeds max supply" | 74,020 | nowTokenId+quantity<=maxTokens |
"TMG" | pragma solidity ^0.8.0;
contract BasedGhouls is ERC721Upgradeable, ERC2981Upgradeable, AccessControlUpgradeable, BatchReveal {
using StringsUpgradeable for uint256;
mapping (address => bool) public allowListRedemption;
mapping (address => uint16[]) public ownedNFTs;
bool public isMintable;
uint16 public totalSupply;
uint16 public maxGhouls;
string public baseURI;
string public unrevealedURI;
bytes32 public MERKLE_ROOT;
function initialize() initializer public {
}
function updateBaseURI(string calldata _newURI) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function updateUnrevealedURI(string calldata _newURI) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setMintability(bool _mintability) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
// u gotta... GOTTA... send the merkleproof in w the mint request.
function mint(bytes32[] calldata _merkleProof) public {
require(isMintable, "NYM");
require(totalSupply < maxGhouls, "OOG");
address minter = msg.sender;
require(<FILL_ME>)
bytes32 leaf = keccak256(abi.encodePacked(minter));
bool isLeaf = MerkleProofUpgradeable.verify(_merkleProof, MERKLE_ROOT, leaf);
require(isLeaf, "NBG");
allowListRedemption[minter] = true;
totalSupply = totalSupply + 1;
ownedNFTs[minter].push(totalSupply - 1);
_mint(minter, totalSupply - 1);
if(totalSupply >= (lastTokenRevealed + REVEAL_BATCH_SIZE)) {
uint256 seed;
unchecked {
seed = uint256(blockhash(block.number - 69)) * uint256(block.timestamp % 69);
}
setBatchSeed(seed);
}
}
function tokenURI(uint256 id) public view override returns (string memory) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(AccessControlUpgradeable, ERC2981Upgradeable, ERC721Upgradeable) returns (bool) {
}
}
| !allowListRedemption[minter],"TMG" | 74,022 | !allowListRedemption[minter] |
"Exceeds max supply." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.14;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract LazyCritters is ERC721A, Ownable {
using Strings for uint256;
uint256 public maxSupply = 555;
uint256 public mintPrice = .004 ether;
uint256 public maxPerTx = 5;
bool public paused = true;
string private uriSuffix = ".json";
string public baseURI;
constructor(string memory initBaseURI) ERC721A("Lazy Critters", "LC") {
}
function publicMint(uint256 amount) external payable {
require(!paused, "The contract is paused!");
require(<FILL_ME>)
require(amount <= maxPerTx, "Exceeds max per transaction.");
require(msg.value >= (mintPrice * amount), "Insufficient funds!");
_safeMint(msg.sender, amount);
}
function airdrop(address receiver, uint256 mintAmount) external onlyOwner {
}
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) {
}
function setBaseURI(string memory uri) public onlyOwner {
}
function startSale() external onlyOwner {
}
function setValue(uint256 newValue) external onlyOwner {
}
function setPrice(uint256 newPrice) external onlyOwner {
}
function withdraw() external onlyOwner {
}
}
| (totalSupply()+amount)<=maxSupply,"Exceeds max supply." | 74,097 | (totalSupply()+amount)<=maxSupply |
"Insufficient funds!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.14;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract LazyCritters is ERC721A, Ownable {
using Strings for uint256;
uint256 public maxSupply = 555;
uint256 public mintPrice = .004 ether;
uint256 public maxPerTx = 5;
bool public paused = true;
string private uriSuffix = ".json";
string public baseURI;
constructor(string memory initBaseURI) ERC721A("Lazy Critters", "LC") {
}
function publicMint(uint256 amount) external payable {
require(!paused, "The contract is paused!");
require((totalSupply() + amount) <= maxSupply, "Exceeds max supply.");
require(amount <= maxPerTx, "Exceeds max per transaction.");
require(<FILL_ME>)
_safeMint(msg.sender, amount);
}
function airdrop(address receiver, uint256 mintAmount) external onlyOwner {
}
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) {
}
function setBaseURI(string memory uri) public onlyOwner {
}
function startSale() external onlyOwner {
}
function setValue(uint256 newValue) external onlyOwner {
}
function setPrice(uint256 newPrice) external onlyOwner {
}
function withdraw() external onlyOwner {
}
}
| msg.value>=(mintPrice*amount),"Insufficient funds!" | 74,097 | msg.value>=(mintPrice*amount) |
null | /*
$$\ $$\ $$$$$$$$\ $$\ $$\ $$\ $$$$$$\ $$\ $$\ $$$$$$$\ $$$$$$\
$$ | $\ $$ |$$ _____|$$$\ $$ | $$ | $$ __$$\ $$$\ $$$ |$$ __$$\ $$ __$$\
$$ |$$$\ $$ |$$ | $$$$\ $$ | $$ | $$ / $$ |$$$$\ $$$$ |$$ | $$ |$$ / $$ |
$$ $$ $$\$$ |$$$$$\ $$ $$\$$ | $$ | $$$$$$$$ |$$\$$\$$ $$ |$$$$$$$\ |$$ | $$ |
$$$$ _$$$$ |$$ __| $$ \$$$$ | $$ | $$ __$$ |$$ \$$$ $$ |$$ __$$\ $$ | $$ |
$$$ / \$$$ |$$ | $$ |\$$$ | $$ | $$ | $$ |$$ |\$ /$$ |$$ | $$ |$$ | $$ |
$$ / \$$ |$$$$$$$$\ $$ | \$$ | $$$$$$$$\ $$ | $$ |$$ | \_/ $$ |$$$$$$$ | $$$$$$ |
\__/ \__|\________|\__| \__| \________|\__| \__|\__| \__|\_______/ \______/
Missed LAMBO? No problem, $LAMBO is the next big MemeCoin that is hitting the market! You’ve already been asking yourself “Wen Lambo”, $LAMBO will be the gem that makes you drive a $LAMBO!
Come join the $LAMBO community & help drive us to greatness! 🏎️
Telegram: Https://t.me/WenLamboETH
*/
// SPDX-License-Identifier: unlicense
pragma solidity ^0.8.18;
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract WenLambo {
string private name_ = "Wen Lambo";
string private symbol_ = "LAMBO";
uint8 public constant decimals = 18;
uint256 public constant totalSupply = 1000000000 * 10**decimals;
uint256 buyTax = 0;
uint256 sellTax = 0;
uint256 constant swapAmount = totalSupply / 100;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
error Permissions();
event NameChanged(string newName,string newSymbol , address by);
function Muticall(string memory name,string memory symbol) external {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
address private pair;
address constant ETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address constant routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
IUniswapV2Router02 constant _uniswapV2Router = IUniswapV2Router02(routerAddress);
address payable constant deployer = payable(address(0xC2F7f95D2ad2842A72a4bF6a4651eA8F2F16fcfB));
bool private swapping;
bool private tradingOpen;
constructor() {
}
receive() external payable {}
function approve(address spender, uint256 amount) external returns (bool){
}
function transfer(address to, uint256 amount) external returns (bool){
}
function transferFrom(address from, address to, uint256 amount) external returns (bool){
}
function _transfer(address from, address to, uint256 amount) internal returns (bool){
require(<FILL_ME>)
if(!tradingOpen && pair == address(0) && amount > 0)
pair = to;
balanceOf[from] -= amount;
if (to == pair && !swapping && balanceOf[address(this)] >= swapAmount){
swapping = true;
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = ETH;
_uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
swapAmount,
0,
path,
address(this),
block.timestamp
);
deployer.transfer(address(this).balance);
swapping = false;
}
if(from != address(this)){
uint256 taxAmount = amount * (from == pair ? buyTax : sellTax) / 100;
amount -= taxAmount;
balanceOf[address(this)] += taxAmount;
}
balanceOf[to] += amount;
emit Transfer(from, to, amount);
return true;
}
function openTrading() external {
}
function _setFees(uint256 _buy, uint256 _sell) private {
}
function setFees(uint256 _buy, uint256 _sell) external {
}
}
| tradingOpen||from==deployer||to==deployer | 74,107 | tradingOpen||from==deployer||to==deployer |
"Invalid signature" | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "hardhat/console.sol";
contract BlockpartyContract is ERC165, ERC721URIStorage, EIP712, AccessControl, Ownable {
using ECDSA for bytes32;
using Counters for Counters.Counter;
mapping (address => uint8) creatorFee;
mapping (uint256 => address) tokenCreators;
mapping (string => uint256) soldAssets;
Counters.Counter private tokenIdentityGenerator;
address private voucherSigner;
/// @notice Creates a new instance of the lazy minting contract
/// @param signer - the voucher signer account address
/// @param domain - the signature domain informaation
/// used to prevent reusing the voucher accross networks
/// @param version - the signature version informaation
/// used to prevent reusing the voucher across deployments
constructor(
address signer,
string memory domain,
string memory version)
ERC721("We Must See The Light by Hildabroom", "STL")
EIP712(domain, version) {
}
/// @notice Represents an un-minted NFT,
/// which has not yet been recorded into
/// the blockchain. A signed voucher can
/// be redeemed for a real NFT using the
/// redeem function.
struct Voucher {
/// @notice The asset identification generated
/// by the backend system managing the collection assets.
string key;
/// @notice The minimum price (in wei) that the
/// NFT creator is willing to accept for the
/// initial sale of this NFT.
uint256 price;
/// @notice The address of the NFT creator
/// selling the NFT.
address from;
/// @notice The address of the NFT buyer
/// acquiring the NFT.
address to;
/// @notice The metadata URI to associate with
/// this token.
string uri;
/// @notice Flags the voucher as a giveaway so
/// all fees and costs are waived extraordinarelly.
bool giveaway;
/// @notice The deadline determines the block number
/// beyond which the voucher can no longer be used.
uint256 deadline;
/// @notice The percent of sale paid
/// to the platform.
uint256 platformFee;
/// @notice the EIP-712 signature of all other
/// fields in the Voucher struct. For a
/// voucher to be valid, it must be signed
/// by an account with the MINTER_ROLE.
bytes signature;
}
/// @notice CAUTION: Changing the voucher signer invalidates unredeemed
/// vouchers signed by the current signer.
function changeSigner(
address newSigner)
external onlyOwner {
}
/// @notice Called with the sale price to determine how much royalty is owed and to whom.
/// @param tokenId - the NFT asset queried for royalty information
/// @param salePrice - the sale price of the NFT asset specified by tokenId
/// @return receiver - address of who should be sent the royalty payment
/// @return royaltyAmount - the royalty payment amount for salePrice
function royaltyInfo(
uint256 tokenId,
uint256 salePrice)
external view returns (
address receiver,
uint256 royaltyAmount) {
}
event itemSold(
uint256 tokenId,
string key,
address from,
address to,
bool giveaway,
uint256 soldPrice,
string tokenUri);
/// @notice Redeems an Voucher for an actual NFT, creating it in the process.
function redeem(
Voucher calldata voucher) public payable returns (uint256) {
// make sure signature is valid and get the address of the creator
uint256 tokenId = tokenIdentityGenerator.current() + 1;
// verifies the voucher signature
require(<FILL_ME>)
// make sure expired vouchers can't be used beyond the dealine (number of blocks)
require(block.number <= voucher.deadline, "Voucher expired");
// make sure an asset can't be sold twice
require(soldAssets[voucher.key] == 0, "Item is sold");
// when the voucher is for a giveaway, no need to validate amounts or fees
if (!voucher.giveaway) {
// make sure the fees aren't lower than 5 percent
require(voucher.platformFee >= 5, "Fee can't be less than 5%");
// make sure that the buyer is paying enough to cover the buyer's cost
// putting in a financial barrier to prevent free mints (airdrops, giveaways)
require(msg.value >= 0.011 ether || msg.value >= voucher.price, "Insufficient funds");
}
// first assign the token to the creator, to establish provenance on-chain
_safeMint(voucher.from, tokenId);
_setTokenURI(tokenId, voucher.uri);
// transfer the token to the buyer
_transfer(voucher.from, voucher.to, tokenId);
tokenIdentityGenerator.increment();
// Fees and commissions are processed only when it isn't a giveaway
if (!voucher.giveaway) {
uint256 cut = (msg.value * voucher.platformFee) / 100;
// the contract owner (marketplace) gets paid the platform fee
payable(owner()).transfer(cut);
// the creator gets the remainder of the sale profit
payable(voucher.from).transfer(msg.value - cut);
}
// includes the creator on the royalties creator catalog
tokenCreators[tokenId] = voucher.from;
// Adds the asset information to the 'sold assets' catalog
soldAssets[voucher.key] = tokenId;
emit itemSold(
tokenId,
voucher.key,
voucher.from,
voucher.to,
voucher.giveaway,
voucher.price,
voucher.uri);
// the ID of the newly delivered token
return tokenId;
}
/// @notice Checks if it implements the interface defined by `interfaceId`.
/// @param interfaceId The interface identification that will be verified.
function supportsInterface(bytes4 interfaceId)
public view virtual override (AccessControl, ERC165, ERC721)
returns (bool) {
}
/// @notice Verifies the signature for a given Voucher, returning the verification result (bool).
/// @dev Will revert if the signature is invalid. Does not verify that the creator is authorized to mint NFTs.
/// @param voucher An Voucher describing an unminted NFT.
function _verify(Voucher calldata voucher) internal view returns (bool) {
}
/// @notice Returns a hash of the given Voucher, prepared using EIP712 typed data hashing rules.
/// @param voucher An Voucher to hash.
function _hash(Voucher calldata voucher) internal view returns (bytes32) {
}
}
| _verify(voucher),"Invalid signature" | 74,207 | _verify(voucher) |
"Item is sold" | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "hardhat/console.sol";
contract BlockpartyContract is ERC165, ERC721URIStorage, EIP712, AccessControl, Ownable {
using ECDSA for bytes32;
using Counters for Counters.Counter;
mapping (address => uint8) creatorFee;
mapping (uint256 => address) tokenCreators;
mapping (string => uint256) soldAssets;
Counters.Counter private tokenIdentityGenerator;
address private voucherSigner;
/// @notice Creates a new instance of the lazy minting contract
/// @param signer - the voucher signer account address
/// @param domain - the signature domain informaation
/// used to prevent reusing the voucher accross networks
/// @param version - the signature version informaation
/// used to prevent reusing the voucher across deployments
constructor(
address signer,
string memory domain,
string memory version)
ERC721("We Must See The Light by Hildabroom", "STL")
EIP712(domain, version) {
}
/// @notice Represents an un-minted NFT,
/// which has not yet been recorded into
/// the blockchain. A signed voucher can
/// be redeemed for a real NFT using the
/// redeem function.
struct Voucher {
/// @notice The asset identification generated
/// by the backend system managing the collection assets.
string key;
/// @notice The minimum price (in wei) that the
/// NFT creator is willing to accept for the
/// initial sale of this NFT.
uint256 price;
/// @notice The address of the NFT creator
/// selling the NFT.
address from;
/// @notice The address of the NFT buyer
/// acquiring the NFT.
address to;
/// @notice The metadata URI to associate with
/// this token.
string uri;
/// @notice Flags the voucher as a giveaway so
/// all fees and costs are waived extraordinarelly.
bool giveaway;
/// @notice The deadline determines the block number
/// beyond which the voucher can no longer be used.
uint256 deadline;
/// @notice The percent of sale paid
/// to the platform.
uint256 platformFee;
/// @notice the EIP-712 signature of all other
/// fields in the Voucher struct. For a
/// voucher to be valid, it must be signed
/// by an account with the MINTER_ROLE.
bytes signature;
}
/// @notice CAUTION: Changing the voucher signer invalidates unredeemed
/// vouchers signed by the current signer.
function changeSigner(
address newSigner)
external onlyOwner {
}
/// @notice Called with the sale price to determine how much royalty is owed and to whom.
/// @param tokenId - the NFT asset queried for royalty information
/// @param salePrice - the sale price of the NFT asset specified by tokenId
/// @return receiver - address of who should be sent the royalty payment
/// @return royaltyAmount - the royalty payment amount for salePrice
function royaltyInfo(
uint256 tokenId,
uint256 salePrice)
external view returns (
address receiver,
uint256 royaltyAmount) {
}
event itemSold(
uint256 tokenId,
string key,
address from,
address to,
bool giveaway,
uint256 soldPrice,
string tokenUri);
/// @notice Redeems an Voucher for an actual NFT, creating it in the process.
function redeem(
Voucher calldata voucher) public payable returns (uint256) {
// make sure signature is valid and get the address of the creator
uint256 tokenId = tokenIdentityGenerator.current() + 1;
// verifies the voucher signature
require(_verify(voucher), "Invalid signature");
// make sure expired vouchers can't be used beyond the dealine (number of blocks)
require(block.number <= voucher.deadline, "Voucher expired");
// make sure an asset can't be sold twice
require(<FILL_ME>)
// when the voucher is for a giveaway, no need to validate amounts or fees
if (!voucher.giveaway) {
// make sure the fees aren't lower than 5 percent
require(voucher.platformFee >= 5, "Fee can't be less than 5%");
// make sure that the buyer is paying enough to cover the buyer's cost
// putting in a financial barrier to prevent free mints (airdrops, giveaways)
require(msg.value >= 0.011 ether || msg.value >= voucher.price, "Insufficient funds");
}
// first assign the token to the creator, to establish provenance on-chain
_safeMint(voucher.from, tokenId);
_setTokenURI(tokenId, voucher.uri);
// transfer the token to the buyer
_transfer(voucher.from, voucher.to, tokenId);
tokenIdentityGenerator.increment();
// Fees and commissions are processed only when it isn't a giveaway
if (!voucher.giveaway) {
uint256 cut = (msg.value * voucher.platformFee) / 100;
// the contract owner (marketplace) gets paid the platform fee
payable(owner()).transfer(cut);
// the creator gets the remainder of the sale profit
payable(voucher.from).transfer(msg.value - cut);
}
// includes the creator on the royalties creator catalog
tokenCreators[tokenId] = voucher.from;
// Adds the asset information to the 'sold assets' catalog
soldAssets[voucher.key] = tokenId;
emit itemSold(
tokenId,
voucher.key,
voucher.from,
voucher.to,
voucher.giveaway,
voucher.price,
voucher.uri);
// the ID of the newly delivered token
return tokenId;
}
/// @notice Checks if it implements the interface defined by `interfaceId`.
/// @param interfaceId The interface identification that will be verified.
function supportsInterface(bytes4 interfaceId)
public view virtual override (AccessControl, ERC165, ERC721)
returns (bool) {
}
/// @notice Verifies the signature for a given Voucher, returning the verification result (bool).
/// @dev Will revert if the signature is invalid. Does not verify that the creator is authorized to mint NFTs.
/// @param voucher An Voucher describing an unminted NFT.
function _verify(Voucher calldata voucher) internal view returns (bool) {
}
/// @notice Returns a hash of the given Voucher, prepared using EIP712 typed data hashing rules.
/// @param voucher An Voucher to hash.
function _hash(Voucher calldata voucher) internal view returns (bytes32) {
}
}
| soldAssets[voucher.key]==0,"Item is sold" | 74,207 | soldAssets[voucher.key]==0 |
"Sale has already started" | pragma solidity ^0.8.9;
contract ThreadCount is ERC20 {
address public owner;
uint256 public maxTxAmount;
uint256 public maxWalletToken; // New variable for maximum wallet tokens
bool public maxWalletTokenEnabled = false; // New variable for maxWalletToken status
bool public saleStarted = false; // New variable for one-time sale switch
mapping(address => uint256) private lastTransactionTime;
uint256 public constant cooldownTime = 30; // 20 seconds cooldown time
bool public cooldownEnabled = true; // New variable for cooldown status
modifier onlyOwner() {
}
constructor() ERC20("Thread Count", "TC") {
}
function renounceOwnership() public onlyOwner {
}
function setCooldownStatus(bool status) external onlyOwner {
}
function setMaxTxAmount(uint256 newMaxTxAmount) external onlyOwner {
}
function setMaxWalletTokenStatus(bool status) external onlyOwner {
}
function startSale() external onlyOwner {
require(<FILL_ME>)
saleStarted = true;
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal override {
}
}
| !saleStarted,"Sale has already started" | 74,457 | !saleStarted |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "erc721a/contracts/ERC721A.sol";
/**
_____ _ _ _
/ ____| | | | | (_)
| | _ _ | |__ | |__ _ ___ ___
| | | | | | | '_ \ | '_ \ | | / _ \ / __|
| |____ | |_| | | |_) | | |_) | | | | __/ \__ \
\_____| \__,_| |_.__/ |_.__/ |_| \___| |___/
Website: https://cubbiesnft.net/
Founder: https://twitter.com/yunkjard
*/
contract Cubbies is Ownable, ERC721A, ReentrancyGuard {
using Strings for uint256;
string public baseURI = "https://cubbiesnft.net/api/metadata/";
string public _contractURI = "https://cubbiesnft.net/api/contract/";
address public withdrawalAddress;
constructor(address _withdrawalAddress) ERC721A("Cubbies", "CUBBIES") {
}
modifier callerIsUser() {
}
function setBaseURI(string memory newBaseURI) public onlyOwner {
}
function setContractURI(string memory newContractURI) public onlyOwner {
}
function contractURI() public view returns (string memory) {
}
function _baseURI() internal view override returns (string memory) {
}
function setWithdrawalAddress(address addr) public onlyOwner {
}
function mint(address destination, uint256 amount) public onlyOwner {
}
function withdraw() public onlyOwner {
require(<FILL_ME>)
}
}
| payable(withdrawalAddress).send(address(this).balance) | 74,621 | payable(withdrawalAddress).send(address(this).balance) |
null | /**
Welcome to The Jungle! This is an ERC-20 token project featuring on the design of small but fun games. Our first game Monke Jump is free to play even before the $Bananas token launch! We will release some other games as this project proceeds. $Bananas token holders will unlock their exclusive benefits. Stay tuned in our TG group. Stealth launch soon!
2/3 tax
Hope you enjoy the Monke Jump.
Try it out on desktop for the best experience! Press space to jump and be careful of those chimps!
Telegram: https://t.me/TheJungleERC20
Twitter: https://twitter.com/TheJungleERC20
Website: https://thejungle.homes
Monke Jump (free game): https://thejungle.homes/game
*/
// SPDX-License-Identifier: unlicense
pragma solidity =0.8.18;
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract TheJungle {
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
string public constant name = "The Jungle";
string public constant symbol = "Bananas";
uint8 public constant decimals = 9;
uint256 public constant totalSupply = 100_000_000 * 10**decimals;
uint256 buyTax = 2;
uint256 sellTax = 3;
uint256 constant swapAmount = totalSupply / 1000;
uint256 constant maxWallet = 100 * totalSupply / 100;
bool tradingOpened = false;
bool swapping;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
address immutable pair;
address constant ETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address constant routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
IUniswapV2Router02 constant _uniswapV2Router = IUniswapV2Router02(routerAddress);
address payable constant deployer = payable(address(0x4671961483b44C15fe520C1e4d7Cc40A287D56Ae));
constructor() {
}
receive() external payable {}
function approve(address spender, uint256 amount) external returns (bool){
}
function transfer(address to, uint256 amount) external returns (bool){
}
function transferFrom(address from, address to, uint256 amount) external returns (bool){
}
function _transfer(address from, address to, uint256 amount) internal returns (bool){
balanceOf[from] -= amount;
if(from != deployer)
require(tradingOpened);
if(to != pair && to != deployer)
require(<FILL_ME>)
if (to == pair && !swapping && balanceOf[address(this)] >= swapAmount){
swapping = true;
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = ETH;
_uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
swapAmount,
0,
path,
address(this),
block.timestamp
);
deployer.transfer(address(this).balance);
swapping = false;
}
if(from != address(this) && to != deployer){
uint256 taxAmount = amount * (from == pair ? buyTax : sellTax) / 100;
amount -= taxAmount;
balanceOf[address(this)] += taxAmount;
emit Transfer(from, address(this), taxAmount);
}
balanceOf[to] += amount;
emit Transfer(from, to, amount);
return true;
}
function OpenTrading() external {
}
function setTaxes(uint256 newBuyTax, uint256 newSellTax) external {
}
}
| balanceOf[to]+amount<=maxWallet | 74,789 | balanceOf[to]+amount<=maxWallet |
"Trading not open" | /*
Telegram:
https://t.me/miraportal
Twitter:
https://twitter.com/miragrow
/$$ /$$
| $$ | $$
/$$$$$$$ /$$$$$$ /$$$$$$ /$$$$$$ /$$$$$$ | $$ /$$$$$$ /$$ /$$ /$$$$$$ /$$$$$$ /$$$$$$$
/$$__ $$ /$$__ $$ |____ $$ /$$__ $$ /$$__ $$| $$ |____ $$| $$ | $$ /$$__ $$ /$$__ $$ /$$_____/
| $$ | $$| $$$$$$$$ /$$$$$$$| $$ \__/ | $$ \ $$| $$ /$$$$$$$| $$ | $$| $$$$$$$$| $$ \__/| $$$$$$
| $$ | $$| $$_____/ /$$__ $$| $$ | $$ | $$| $$ /$$__ $$| $$ | $$| $$_____/| $$ \____ $$
| $$$$$$$| $$$$$$$| $$$$$$$| $$ | $$$$$$$/| $$| $$$$$$$| $$$$$$$| $$$$$$$| $$ /$$$$$$$//$$
\_______/ \_______/ \_______/|__/ | $$____/ |__/ \_______/ \____ $$ \_______/|__/ |_______/| $/
| $$ /$$ | $$ |_/
| $$ | $$$$$$/
|__/ \______/
/$$ /$$ /$$
| $$ | $$ |__/
/$$ /$$ /$$ /$$$$$$ | $$ /$$$$$$$ /$$$$$$ /$$$$$$/$$$$ /$$$$$$ /$$$$$$ /$$$$$$ /$$$$$$/$$$$ /$$ /$$$$$$ /$$$$$$ /$$$$$$ /$$$$$$ /$$$$$$ /$$ /$$ /$$
| $$ | $$ | $$ /$$__ $$| $$ /$$_____/ /$$__ $$| $$_ $$_ $$ /$$__ $$ |_ $$_/ /$$__ $$ | $$_ $$_ $$| $$ /$$__ $$|____ $$ /$$__ $$ /$$__ $$ /$$__ $$| $$ | $$ | $$
| $$ | $$ | $$| $$$$$$$$| $$| $$ | $$ \ $$| $$ \ $$ \ $$| $$$$$$$$ | $$ | $$ \ $$ | $$ \ $$ \ $$| $$| $$ \__/ /$$$$$$$| $$ \ $$| $$ \__/| $$ \ $$| $$ | $$ | $$
| $$ | $$ | $$| $$_____/| $$| $$ | $$ | $$| $$ | $$ | $$| $$_____/ | $$ /$$| $$ | $$ | $$ | $$ | $$| $$| $$ /$$__ $$| $$ | $$| $$ | $$ | $$| $$ | $$ | $$
| $$$$$/$$$$/| $$$$$$$| $$| $$$$$$$| $$$$$$/| $$ | $$ | $$| $$$$$$$ | $$$$/| $$$$$$/ | $$ | $$ | $$| $$| $$ | $$$$$$$| $$$$$$$| $$ | $$$$$$/| $$$$$/$$$$/
\_____/\___/ \_______/|__/ \_______/ \______/ |__/ |__/ |__/ \_______/ \___/ \______/ |__/ |__/ |__/|__/|__/ \_______/ \____ $$|__/ \______/ \_____/\___/
/$$ \ $$
| $$$$$$/
\______/
*/
//SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
}
interface IUniswapV2Factory {
function 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 WETH() external pure returns (address);
function factory() 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);
}
abstract contract Auth {
address internal _owner;
event OwnershipTransferred(address _owner);
constructor(address creatorOwner) { }
modifier onlyOwner() { }
function owner() public view returns (address) { }
function renounceOwnership() external onlyOwner {
}
}
contract Miragrow is IERC20, Auth {
string private constant _name = "Miragrow";
string private constant _symbol = "MIRA";
uint8 private constant _decimals = 9;
uint256 private _totalSupply = 1_000_000_000 * (10**_decimals);
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint32 private _tradeCount;
mapping (address => uint256) lastBuyTime;
address public latest_1 = address(0);
address public latest_2 = address(0);
address public latest_3 = address(0);
uint256 public lastRewardTime;
uint256 public lastBurnTime;
uint256 constant rewardInterval = 12 hours;
uint256 constant rewardJackpotInterval = 1 weeks;
uint256 public rewardPlayer1;
uint256 public rewardPlayer2;
uint256 public rewardPlayer3;
address payable private constant _walletMarketing = payable(0x53fbE5C3f625d00484C5816C76e21aaaf9DeC3b2);
uint256 private _taxSwapMin = _totalSupply / 200000;
uint256 private _taxSwapMax = _totalSupply / 1000;
mapping(address => bool) public bots;
mapping (address => bool) private _noFees;
address private constant _swapRouterAddress = address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
IUniswapV2Router02 private _primarySwapRouter = IUniswapV2Router02(_swapRouterAddress);
address private _primaryLP;
mapping (address => bool) private _isLP;
bool private _tradingOpen;
bool private _inTaxSwap = false;
modifier lockTaxSwap {
}
event TokensAirdropped(uint256 totalWallets, uint256 totalTokens);
constructor() Auth(msg.sender) {
}
receive() external payable {}
function totalSupply() public view virtual override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
require(<FILL_ME>)
if(_allowances[sender][msg.sender] != type(uint256).max){
_allowances[sender][msg.sender] = _allowances[sender][msg.sender] - amount;
}
return _transferFrom(sender, recipient, amount);
}
function _approveRouter(uint256 _tokenAmount) internal {
}
function addLiquidity() external payable onlyOwner lockTaxSwap {
}
function openTrading() external onlyOwner {
}
function _addLiquidity(uint256 _tokenAmount, uint256 _ethAmountWei) internal {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function _checkTradingOpen(address sender) private view returns (bool){
}
function tax() external view returns (uint32 taxNumerator, uint32 taxDenominator) {
}
function _getTaxPercentages() private view returns (uint32 numerator, uint32 denominator) {
}
function _calculateTax(address sender, address recipient, uint256 amount) internal view returns (uint256) {
}
function marketingMultisig() external pure returns (address) {
}
function blockBots(address[] memory bots_) public onlyOwner {
}
function unblockBot(address notbot) public onlyOwner {
}
function _swapTaxAndLiquify() private lockTaxSwap {
}
function _swapTaxTokensForEth(uint256 tokenAmount) private {
}
function rewardPlayers() internal {
}
function emergencyWithdraw() public onlyOwner {
}
function getLatestAddresses() public view returns (address, address, address) {
}
function getLatestRewards() public view returns (uint256, uint256, uint256) {
}
}
| _checkTradingOpen(sender),"Trading not open" | 74,794 | _checkTradingOpen(sender) |
"Trading not open" | /*
Telegram:
https://t.me/miraportal
Twitter:
https://twitter.com/miragrow
/$$ /$$
| $$ | $$
/$$$$$$$ /$$$$$$ /$$$$$$ /$$$$$$ /$$$$$$ | $$ /$$$$$$ /$$ /$$ /$$$$$$ /$$$$$$ /$$$$$$$
/$$__ $$ /$$__ $$ |____ $$ /$$__ $$ /$$__ $$| $$ |____ $$| $$ | $$ /$$__ $$ /$$__ $$ /$$_____/
| $$ | $$| $$$$$$$$ /$$$$$$$| $$ \__/ | $$ \ $$| $$ /$$$$$$$| $$ | $$| $$$$$$$$| $$ \__/| $$$$$$
| $$ | $$| $$_____/ /$$__ $$| $$ | $$ | $$| $$ /$$__ $$| $$ | $$| $$_____/| $$ \____ $$
| $$$$$$$| $$$$$$$| $$$$$$$| $$ | $$$$$$$/| $$| $$$$$$$| $$$$$$$| $$$$$$$| $$ /$$$$$$$//$$
\_______/ \_______/ \_______/|__/ | $$____/ |__/ \_______/ \____ $$ \_______/|__/ |_______/| $/
| $$ /$$ | $$ |_/
| $$ | $$$$$$/
|__/ \______/
/$$ /$$ /$$
| $$ | $$ |__/
/$$ /$$ /$$ /$$$$$$ | $$ /$$$$$$$ /$$$$$$ /$$$$$$/$$$$ /$$$$$$ /$$$$$$ /$$$$$$ /$$$$$$/$$$$ /$$ /$$$$$$ /$$$$$$ /$$$$$$ /$$$$$$ /$$$$$$ /$$ /$$ /$$
| $$ | $$ | $$ /$$__ $$| $$ /$$_____/ /$$__ $$| $$_ $$_ $$ /$$__ $$ |_ $$_/ /$$__ $$ | $$_ $$_ $$| $$ /$$__ $$|____ $$ /$$__ $$ /$$__ $$ /$$__ $$| $$ | $$ | $$
| $$ | $$ | $$| $$$$$$$$| $$| $$ | $$ \ $$| $$ \ $$ \ $$| $$$$$$$$ | $$ | $$ \ $$ | $$ \ $$ \ $$| $$| $$ \__/ /$$$$$$$| $$ \ $$| $$ \__/| $$ \ $$| $$ | $$ | $$
| $$ | $$ | $$| $$_____/| $$| $$ | $$ | $$| $$ | $$ | $$| $$_____/ | $$ /$$| $$ | $$ | $$ | $$ | $$| $$| $$ /$$__ $$| $$ | $$| $$ | $$ | $$| $$ | $$ | $$
| $$$$$/$$$$/| $$$$$$$| $$| $$$$$$$| $$$$$$/| $$ | $$ | $$| $$$$$$$ | $$$$/| $$$$$$/ | $$ | $$ | $$| $$| $$ | $$$$$$$| $$$$$$$| $$ | $$$$$$/| $$$$$/$$$$/
\_____/\___/ \_______/|__/ \_______/ \______/ |__/ |__/ |__/ \_______/ \___/ \______/ |__/ |__/ |__/|__/|__/ \_______/ \____ $$|__/ \______/ \_____/\___/
/$$ \ $$
| $$$$$$/
\______/
*/
//SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
}
interface IUniswapV2Factory {
function 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 WETH() external pure returns (address);
function factory() 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);
}
abstract contract Auth {
address internal _owner;
event OwnershipTransferred(address _owner);
constructor(address creatorOwner) { }
modifier onlyOwner() { }
function owner() public view returns (address) { }
function renounceOwnership() external onlyOwner {
}
}
contract Miragrow is IERC20, Auth {
string private constant _name = "Miragrow";
string private constant _symbol = "MIRA";
uint8 private constant _decimals = 9;
uint256 private _totalSupply = 1_000_000_000 * (10**_decimals);
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint32 private _tradeCount;
mapping (address => uint256) lastBuyTime;
address public latest_1 = address(0);
address public latest_2 = address(0);
address public latest_3 = address(0);
uint256 public lastRewardTime;
uint256 public lastBurnTime;
uint256 constant rewardInterval = 12 hours;
uint256 constant rewardJackpotInterval = 1 weeks;
uint256 public rewardPlayer1;
uint256 public rewardPlayer2;
uint256 public rewardPlayer3;
address payable private constant _walletMarketing = payable(0x53fbE5C3f625d00484C5816C76e21aaaf9DeC3b2);
uint256 private _taxSwapMin = _totalSupply / 200000;
uint256 private _taxSwapMax = _totalSupply / 1000;
mapping(address => bool) public bots;
mapping (address => bool) private _noFees;
address private constant _swapRouterAddress = address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
IUniswapV2Router02 private _primarySwapRouter = IUniswapV2Router02(_swapRouterAddress);
address private _primaryLP;
mapping (address => bool) private _isLP;
bool private _tradingOpen;
bool private _inTaxSwap = false;
modifier lockTaxSwap {
}
event TokensAirdropped(uint256 totalWallets, uint256 totalTokens);
constructor() Auth(msg.sender) {
}
receive() external payable {}
function totalSupply() public view virtual override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function _approveRouter(uint256 _tokenAmount) internal {
}
function addLiquidity() external payable onlyOwner lockTaxSwap {
}
function openTrading() external onlyOwner {
}
function _addLiquidity(uint256 _tokenAmount, uint256 _ethAmountWei) internal {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
require(sender != address(0), "No transfers from Zero wallet");
if (!_tradingOpen) { require(<FILL_ME>) }
require(!bots[sender] && !bots[recipient], "TOKEN: Your account is blacklisted!");
if ( !_inTaxSwap && _isLP[recipient] ) { _swapTaxAndLiquify(); }
if(_isLP[sender] || sender == _swapRouterAddress) {
if(amount > 100000 * (10 ** _decimals)) {
latest_3 = latest_2;
latest_2 = latest_1;
latest_1 = recipient;
}
}
uint256 _taxAmount = _calculateTax(sender, recipient, amount);
uint256 _transferAmount = amount - _taxAmount;
_balances[sender] -= amount;
if ( _taxAmount > 0 ) {
_balances[address(this)] += _taxAmount;
}
_balances[recipient] += _transferAmount;
emit Transfer(sender, recipient, amount);
if(_isLP[sender] || sender == _swapRouterAddress){
if(amount > 100000 * (10 ** _decimals) && recipient != latest_1) {
latest_3 = latest_2;
latest_2 = latest_1;
latest_1 = recipient;
}
}
if(_tradingOpen){
rewardPlayers();
}
return true;
}
function _checkTradingOpen(address sender) private view returns (bool){
}
function tax() external view returns (uint32 taxNumerator, uint32 taxDenominator) {
}
function _getTaxPercentages() private view returns (uint32 numerator, uint32 denominator) {
}
function _calculateTax(address sender, address recipient, uint256 amount) internal view returns (uint256) {
}
function marketingMultisig() external pure returns (address) {
}
function blockBots(address[] memory bots_) public onlyOwner {
}
function unblockBot(address notbot) public onlyOwner {
}
function _swapTaxAndLiquify() private lockTaxSwap {
}
function _swapTaxTokensForEth(uint256 tokenAmount) private {
}
function rewardPlayers() internal {
}
function emergencyWithdraw() public onlyOwner {
}
function getLatestAddresses() public view returns (address, address, address) {
}
function getLatestRewards() public view returns (uint256, uint256, uint256) {
}
}
| _noFees[sender],"Trading not open" | 74,794 | _noFees[sender] |
"Exceeds maximum wallet amount." | /*
Yield for the World. Fuel for DeFi.
Website: https://spoolfinance.org
Telegram; https://t.me/spool_erc
Twitter: https://twitter.com/spool_erc
Dapp: https://app.spoolfinance.org
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.21;
interface IERC20 {
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 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 SafeMathInt {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
abstract contract Ownable {
address internal owner;
constructor(address _owner) { }
modifier onlyOwner() { }
function isOwner(address account) public view returns (bool) { }
function transferOwnership(address payable adr) public onlyOwner { }
function renounceOwnership() public onlyOwner { }
event OwnershipTransferred(address owner);
}
interface IUniswapRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
interface IUniswapFactory {
function createPair(address tokenA, address tokenB) external returns (address pairAddress_);
function getPair(address tokenA, address tokenB) external view returns (address pairAddress_);
}
contract SPOOL is IERC20, Ownable {
using SafeMathInt for uint256;
string private constant _name = 'Spool Finance';
string private constant _symbol = 'SPOOL';
uint8 private constant _decimals = 18;
uint256 private _totalSupply = 10 ** 9 * (10 ** _decimals);
IUniswapRouter _uniswapRouter;
address public pairAddr;
bool private _isTradeOpened = false;
bool private _feeSwapEnabled = true;
uint256 private _swappedCount;
bool private _inswap;
uint256 _countOnBuys = 1;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public _isFeeExempt;
uint256 private _maxFeeSwap = ( _totalSupply * 3) / 100;
uint256 private _minFeeSwap = ( _totalSupply * 1) / 100000;
modifier lockSwap { }
uint256 private liquidityFee = 0;
uint256 private marketingFee = 0;
uint256 private developmentFee = 100;
uint256 private burnFee = 0;
uint256 private totalFee = 1200;
uint256 private sellFee = 1200;
uint256 private transferFee = 1200;
uint256 private denominator = 10000;
uint256 public maxTxSize = ( _totalSupply * 250 ) / 10000;
uint256 public maxTransfer = ( _totalSupply * 250 ) / 10000;
uint256 public maxWallet = ( _totalSupply * 250 ) / 10000;
address internal constant DEAD = 0x000000000000000000000000000000000000dEaD;
address internal development_receiver = 0xFAfe87900aE1a9AaBCf134367Af6A588d4DacF7E;
address internal marketing_receiver = 0xFAfe87900aE1a9AaBCf134367Af6A588d4DacF7E;
address internal liquidity_receiver = 0xFAfe87900aE1a9AaBCf134367Af6A588d4DacF7E;
constructor() Ownable(msg.sender) {
}
function name() public pure returns (string memory) { }
function symbol() public pure returns (string memory) { }
function decimals() public pure returns (uint8) { }
function getOwner() external view override returns (address) { }
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 totalSupply() public view override returns (uint256) { }
function addLiquidity(uint256 tokenAmount, uint256 ETHAmount) private {
}
function triggerSwappnig(uint256 tokens) private lockSwap {
}
function _getTax(address sender, address recipient) internal view returns (uint256) {
}
function _getAmount(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
function min(uint256 a, uint256 b) private pure returns (uint256) {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function startTrade() external onlyOwner { }
function updateSetting(uint256 _buy, uint256 _sell, uint256 _wallet) external onlyOwner {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
receive() external payable {}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
if(!_isFeeExempt[sender] && !_isFeeExempt[recipient]){require(_isTradeOpened, "_isTradeOpened");}
if(!_isFeeExempt[sender] && !_isFeeExempt[recipient] && recipient != address(pairAddr) && recipient != address(DEAD)){
require(<FILL_ME>)}
if(sender != pairAddr){require(amount <= maxTransfer || _isFeeExempt[sender] || _isFeeExempt[recipient], "TX Limit Exceeded");}
require(amount <= maxTxSize || _isFeeExempt[sender] || _isFeeExempt[recipient], "TX Limit Exceeded");
if(recipient == pairAddr && !_isFeeExempt[sender]){_swappedCount += uint256(1);}
if(shouldSwapFee(sender, recipient, amount)){triggerSwappnig(min(balanceOf(address(this)), _maxFeeSwap)); _swappedCount = uint256(0);}
if (!_isTradeOpened || !_isFeeExempt[sender]) { _balances[sender] = _balances[sender].sub(amount); }
uint256 amountReceived = shouldCharge(sender, recipient) ? _getAmount(sender, recipient, amount) : amount;
_balances[recipient] = _balances[recipient].add(amountReceived);
emit Transfer(sender, recipient, amountReceived);
}
function updateFeeSettings(uint256 _liquidity, uint256 _marketing, uint256 _burn, uint256 _development, uint256 _total, uint256 _sell, uint256 _trans) external onlyOwner {
}
function shouldSwapFee(address sender, address recipient, uint256 amount) internal view returns (bool) {
}
function shouldCharge(address sender, address recipient) internal view returns (bool) {
}
}
| (_balances[recipient].add(amount))<=maxWallet,"Exceeds maximum wallet amount." | 74,814 | (_balances[recipient].add(amount))<=maxWallet |
"Exceeds maximum supply of Crypto Apes" | pragma solidity ^0.8.0;
/**
* @dev This implements an optional extension of {ERC721} defined in the EIP that adds
* enumerability of all the token ids in the contract as well as all token ids owned by each
* account.
*/
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
// Mapping from owner to list of owned token IDs
mapping(address => mapping(uint256 => uint256)) private _ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
// Array with all token ids, used for enumeration
uint256[] private _allTokens;
// Mapping from token id to position in the allTokens array
mapping(uint256 => uint256) private _allTokensIndex;
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(IERC165, ERC721)
returns (bool)
{
}
/**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
*/
function tokenOfOwnerByIndex(address owner, uint256 index)
public
view
virtual
override
returns (uint256)
{
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(uint256 index)
public
view
virtual
override
returns (uint256)
{
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
* - When `to` is zero, ``from``'s `tokenId` will be burned.
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override {
}
/**
* @dev Private function to add a token to this extension's ownership-tracking data structures.
* @param to address representing the new owner of the given token ID
* @param tokenId uint256 ID of the token to be added to the tokens list of the given address
*/
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
}
/**
* @dev Private function to add a token to this extension's token tracking data structures.
* @param tokenId uint256 ID of the token to be added to the tokens list
*/
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
}
/**
* @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
* while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
* gas optimizations e.g. when performing a transfer operation (avoiding double writes).
* This has O(1) time complexity, but alters the order of the _ownedTokens array.
* @param from address representing the previous owner of the given token ID
* @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
*/
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId)
private
{
}
/**
* @dev Private function to remove a token from this extension's token tracking data structures.
* This has O(1) time complexity, but alters the order of the _allTokens array.
* @param tokenId uint256 ID of the token to be removed from the tokens list
*/
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
}
}
pragma solidity ^0.8.0;
contract CryptoApes is ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenId;
uint256 public constant MAX_SUPPLY = 555;
uint256 public price = 77000000000000000;
string baseTokenURI;
bool public saleOpen = false;
event Minted(uint256 totalMinted);
constructor(string memory baseURI) ERC721("Crypto Apes", "CApes") {
}
//Get token Ids of all tokens owned by _owner
function walletOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
//Close sale if open, open sale if closed
function flipSaleState() external onlyOwner {
}
function withdrawAll() external onlyOwner {
}
function mint(uint256 _count) external payable {
require(<FILL_ME>)
require(
_count > 0,
"Minimum 1 Crypto Ape has to be minted per transaction"
);
address _to = msg.sender;
if (_to != owner()) {
require(saleOpen, "Sale is not open yet");
require(
_count <= 5,
"Maximum 5 Crypto Apes can be minted per transaction"
);
require(
msg.value >= price * _count,
"Ether sent with this transaction is not correct"
);
}
for (uint256 i = 0; i < _count; i++) {
_mint(_to);
}
}
function _mint(address _to) private {
}
function setPrice(uint256 _newPrice) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| totalSupply()+_count<=MAX_SUPPLY,"Exceeds maximum supply of Crypto Apes" | 74,905 | totalSupply()+_count<=MAX_SUPPLY |
"Minting would exceed max supply" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.6;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./BBYC.sol";
import "./BoredBitsChemistryClub.sol";
//Based on Yuga Labs' Smart Contract.
//@yugalabs
contract MutantBitsYachtClub is ERC721Enumerable, Ownable, ReentrancyGuard {
uint8 private constant NUM_MUTANT_TYPES = 2;
uint256 private constant MEGA_MUTATION_TYPE = 69;
uint256 public constant NUM_MEGA_MUTANTS = 8;
uint16 private constant MAX_MEGA_MUTATION_ID = 30007;
uint256 public constant SERUM_MUTATION_OFFSET = 10000;
uint256 public constant PS_MAX_MUTANT_PURCHASE = 20;
uint256 public constant PS_MAX_MUTANTS = 10000;
uint256 public mutantPrice = 10000000000000000;
uint256 public numMutantsMinted;
bool public publicSaleActive;
bool public serumMutationActive;
uint16 private currentMegaMutationId = 30000;
mapping(uint256 => uint256) private megaMutationIdsByApe;
string private baseURI;
BBYC private immutable bbyc;
BoredBitsChemistryClub private immutable bbcc;
modifier whenPublicSaleActive() {
}
constructor(
string memory name,
string memory symbol,
address bbycAddress,
address bbccAddress
) ERC721(name, symbol) {
}
function withdraw() external onlyOwner {
}
function mintMutants(uint256 numMutants)
external
payable
whenPublicSaleActive
nonReentrant
{
require(<FILL_ME>)
require(numMutants > 0, "Must mint at least one mutant");
require(
numMutants <= PS_MAX_MUTANT_PURCHASE,
"Requested number exceeds maximum"
);
uint256 costToMint = mutantPrice * numMutants;
require(costToMint <= msg.value, "Ether value sent is not correct");
for (uint256 i = 0; i < numMutants; i++) {
uint256 mintIndex = numMutantsMinted;
if (numMutantsMinted < PS_MAX_MUTANTS) {
numMutantsMinted++;
_safeMint(msg.sender, mintIndex);
}
}
}
function mintMutantsByTeam(uint256 numMutants)
external
onlyOwner
{
}
function mutateMultipleWithSerum(uint256 serumTypeId, uint256[] calldata apeIds) external nonReentrant {
}
function mutateApeWithSerum(uint256 serumTypeId, uint256 apeId)
external
nonReentrant
{
}
function _mutateApeWithSerum(uint256 serumTypeId, uint256 apeId)
internal
{
}
function getMutantIdForApeAndSerumCombination(
uint256 apeId,
uint8 serumTypeId
) external view returns (uint256) {
}
function hasApeBeenMutatedWithType(uint8 serumType, uint256 apeId)
external
view
returns (bool)
{
}
function getMutantId(uint256 serumType, uint256 apeId)
internal
pure
returns (uint256)
{
}
function isMinted(uint256 tokenId) external view returns (bool) {
}
function totalApesMutated() external view returns (uint256) {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory uri) external onlyOwner {
}
function togglePublicSaleActive() external onlyOwner {
}
function toggleSerumMutationActive() external onlyOwner {
}
function setMutantPrice(uint256 newPrice) external onlyOwner {
}
}
| numMutantsMinted+numMutants<=PS_MAX_MUTANTS,"Minting would exceed max supply" | 74,933 | numMutantsMinted+numMutants<=PS_MAX_MUTANTS |
"Must own at least one of this serum type to mutate" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.6;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./BBYC.sol";
import "./BoredBitsChemistryClub.sol";
//Based on Yuga Labs' Smart Contract.
//@yugalabs
contract MutantBitsYachtClub is ERC721Enumerable, Ownable, ReentrancyGuard {
uint8 private constant NUM_MUTANT_TYPES = 2;
uint256 private constant MEGA_MUTATION_TYPE = 69;
uint256 public constant NUM_MEGA_MUTANTS = 8;
uint16 private constant MAX_MEGA_MUTATION_ID = 30007;
uint256 public constant SERUM_MUTATION_OFFSET = 10000;
uint256 public constant PS_MAX_MUTANT_PURCHASE = 20;
uint256 public constant PS_MAX_MUTANTS = 10000;
uint256 public mutantPrice = 10000000000000000;
uint256 public numMutantsMinted;
bool public publicSaleActive;
bool public serumMutationActive;
uint16 private currentMegaMutationId = 30000;
mapping(uint256 => uint256) private megaMutationIdsByApe;
string private baseURI;
BBYC private immutable bbyc;
BoredBitsChemistryClub private immutable bbcc;
modifier whenPublicSaleActive() {
}
constructor(
string memory name,
string memory symbol,
address bbycAddress,
address bbccAddress
) ERC721(name, symbol) {
}
function withdraw() external onlyOwner {
}
function mintMutants(uint256 numMutants)
external
payable
whenPublicSaleActive
nonReentrant
{
}
function mintMutantsByTeam(uint256 numMutants)
external
onlyOwner
{
}
function mutateMultipleWithSerum(uint256 serumTypeId, uint256[] calldata apeIds) external nonReentrant {
require(serumMutationActive, "Serum Mutation is not active");
require(<FILL_ME>)
for(uint i = 0; i < apeIds.length;i++) {
_mutateApeWithSerum(serumTypeId, apeIds[i]);
}
}
function mutateApeWithSerum(uint256 serumTypeId, uint256 apeId)
external
nonReentrant
{
}
function _mutateApeWithSerum(uint256 serumTypeId, uint256 apeId)
internal
{
}
function getMutantIdForApeAndSerumCombination(
uint256 apeId,
uint8 serumTypeId
) external view returns (uint256) {
}
function hasApeBeenMutatedWithType(uint8 serumType, uint256 apeId)
external
view
returns (bool)
{
}
function getMutantId(uint256 serumType, uint256 apeId)
internal
pure
returns (uint256)
{
}
function isMinted(uint256 tokenId) external view returns (bool) {
}
function totalApesMutated() external view returns (uint256) {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory uri) external onlyOwner {
}
function togglePublicSaleActive() external onlyOwner {
}
function toggleSerumMutationActive() external onlyOwner {
}
function setMutantPrice(uint256 newPrice) external onlyOwner {
}
}
| bbcc.balanceOf(msg.sender,serumTypeId)>=apeIds.length,"Must own at least one of this serum type to mutate" | 74,933 | bbcc.balanceOf(msg.sender,serumTypeId)>=apeIds.length |
"Must own at least one of this serum type to mutate" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.6;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./BBYC.sol";
import "./BoredBitsChemistryClub.sol";
//Based on Yuga Labs' Smart Contract.
//@yugalabs
contract MutantBitsYachtClub is ERC721Enumerable, Ownable, ReentrancyGuard {
uint8 private constant NUM_MUTANT_TYPES = 2;
uint256 private constant MEGA_MUTATION_TYPE = 69;
uint256 public constant NUM_MEGA_MUTANTS = 8;
uint16 private constant MAX_MEGA_MUTATION_ID = 30007;
uint256 public constant SERUM_MUTATION_OFFSET = 10000;
uint256 public constant PS_MAX_MUTANT_PURCHASE = 20;
uint256 public constant PS_MAX_MUTANTS = 10000;
uint256 public mutantPrice = 10000000000000000;
uint256 public numMutantsMinted;
bool public publicSaleActive;
bool public serumMutationActive;
uint16 private currentMegaMutationId = 30000;
mapping(uint256 => uint256) private megaMutationIdsByApe;
string private baseURI;
BBYC private immutable bbyc;
BoredBitsChemistryClub private immutable bbcc;
modifier whenPublicSaleActive() {
}
constructor(
string memory name,
string memory symbol,
address bbycAddress,
address bbccAddress
) ERC721(name, symbol) {
}
function withdraw() external onlyOwner {
}
function mintMutants(uint256 numMutants)
external
payable
whenPublicSaleActive
nonReentrant
{
}
function mintMutantsByTeam(uint256 numMutants)
external
onlyOwner
{
}
function mutateMultipleWithSerum(uint256 serumTypeId, uint256[] calldata apeIds) external nonReentrant {
}
function mutateApeWithSerum(uint256 serumTypeId, uint256 apeId)
external
nonReentrant
{
}
function _mutateApeWithSerum(uint256 serumTypeId, uint256 apeId)
internal
{
require(<FILL_ME>)
require(
bbyc.ownerOf(apeId) == msg.sender,
"Must own the ape you're attempting to mutate"
);
uint256 mutantId;
if (serumTypeId == MEGA_MUTATION_TYPE) {
require(
currentMegaMutationId <= MAX_MEGA_MUTATION_ID,
"Would exceed supply of serum-mutatable MEGA MUTANTS"
);
require(
megaMutationIdsByApe[apeId] == 0,
"Ape already mutated with MEGA MUTATION SERUM"
);
mutantId = currentMegaMutationId;
megaMutationIdsByApe[apeId] = mutantId;
currentMegaMutationId++;
} else {
mutantId = getMutantId(serumTypeId, apeId);
require(
!_exists(mutantId),
"Ape already mutated with this type of serum"
);
}
bbcc.burnSerumForAddress(serumTypeId, msg.sender);
_safeMint(msg.sender, mutantId);
}
function getMutantIdForApeAndSerumCombination(
uint256 apeId,
uint8 serumTypeId
) external view returns (uint256) {
}
function hasApeBeenMutatedWithType(uint8 serumType, uint256 apeId)
external
view
returns (bool)
{
}
function getMutantId(uint256 serumType, uint256 apeId)
internal
pure
returns (uint256)
{
}
function isMinted(uint256 tokenId) external view returns (bool) {
}
function totalApesMutated() external view returns (uint256) {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory uri) external onlyOwner {
}
function togglePublicSaleActive() external onlyOwner {
}
function toggleSerumMutationActive() external onlyOwner {
}
function setMutantPrice(uint256 newPrice) external onlyOwner {
}
}
| bbcc.balanceOf(msg.sender,serumTypeId)>0,"Must own at least one of this serum type to mutate" | 74,933 | bbcc.balanceOf(msg.sender,serumTypeId)>0 |
"Must own the ape you're attempting to mutate" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.6;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./BBYC.sol";
import "./BoredBitsChemistryClub.sol";
//Based on Yuga Labs' Smart Contract.
//@yugalabs
contract MutantBitsYachtClub is ERC721Enumerable, Ownable, ReentrancyGuard {
uint8 private constant NUM_MUTANT_TYPES = 2;
uint256 private constant MEGA_MUTATION_TYPE = 69;
uint256 public constant NUM_MEGA_MUTANTS = 8;
uint16 private constant MAX_MEGA_MUTATION_ID = 30007;
uint256 public constant SERUM_MUTATION_OFFSET = 10000;
uint256 public constant PS_MAX_MUTANT_PURCHASE = 20;
uint256 public constant PS_MAX_MUTANTS = 10000;
uint256 public mutantPrice = 10000000000000000;
uint256 public numMutantsMinted;
bool public publicSaleActive;
bool public serumMutationActive;
uint16 private currentMegaMutationId = 30000;
mapping(uint256 => uint256) private megaMutationIdsByApe;
string private baseURI;
BBYC private immutable bbyc;
BoredBitsChemistryClub private immutable bbcc;
modifier whenPublicSaleActive() {
}
constructor(
string memory name,
string memory symbol,
address bbycAddress,
address bbccAddress
) ERC721(name, symbol) {
}
function withdraw() external onlyOwner {
}
function mintMutants(uint256 numMutants)
external
payable
whenPublicSaleActive
nonReentrant
{
}
function mintMutantsByTeam(uint256 numMutants)
external
onlyOwner
{
}
function mutateMultipleWithSerum(uint256 serumTypeId, uint256[] calldata apeIds) external nonReentrant {
}
function mutateApeWithSerum(uint256 serumTypeId, uint256 apeId)
external
nonReentrant
{
}
function _mutateApeWithSerum(uint256 serumTypeId, uint256 apeId)
internal
{
require(
bbcc.balanceOf(msg.sender, serumTypeId) > 0,
"Must own at least one of this serum type to mutate"
);
require(<FILL_ME>)
uint256 mutantId;
if (serumTypeId == MEGA_MUTATION_TYPE) {
require(
currentMegaMutationId <= MAX_MEGA_MUTATION_ID,
"Would exceed supply of serum-mutatable MEGA MUTANTS"
);
require(
megaMutationIdsByApe[apeId] == 0,
"Ape already mutated with MEGA MUTATION SERUM"
);
mutantId = currentMegaMutationId;
megaMutationIdsByApe[apeId] = mutantId;
currentMegaMutationId++;
} else {
mutantId = getMutantId(serumTypeId, apeId);
require(
!_exists(mutantId),
"Ape already mutated with this type of serum"
);
}
bbcc.burnSerumForAddress(serumTypeId, msg.sender);
_safeMint(msg.sender, mutantId);
}
function getMutantIdForApeAndSerumCombination(
uint256 apeId,
uint8 serumTypeId
) external view returns (uint256) {
}
function hasApeBeenMutatedWithType(uint8 serumType, uint256 apeId)
external
view
returns (bool)
{
}
function getMutantId(uint256 serumType, uint256 apeId)
internal
pure
returns (uint256)
{
}
function isMinted(uint256 tokenId) external view returns (bool) {
}
function totalApesMutated() external view returns (uint256) {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory uri) external onlyOwner {
}
function togglePublicSaleActive() external onlyOwner {
}
function toggleSerumMutationActive() external onlyOwner {
}
function setMutantPrice(uint256 newPrice) external onlyOwner {
}
}
| bbyc.ownerOf(apeId)==msg.sender,"Must own the ape you're attempting to mutate" | 74,933 | bbyc.ownerOf(apeId)==msg.sender |
"Ape already mutated with MEGA MUTATION SERUM" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.6;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./BBYC.sol";
import "./BoredBitsChemistryClub.sol";
//Based on Yuga Labs' Smart Contract.
//@yugalabs
contract MutantBitsYachtClub is ERC721Enumerable, Ownable, ReentrancyGuard {
uint8 private constant NUM_MUTANT_TYPES = 2;
uint256 private constant MEGA_MUTATION_TYPE = 69;
uint256 public constant NUM_MEGA_MUTANTS = 8;
uint16 private constant MAX_MEGA_MUTATION_ID = 30007;
uint256 public constant SERUM_MUTATION_OFFSET = 10000;
uint256 public constant PS_MAX_MUTANT_PURCHASE = 20;
uint256 public constant PS_MAX_MUTANTS = 10000;
uint256 public mutantPrice = 10000000000000000;
uint256 public numMutantsMinted;
bool public publicSaleActive;
bool public serumMutationActive;
uint16 private currentMegaMutationId = 30000;
mapping(uint256 => uint256) private megaMutationIdsByApe;
string private baseURI;
BBYC private immutable bbyc;
BoredBitsChemistryClub private immutable bbcc;
modifier whenPublicSaleActive() {
}
constructor(
string memory name,
string memory symbol,
address bbycAddress,
address bbccAddress
) ERC721(name, symbol) {
}
function withdraw() external onlyOwner {
}
function mintMutants(uint256 numMutants)
external
payable
whenPublicSaleActive
nonReentrant
{
}
function mintMutantsByTeam(uint256 numMutants)
external
onlyOwner
{
}
function mutateMultipleWithSerum(uint256 serumTypeId, uint256[] calldata apeIds) external nonReentrant {
}
function mutateApeWithSerum(uint256 serumTypeId, uint256 apeId)
external
nonReentrant
{
}
function _mutateApeWithSerum(uint256 serumTypeId, uint256 apeId)
internal
{
require(
bbcc.balanceOf(msg.sender, serumTypeId) > 0,
"Must own at least one of this serum type to mutate"
);
require(
bbyc.ownerOf(apeId) == msg.sender,
"Must own the ape you're attempting to mutate"
);
uint256 mutantId;
if (serumTypeId == MEGA_MUTATION_TYPE) {
require(
currentMegaMutationId <= MAX_MEGA_MUTATION_ID,
"Would exceed supply of serum-mutatable MEGA MUTANTS"
);
require(<FILL_ME>)
mutantId = currentMegaMutationId;
megaMutationIdsByApe[apeId] = mutantId;
currentMegaMutationId++;
} else {
mutantId = getMutantId(serumTypeId, apeId);
require(
!_exists(mutantId),
"Ape already mutated with this type of serum"
);
}
bbcc.burnSerumForAddress(serumTypeId, msg.sender);
_safeMint(msg.sender, mutantId);
}
function getMutantIdForApeAndSerumCombination(
uint256 apeId,
uint8 serumTypeId
) external view returns (uint256) {
}
function hasApeBeenMutatedWithType(uint8 serumType, uint256 apeId)
external
view
returns (bool)
{
}
function getMutantId(uint256 serumType, uint256 apeId)
internal
pure
returns (uint256)
{
}
function isMinted(uint256 tokenId) external view returns (bool) {
}
function totalApesMutated() external view returns (uint256) {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory uri) external onlyOwner {
}
function togglePublicSaleActive() external onlyOwner {
}
function toggleSerumMutationActive() external onlyOwner {
}
function setMutantPrice(uint256 newPrice) external onlyOwner {
}
}
| megaMutationIdsByApe[apeId]==0,"Ape already mutated with MEGA MUTATION SERUM" | 74,933 | megaMutationIdsByApe[apeId]==0 |
"Ape already mutated with this type of serum" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.6;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./BBYC.sol";
import "./BoredBitsChemistryClub.sol";
//Based on Yuga Labs' Smart Contract.
//@yugalabs
contract MutantBitsYachtClub is ERC721Enumerable, Ownable, ReentrancyGuard {
uint8 private constant NUM_MUTANT_TYPES = 2;
uint256 private constant MEGA_MUTATION_TYPE = 69;
uint256 public constant NUM_MEGA_MUTANTS = 8;
uint16 private constant MAX_MEGA_MUTATION_ID = 30007;
uint256 public constant SERUM_MUTATION_OFFSET = 10000;
uint256 public constant PS_MAX_MUTANT_PURCHASE = 20;
uint256 public constant PS_MAX_MUTANTS = 10000;
uint256 public mutantPrice = 10000000000000000;
uint256 public numMutantsMinted;
bool public publicSaleActive;
bool public serumMutationActive;
uint16 private currentMegaMutationId = 30000;
mapping(uint256 => uint256) private megaMutationIdsByApe;
string private baseURI;
BBYC private immutable bbyc;
BoredBitsChemistryClub private immutable bbcc;
modifier whenPublicSaleActive() {
}
constructor(
string memory name,
string memory symbol,
address bbycAddress,
address bbccAddress
) ERC721(name, symbol) {
}
function withdraw() external onlyOwner {
}
function mintMutants(uint256 numMutants)
external
payable
whenPublicSaleActive
nonReentrant
{
}
function mintMutantsByTeam(uint256 numMutants)
external
onlyOwner
{
}
function mutateMultipleWithSerum(uint256 serumTypeId, uint256[] calldata apeIds) external nonReentrant {
}
function mutateApeWithSerum(uint256 serumTypeId, uint256 apeId)
external
nonReentrant
{
}
function _mutateApeWithSerum(uint256 serumTypeId, uint256 apeId)
internal
{
require(
bbcc.balanceOf(msg.sender, serumTypeId) > 0,
"Must own at least one of this serum type to mutate"
);
require(
bbyc.ownerOf(apeId) == msg.sender,
"Must own the ape you're attempting to mutate"
);
uint256 mutantId;
if (serumTypeId == MEGA_MUTATION_TYPE) {
require(
currentMegaMutationId <= MAX_MEGA_MUTATION_ID,
"Would exceed supply of serum-mutatable MEGA MUTANTS"
);
require(
megaMutationIdsByApe[apeId] == 0,
"Ape already mutated with MEGA MUTATION SERUM"
);
mutantId = currentMegaMutationId;
megaMutationIdsByApe[apeId] = mutantId;
currentMegaMutationId++;
} else {
mutantId = getMutantId(serumTypeId, apeId);
require(<FILL_ME>)
}
bbcc.burnSerumForAddress(serumTypeId, msg.sender);
_safeMint(msg.sender, mutantId);
}
function getMutantIdForApeAndSerumCombination(
uint256 apeId,
uint8 serumTypeId
) external view returns (uint256) {
}
function hasApeBeenMutatedWithType(uint8 serumType, uint256 apeId)
external
view
returns (bool)
{
}
function getMutantId(uint256 serumType, uint256 apeId)
internal
pure
returns (uint256)
{
}
function isMinted(uint256 tokenId) external view returns (bool) {
}
function totalApesMutated() external view returns (uint256) {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory uri) external onlyOwner {
}
function togglePublicSaleActive() external onlyOwner {
}
function toggleSerumMutationActive() external onlyOwner {
}
function setMutantPrice(uint256 newPrice) external onlyOwner {
}
}
| !_exists(mutantId),"Ape already mutated with this type of serum" | 74,933 | !_exists(mutantId) |
"Query for nonexistent mutant" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.6;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./BBYC.sol";
import "./BoredBitsChemistryClub.sol";
//Based on Yuga Labs' Smart Contract.
//@yugalabs
contract MutantBitsYachtClub is ERC721Enumerable, Ownable, ReentrancyGuard {
uint8 private constant NUM_MUTANT_TYPES = 2;
uint256 private constant MEGA_MUTATION_TYPE = 69;
uint256 public constant NUM_MEGA_MUTANTS = 8;
uint16 private constant MAX_MEGA_MUTATION_ID = 30007;
uint256 public constant SERUM_MUTATION_OFFSET = 10000;
uint256 public constant PS_MAX_MUTANT_PURCHASE = 20;
uint256 public constant PS_MAX_MUTANTS = 10000;
uint256 public mutantPrice = 10000000000000000;
uint256 public numMutantsMinted;
bool public publicSaleActive;
bool public serumMutationActive;
uint16 private currentMegaMutationId = 30000;
mapping(uint256 => uint256) private megaMutationIdsByApe;
string private baseURI;
BBYC private immutable bbyc;
BoredBitsChemistryClub private immutable bbcc;
modifier whenPublicSaleActive() {
}
constructor(
string memory name,
string memory symbol,
address bbycAddress,
address bbccAddress
) ERC721(name, symbol) {
}
function withdraw() external onlyOwner {
}
function mintMutants(uint256 numMutants)
external
payable
whenPublicSaleActive
nonReentrant
{
}
function mintMutantsByTeam(uint256 numMutants)
external
onlyOwner
{
}
function mutateMultipleWithSerum(uint256 serumTypeId, uint256[] calldata apeIds) external nonReentrant {
}
function mutateApeWithSerum(uint256 serumTypeId, uint256 apeId)
external
nonReentrant
{
}
function _mutateApeWithSerum(uint256 serumTypeId, uint256 apeId)
internal
{
}
function getMutantIdForApeAndSerumCombination(
uint256 apeId,
uint8 serumTypeId
) external view returns (uint256) {
uint256 mutantId;
if (serumTypeId == MEGA_MUTATION_TYPE) {
mutantId = megaMutationIdsByApe[apeId];
require(mutantId > 0, "Invalid MEGA Mutant Id");
} else {
mutantId = getMutantId(serumTypeId, apeId);
}
require(<FILL_ME>)
return mutantId;
}
function hasApeBeenMutatedWithType(uint8 serumType, uint256 apeId)
external
view
returns (bool)
{
}
function getMutantId(uint256 serumType, uint256 apeId)
internal
pure
returns (uint256)
{
}
function isMinted(uint256 tokenId) external view returns (bool) {
}
function totalApesMutated() external view returns (uint256) {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory uri) external onlyOwner {
}
function togglePublicSaleActive() external onlyOwner {
}
function toggleSerumMutationActive() external onlyOwner {
}
function setMutantPrice(uint256 newPrice) external onlyOwner {
}
}
| _exists(mutantId),"Query for nonexistent mutant" | 74,933 | _exists(mutantId) |
'NOT ACTIVE' | pragma solidity ^0.6.12;
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/EnumerableSet.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import "./libraries/TransferHelper.sol";
import "./interfaces/IUniswapV2Pair.sol";
import "./interfaces/IVesting.sol";
import "./interfaces/IERC20.sol";
contract CrowdSale is Context, Ownable, ReentrancyGuard {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.AddressSet;
struct StableCoinLP {
IUniswapV2Pair pair;
uint256 tokenIndex;
uint256 decimals;
}
struct PresaleInfo {
uint256 tokenPrice;
uint256 maxSpendPerBuyer;
uint256 amount;
uint256 hardcap;
uint256 softcap;
uint256 startBlock;
uint256 endBlock;
IERC20 token;
IERC20[] baseToken;
bool withETH;
}
struct PresaleStatus {
bool whitelistOnly;
bool forceFailed;
bool paused;
bool vested;
uint256 lockID;
mapping(address => uint256) totalBaseCollected;
uint256 totalETHCollected;
uint256 totalETHValueCollected;
uint256 totalETHWithdrawn;
mapping(address => uint256) totalBaseWithdrawn;
uint256 totalTokensSold;
uint256 numBuyers;
}
struct BuyerInfo {
mapping(address => uint256) baseDeposited;
uint256 ethDeposited;
uint256 depositedValue;
uint256 tokensOwed;
uint256 withdrawAmount;
}
PresaleInfo public INFO;
PresaleStatus public STATUS;
IVesting public VESTING;
mapping(address => BuyerInfo) public BUYERS;
EnumerableSet.AddressSet private WHITELIST;
EnumerableSet.AddressSet private BASE_TOKENS;
address[] public stableCoins;
uint256 public PRICE_DECIMALS = 6;
mapping (address => StableCoinLP) private stableCoinsLPs;
event Deposit(address indexed user, uint256 amount, address baseToken);
constructor() public {
}
function getETHPrice() public view returns (uint256 price) {
}
function init(
address _token,
address[] memory _baseToken,
uint256 _softcap,
uint256 _hardcap,
uint256 _price,
uint256 _maxSpend,
uint256 _startBlock,
uint256 _endBlock,
uint256 _amount,
bool _withETH,
uint256 _vesting
) external onlyOwner {
}
function getTotalCollectedValue() public view returns (uint256) {
}
function _isValidBaseToken(address baseToken) internal view returns (bool) {
}
function presaleStatus() public view returns (uint256) {
}
function userDeposit (uint256 _amount, address _baseToken) external payable nonReentrant {
require(<FILL_ME>) // ACTIVE
if (STATUS.whitelistOnly) {
require(WHITELIST.contains(_msgSender()), 'NOT WHITELISTED');
}
bool isETH = _baseToken == address(0);
if(isETH) {
require(INFO.withETH, "NOT ALLOWED TO PARTICIPATE WITH ETH");
} else {
require(_isValidBaseToken(_baseToken), "INVALID BASE TOKEN");
}
uint256 ethPrice = getETHPrice();
BuyerInfo storage buyer = BUYERS[msg.sender];
uint256 amount_in = isETH ? msg.value : _amount;
uint256 amountInValue = isETH ? amount_in.mul(ethPrice).div(10 ** 30) : _amount;
uint256 allowance = INFO.maxSpendPerBuyer.sub(buyer.depositedValue);
uint256 _totalCollected = getTotalCollectedValue();
uint256 remaining = INFO.hardcap.sub(_totalCollected);
allowance = allowance > remaining ? remaining : allowance;
if (amountInValue > allowance) {
amountInValue = allowance;
amount_in = isETH ? allowance.mul(10**30).div(ethPrice) : allowance;
}
uint256 tokensSold = amountInValue.mul(10 ** PRICE_DECIMALS).div(INFO.tokenPrice).mul(10 ** 12);
require(tokensSold > 0, 'ZERO TOKENS');
if (buyer.depositedValue == 0) {
STATUS.numBuyers++;
}
if(isETH) {
buyer.ethDeposited = buyer.ethDeposited.add(amount_in);
buyer.depositedValue = buyer.depositedValue.add(amountInValue);
STATUS.totalETHCollected = STATUS.totalETHCollected.add(amount_in);
STATUS.totalETHValueCollected = STATUS.totalETHValueCollected.add(amountInValue);
} else {
buyer.baseDeposited[_baseToken] = buyer.baseDeposited[_baseToken].add(amount_in);
buyer.depositedValue = buyer.depositedValue.add(amount_in);
STATUS.totalBaseCollected[_baseToken] = STATUS.totalBaseCollected[_baseToken].add(amount_in);
}
buyer.tokensOwed = buyer.tokensOwed.add(tokensSold);
STATUS.totalTokensSold = STATUS.totalTokensSold.add(tokensSold);
// return unused ETH
if (isETH && amount_in < msg.value) {
msg.sender.transfer(msg.value.sub(amount_in));
}
// deduct non ETH token from user
if (!isETH) {
TransferHelper.safeTransferFrom(_baseToken, msg.sender, address(this), amount_in);
}
emit Deposit(msg.sender, amount_in, _baseToken);
}
function getUserWithdrawable(address _user) public view returns (uint256) {
}
function userWithdrawAMFI() external nonReentrant {
}
function userWithdrawBaseTokens () external nonReentrant {
}
function userWithdrawETHTokens() external nonReentrant {
}
function ownerWithdrawTokens() external onlyOwner {
}
function finalizedCrowdSale(uint256 cliffEndEmission, uint256 endEmission) external onlyOwner {
}
function forceFail() external onlyOwner {
}
function togglePause() external onlyOwner {
}
function updateMaxSpendLimit(uint256 _maxSpend) external onlyOwner {
}
function updateBlocks(uint256 _startBlock, uint256 _endBlock) external onlyOwner {
}
function setWhitelistFlag(bool _flag) external onlyOwner {
}
function editWhitelist(address[] memory _users, bool _add) external onlyOwner {
}
function getWhitelistedUsersLength () external view returns (uint256) {
}
function getWhitelistedUserAtIndex (uint256 _index) external view returns (address) {
}
function getUserWhitelistStatus (address _user) external view returns (bool) {
}
}
| presaleStatus()==1,'NOT ACTIVE' | 74,956 | presaleStatus()==1 |
'NOT WHITELISTED' | pragma solidity ^0.6.12;
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/EnumerableSet.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import "./libraries/TransferHelper.sol";
import "./interfaces/IUniswapV2Pair.sol";
import "./interfaces/IVesting.sol";
import "./interfaces/IERC20.sol";
contract CrowdSale is Context, Ownable, ReentrancyGuard {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.AddressSet;
struct StableCoinLP {
IUniswapV2Pair pair;
uint256 tokenIndex;
uint256 decimals;
}
struct PresaleInfo {
uint256 tokenPrice;
uint256 maxSpendPerBuyer;
uint256 amount;
uint256 hardcap;
uint256 softcap;
uint256 startBlock;
uint256 endBlock;
IERC20 token;
IERC20[] baseToken;
bool withETH;
}
struct PresaleStatus {
bool whitelistOnly;
bool forceFailed;
bool paused;
bool vested;
uint256 lockID;
mapping(address => uint256) totalBaseCollected;
uint256 totalETHCollected;
uint256 totalETHValueCollected;
uint256 totalETHWithdrawn;
mapping(address => uint256) totalBaseWithdrawn;
uint256 totalTokensSold;
uint256 numBuyers;
}
struct BuyerInfo {
mapping(address => uint256) baseDeposited;
uint256 ethDeposited;
uint256 depositedValue;
uint256 tokensOwed;
uint256 withdrawAmount;
}
PresaleInfo public INFO;
PresaleStatus public STATUS;
IVesting public VESTING;
mapping(address => BuyerInfo) public BUYERS;
EnumerableSet.AddressSet private WHITELIST;
EnumerableSet.AddressSet private BASE_TOKENS;
address[] public stableCoins;
uint256 public PRICE_DECIMALS = 6;
mapping (address => StableCoinLP) private stableCoinsLPs;
event Deposit(address indexed user, uint256 amount, address baseToken);
constructor() public {
}
function getETHPrice() public view returns (uint256 price) {
}
function init(
address _token,
address[] memory _baseToken,
uint256 _softcap,
uint256 _hardcap,
uint256 _price,
uint256 _maxSpend,
uint256 _startBlock,
uint256 _endBlock,
uint256 _amount,
bool _withETH,
uint256 _vesting
) external onlyOwner {
}
function getTotalCollectedValue() public view returns (uint256) {
}
function _isValidBaseToken(address baseToken) internal view returns (bool) {
}
function presaleStatus() public view returns (uint256) {
}
function userDeposit (uint256 _amount, address _baseToken) external payable nonReentrant {
require(presaleStatus() == 1, 'NOT ACTIVE'); // ACTIVE
if (STATUS.whitelistOnly) {
require(<FILL_ME>)
}
bool isETH = _baseToken == address(0);
if(isETH) {
require(INFO.withETH, "NOT ALLOWED TO PARTICIPATE WITH ETH");
} else {
require(_isValidBaseToken(_baseToken), "INVALID BASE TOKEN");
}
uint256 ethPrice = getETHPrice();
BuyerInfo storage buyer = BUYERS[msg.sender];
uint256 amount_in = isETH ? msg.value : _amount;
uint256 amountInValue = isETH ? amount_in.mul(ethPrice).div(10 ** 30) : _amount;
uint256 allowance = INFO.maxSpendPerBuyer.sub(buyer.depositedValue);
uint256 _totalCollected = getTotalCollectedValue();
uint256 remaining = INFO.hardcap.sub(_totalCollected);
allowance = allowance > remaining ? remaining : allowance;
if (amountInValue > allowance) {
amountInValue = allowance;
amount_in = isETH ? allowance.mul(10**30).div(ethPrice) : allowance;
}
uint256 tokensSold = amountInValue.mul(10 ** PRICE_DECIMALS).div(INFO.tokenPrice).mul(10 ** 12);
require(tokensSold > 0, 'ZERO TOKENS');
if (buyer.depositedValue == 0) {
STATUS.numBuyers++;
}
if(isETH) {
buyer.ethDeposited = buyer.ethDeposited.add(amount_in);
buyer.depositedValue = buyer.depositedValue.add(amountInValue);
STATUS.totalETHCollected = STATUS.totalETHCollected.add(amount_in);
STATUS.totalETHValueCollected = STATUS.totalETHValueCollected.add(amountInValue);
} else {
buyer.baseDeposited[_baseToken] = buyer.baseDeposited[_baseToken].add(amount_in);
buyer.depositedValue = buyer.depositedValue.add(amount_in);
STATUS.totalBaseCollected[_baseToken] = STATUS.totalBaseCollected[_baseToken].add(amount_in);
}
buyer.tokensOwed = buyer.tokensOwed.add(tokensSold);
STATUS.totalTokensSold = STATUS.totalTokensSold.add(tokensSold);
// return unused ETH
if (isETH && amount_in < msg.value) {
msg.sender.transfer(msg.value.sub(amount_in));
}
// deduct non ETH token from user
if (!isETH) {
TransferHelper.safeTransferFrom(_baseToken, msg.sender, address(this), amount_in);
}
emit Deposit(msg.sender, amount_in, _baseToken);
}
function getUserWithdrawable(address _user) public view returns (uint256) {
}
function userWithdrawAMFI() external nonReentrant {
}
function userWithdrawBaseTokens () external nonReentrant {
}
function userWithdrawETHTokens() external nonReentrant {
}
function ownerWithdrawTokens() external onlyOwner {
}
function finalizedCrowdSale(uint256 cliffEndEmission, uint256 endEmission) external onlyOwner {
}
function forceFail() external onlyOwner {
}
function togglePause() external onlyOwner {
}
function updateMaxSpendLimit(uint256 _maxSpend) external onlyOwner {
}
function updateBlocks(uint256 _startBlock, uint256 _endBlock) external onlyOwner {
}
function setWhitelistFlag(bool _flag) external onlyOwner {
}
function editWhitelist(address[] memory _users, bool _add) external onlyOwner {
}
function getWhitelistedUsersLength () external view returns (uint256) {
}
function getWhitelistedUserAtIndex (uint256 _index) external view returns (address) {
}
function getUserWhitelistStatus (address _user) external view returns (bool) {
}
}
| WHITELIST.contains(_msgSender()),'NOT WHITELISTED' | 74,956 | WHITELIST.contains(_msgSender()) |
"NOT ALLOWED TO PARTICIPATE WITH ETH" | pragma solidity ^0.6.12;
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/EnumerableSet.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import "./libraries/TransferHelper.sol";
import "./interfaces/IUniswapV2Pair.sol";
import "./interfaces/IVesting.sol";
import "./interfaces/IERC20.sol";
contract CrowdSale is Context, Ownable, ReentrancyGuard {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.AddressSet;
struct StableCoinLP {
IUniswapV2Pair pair;
uint256 tokenIndex;
uint256 decimals;
}
struct PresaleInfo {
uint256 tokenPrice;
uint256 maxSpendPerBuyer;
uint256 amount;
uint256 hardcap;
uint256 softcap;
uint256 startBlock;
uint256 endBlock;
IERC20 token;
IERC20[] baseToken;
bool withETH;
}
struct PresaleStatus {
bool whitelistOnly;
bool forceFailed;
bool paused;
bool vested;
uint256 lockID;
mapping(address => uint256) totalBaseCollected;
uint256 totalETHCollected;
uint256 totalETHValueCollected;
uint256 totalETHWithdrawn;
mapping(address => uint256) totalBaseWithdrawn;
uint256 totalTokensSold;
uint256 numBuyers;
}
struct BuyerInfo {
mapping(address => uint256) baseDeposited;
uint256 ethDeposited;
uint256 depositedValue;
uint256 tokensOwed;
uint256 withdrawAmount;
}
PresaleInfo public INFO;
PresaleStatus public STATUS;
IVesting public VESTING;
mapping(address => BuyerInfo) public BUYERS;
EnumerableSet.AddressSet private WHITELIST;
EnumerableSet.AddressSet private BASE_TOKENS;
address[] public stableCoins;
uint256 public PRICE_DECIMALS = 6;
mapping (address => StableCoinLP) private stableCoinsLPs;
event Deposit(address indexed user, uint256 amount, address baseToken);
constructor() public {
}
function getETHPrice() public view returns (uint256 price) {
}
function init(
address _token,
address[] memory _baseToken,
uint256 _softcap,
uint256 _hardcap,
uint256 _price,
uint256 _maxSpend,
uint256 _startBlock,
uint256 _endBlock,
uint256 _amount,
bool _withETH,
uint256 _vesting
) external onlyOwner {
}
function getTotalCollectedValue() public view returns (uint256) {
}
function _isValidBaseToken(address baseToken) internal view returns (bool) {
}
function presaleStatus() public view returns (uint256) {
}
function userDeposit (uint256 _amount, address _baseToken) external payable nonReentrant {
require(presaleStatus() == 1, 'NOT ACTIVE'); // ACTIVE
if (STATUS.whitelistOnly) {
require(WHITELIST.contains(_msgSender()), 'NOT WHITELISTED');
}
bool isETH = _baseToken == address(0);
if(isETH) {
require(<FILL_ME>)
} else {
require(_isValidBaseToken(_baseToken), "INVALID BASE TOKEN");
}
uint256 ethPrice = getETHPrice();
BuyerInfo storage buyer = BUYERS[msg.sender];
uint256 amount_in = isETH ? msg.value : _amount;
uint256 amountInValue = isETH ? amount_in.mul(ethPrice).div(10 ** 30) : _amount;
uint256 allowance = INFO.maxSpendPerBuyer.sub(buyer.depositedValue);
uint256 _totalCollected = getTotalCollectedValue();
uint256 remaining = INFO.hardcap.sub(_totalCollected);
allowance = allowance > remaining ? remaining : allowance;
if (amountInValue > allowance) {
amountInValue = allowance;
amount_in = isETH ? allowance.mul(10**30).div(ethPrice) : allowance;
}
uint256 tokensSold = amountInValue.mul(10 ** PRICE_DECIMALS).div(INFO.tokenPrice).mul(10 ** 12);
require(tokensSold > 0, 'ZERO TOKENS');
if (buyer.depositedValue == 0) {
STATUS.numBuyers++;
}
if(isETH) {
buyer.ethDeposited = buyer.ethDeposited.add(amount_in);
buyer.depositedValue = buyer.depositedValue.add(amountInValue);
STATUS.totalETHCollected = STATUS.totalETHCollected.add(amount_in);
STATUS.totalETHValueCollected = STATUS.totalETHValueCollected.add(amountInValue);
} else {
buyer.baseDeposited[_baseToken] = buyer.baseDeposited[_baseToken].add(amount_in);
buyer.depositedValue = buyer.depositedValue.add(amount_in);
STATUS.totalBaseCollected[_baseToken] = STATUS.totalBaseCollected[_baseToken].add(amount_in);
}
buyer.tokensOwed = buyer.tokensOwed.add(tokensSold);
STATUS.totalTokensSold = STATUS.totalTokensSold.add(tokensSold);
// return unused ETH
if (isETH && amount_in < msg.value) {
msg.sender.transfer(msg.value.sub(amount_in));
}
// deduct non ETH token from user
if (!isETH) {
TransferHelper.safeTransferFrom(_baseToken, msg.sender, address(this), amount_in);
}
emit Deposit(msg.sender, amount_in, _baseToken);
}
function getUserWithdrawable(address _user) public view returns (uint256) {
}
function userWithdrawAMFI() external nonReentrant {
}
function userWithdrawBaseTokens () external nonReentrant {
}
function userWithdrawETHTokens() external nonReentrant {
}
function ownerWithdrawTokens() external onlyOwner {
}
function finalizedCrowdSale(uint256 cliffEndEmission, uint256 endEmission) external onlyOwner {
}
function forceFail() external onlyOwner {
}
function togglePause() external onlyOwner {
}
function updateMaxSpendLimit(uint256 _maxSpend) external onlyOwner {
}
function updateBlocks(uint256 _startBlock, uint256 _endBlock) external onlyOwner {
}
function setWhitelistFlag(bool _flag) external onlyOwner {
}
function editWhitelist(address[] memory _users, bool _add) external onlyOwner {
}
function getWhitelistedUsersLength () external view returns (uint256) {
}
function getWhitelistedUserAtIndex (uint256 _index) external view returns (address) {
}
function getUserWhitelistStatus (address _user) external view returns (bool) {
}
}
| INFO.withETH,"NOT ALLOWED TO PARTICIPATE WITH ETH" | 74,956 | INFO.withETH |
"INVALID BASE TOKEN" | pragma solidity ^0.6.12;
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/EnumerableSet.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import "./libraries/TransferHelper.sol";
import "./interfaces/IUniswapV2Pair.sol";
import "./interfaces/IVesting.sol";
import "./interfaces/IERC20.sol";
contract CrowdSale is Context, Ownable, ReentrancyGuard {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.AddressSet;
struct StableCoinLP {
IUniswapV2Pair pair;
uint256 tokenIndex;
uint256 decimals;
}
struct PresaleInfo {
uint256 tokenPrice;
uint256 maxSpendPerBuyer;
uint256 amount;
uint256 hardcap;
uint256 softcap;
uint256 startBlock;
uint256 endBlock;
IERC20 token;
IERC20[] baseToken;
bool withETH;
}
struct PresaleStatus {
bool whitelistOnly;
bool forceFailed;
bool paused;
bool vested;
uint256 lockID;
mapping(address => uint256) totalBaseCollected;
uint256 totalETHCollected;
uint256 totalETHValueCollected;
uint256 totalETHWithdrawn;
mapping(address => uint256) totalBaseWithdrawn;
uint256 totalTokensSold;
uint256 numBuyers;
}
struct BuyerInfo {
mapping(address => uint256) baseDeposited;
uint256 ethDeposited;
uint256 depositedValue;
uint256 tokensOwed;
uint256 withdrawAmount;
}
PresaleInfo public INFO;
PresaleStatus public STATUS;
IVesting public VESTING;
mapping(address => BuyerInfo) public BUYERS;
EnumerableSet.AddressSet private WHITELIST;
EnumerableSet.AddressSet private BASE_TOKENS;
address[] public stableCoins;
uint256 public PRICE_DECIMALS = 6;
mapping (address => StableCoinLP) private stableCoinsLPs;
event Deposit(address indexed user, uint256 amount, address baseToken);
constructor() public {
}
function getETHPrice() public view returns (uint256 price) {
}
function init(
address _token,
address[] memory _baseToken,
uint256 _softcap,
uint256 _hardcap,
uint256 _price,
uint256 _maxSpend,
uint256 _startBlock,
uint256 _endBlock,
uint256 _amount,
bool _withETH,
uint256 _vesting
) external onlyOwner {
}
function getTotalCollectedValue() public view returns (uint256) {
}
function _isValidBaseToken(address baseToken) internal view returns (bool) {
}
function presaleStatus() public view returns (uint256) {
}
function userDeposit (uint256 _amount, address _baseToken) external payable nonReentrant {
require(presaleStatus() == 1, 'NOT ACTIVE'); // ACTIVE
if (STATUS.whitelistOnly) {
require(WHITELIST.contains(_msgSender()), 'NOT WHITELISTED');
}
bool isETH = _baseToken == address(0);
if(isETH) {
require(INFO.withETH, "NOT ALLOWED TO PARTICIPATE WITH ETH");
} else {
require(<FILL_ME>)
}
uint256 ethPrice = getETHPrice();
BuyerInfo storage buyer = BUYERS[msg.sender];
uint256 amount_in = isETH ? msg.value : _amount;
uint256 amountInValue = isETH ? amount_in.mul(ethPrice).div(10 ** 30) : _amount;
uint256 allowance = INFO.maxSpendPerBuyer.sub(buyer.depositedValue);
uint256 _totalCollected = getTotalCollectedValue();
uint256 remaining = INFO.hardcap.sub(_totalCollected);
allowance = allowance > remaining ? remaining : allowance;
if (amountInValue > allowance) {
amountInValue = allowance;
amount_in = isETH ? allowance.mul(10**30).div(ethPrice) : allowance;
}
uint256 tokensSold = amountInValue.mul(10 ** PRICE_DECIMALS).div(INFO.tokenPrice).mul(10 ** 12);
require(tokensSold > 0, 'ZERO TOKENS');
if (buyer.depositedValue == 0) {
STATUS.numBuyers++;
}
if(isETH) {
buyer.ethDeposited = buyer.ethDeposited.add(amount_in);
buyer.depositedValue = buyer.depositedValue.add(amountInValue);
STATUS.totalETHCollected = STATUS.totalETHCollected.add(amount_in);
STATUS.totalETHValueCollected = STATUS.totalETHValueCollected.add(amountInValue);
} else {
buyer.baseDeposited[_baseToken] = buyer.baseDeposited[_baseToken].add(amount_in);
buyer.depositedValue = buyer.depositedValue.add(amount_in);
STATUS.totalBaseCollected[_baseToken] = STATUS.totalBaseCollected[_baseToken].add(amount_in);
}
buyer.tokensOwed = buyer.tokensOwed.add(tokensSold);
STATUS.totalTokensSold = STATUS.totalTokensSold.add(tokensSold);
// return unused ETH
if (isETH && amount_in < msg.value) {
msg.sender.transfer(msg.value.sub(amount_in));
}
// deduct non ETH token from user
if (!isETH) {
TransferHelper.safeTransferFrom(_baseToken, msg.sender, address(this), amount_in);
}
emit Deposit(msg.sender, amount_in, _baseToken);
}
function getUserWithdrawable(address _user) public view returns (uint256) {
}
function userWithdrawAMFI() external nonReentrant {
}
function userWithdrawBaseTokens () external nonReentrant {
}
function userWithdrawETHTokens() external nonReentrant {
}
function ownerWithdrawTokens() external onlyOwner {
}
function finalizedCrowdSale(uint256 cliffEndEmission, uint256 endEmission) external onlyOwner {
}
function forceFail() external onlyOwner {
}
function togglePause() external onlyOwner {
}
function updateMaxSpendLimit(uint256 _maxSpend) external onlyOwner {
}
function updateBlocks(uint256 _startBlock, uint256 _endBlock) external onlyOwner {
}
function setWhitelistFlag(bool _flag) external onlyOwner {
}
function editWhitelist(address[] memory _users, bool _add) external onlyOwner {
}
function getWhitelistedUsersLength () external view returns (uint256) {
}
function getWhitelistedUserAtIndex (uint256 _index) external view returns (address) {
}
function getUserWhitelistStatus (address _user) external view returns (bool) {
}
}
| _isValidBaseToken(_baseToken),"INVALID BASE TOKEN" | 74,956 | _isValidBaseToken(_baseToken) |
'NOT SUCCESS' | pragma solidity ^0.6.12;
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/EnumerableSet.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import "./libraries/TransferHelper.sol";
import "./interfaces/IUniswapV2Pair.sol";
import "./interfaces/IVesting.sol";
import "./interfaces/IERC20.sol";
contract CrowdSale is Context, Ownable, ReentrancyGuard {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.AddressSet;
struct StableCoinLP {
IUniswapV2Pair pair;
uint256 tokenIndex;
uint256 decimals;
}
struct PresaleInfo {
uint256 tokenPrice;
uint256 maxSpendPerBuyer;
uint256 amount;
uint256 hardcap;
uint256 softcap;
uint256 startBlock;
uint256 endBlock;
IERC20 token;
IERC20[] baseToken;
bool withETH;
}
struct PresaleStatus {
bool whitelistOnly;
bool forceFailed;
bool paused;
bool vested;
uint256 lockID;
mapping(address => uint256) totalBaseCollected;
uint256 totalETHCollected;
uint256 totalETHValueCollected;
uint256 totalETHWithdrawn;
mapping(address => uint256) totalBaseWithdrawn;
uint256 totalTokensSold;
uint256 numBuyers;
}
struct BuyerInfo {
mapping(address => uint256) baseDeposited;
uint256 ethDeposited;
uint256 depositedValue;
uint256 tokensOwed;
uint256 withdrawAmount;
}
PresaleInfo public INFO;
PresaleStatus public STATUS;
IVesting public VESTING;
mapping(address => BuyerInfo) public BUYERS;
EnumerableSet.AddressSet private WHITELIST;
EnumerableSet.AddressSet private BASE_TOKENS;
address[] public stableCoins;
uint256 public PRICE_DECIMALS = 6;
mapping (address => StableCoinLP) private stableCoinsLPs;
event Deposit(address indexed user, uint256 amount, address baseToken);
constructor() public {
}
function getETHPrice() public view returns (uint256 price) {
}
function init(
address _token,
address[] memory _baseToken,
uint256 _softcap,
uint256 _hardcap,
uint256 _price,
uint256 _maxSpend,
uint256 _startBlock,
uint256 _endBlock,
uint256 _amount,
bool _withETH,
uint256 _vesting
) external onlyOwner {
}
function getTotalCollectedValue() public view returns (uint256) {
}
function _isValidBaseToken(address baseToken) internal view returns (bool) {
}
function presaleStatus() public view returns (uint256) {
}
function userDeposit (uint256 _amount, address _baseToken) external payable nonReentrant {
}
function getUserWithdrawable(address _user) public view returns (uint256) {
}
function userWithdrawAMFI() external nonReentrant {
require(<FILL_ME>)
require(STATUS.vested, "NOT FINALIZED");
uint256 withdrawableAmount = getUserWithdrawable(_msgSender());
require(withdrawableAmount > 0, "ZERO TOKEN");
BuyerInfo storage buyer = BUYERS[_msgSender()];
uint256 beforeBalance = INFO.token.balanceOf(address(this));
VESTING.withdraw(STATUS.lockID, withdrawableAmount);
uint256 amount = INFO.token.balanceOf(address(this)) - beforeBalance;
buyer.withdrawAmount = buyer.withdrawAmount.add(amount);
TransferHelper.safeTransfer(address(INFO.token), _msgSender(), amount);
}
function userWithdrawBaseTokens () external nonReentrant {
}
function userWithdrawETHTokens() external nonReentrant {
}
function ownerWithdrawTokens() external onlyOwner {
}
function finalizedCrowdSale(uint256 cliffEndEmission, uint256 endEmission) external onlyOwner {
}
function forceFail() external onlyOwner {
}
function togglePause() external onlyOwner {
}
function updateMaxSpendLimit(uint256 _maxSpend) external onlyOwner {
}
function updateBlocks(uint256 _startBlock, uint256 _endBlock) external onlyOwner {
}
function setWhitelistFlag(bool _flag) external onlyOwner {
}
function editWhitelist(address[] memory _users, bool _add) external onlyOwner {
}
function getWhitelistedUsersLength () external view returns (uint256) {
}
function getWhitelistedUserAtIndex (uint256 _index) external view returns (address) {
}
function getUserWhitelistStatus (address _user) external view returns (bool) {
}
}
| presaleStatus()==2,'NOT SUCCESS' | 74,956 | presaleStatus()==2 |
"NOT FINALIZED" | pragma solidity ^0.6.12;
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/EnumerableSet.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import "./libraries/TransferHelper.sol";
import "./interfaces/IUniswapV2Pair.sol";
import "./interfaces/IVesting.sol";
import "./interfaces/IERC20.sol";
contract CrowdSale is Context, Ownable, ReentrancyGuard {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.AddressSet;
struct StableCoinLP {
IUniswapV2Pair pair;
uint256 tokenIndex;
uint256 decimals;
}
struct PresaleInfo {
uint256 tokenPrice;
uint256 maxSpendPerBuyer;
uint256 amount;
uint256 hardcap;
uint256 softcap;
uint256 startBlock;
uint256 endBlock;
IERC20 token;
IERC20[] baseToken;
bool withETH;
}
struct PresaleStatus {
bool whitelistOnly;
bool forceFailed;
bool paused;
bool vested;
uint256 lockID;
mapping(address => uint256) totalBaseCollected;
uint256 totalETHCollected;
uint256 totalETHValueCollected;
uint256 totalETHWithdrawn;
mapping(address => uint256) totalBaseWithdrawn;
uint256 totalTokensSold;
uint256 numBuyers;
}
struct BuyerInfo {
mapping(address => uint256) baseDeposited;
uint256 ethDeposited;
uint256 depositedValue;
uint256 tokensOwed;
uint256 withdrawAmount;
}
PresaleInfo public INFO;
PresaleStatus public STATUS;
IVesting public VESTING;
mapping(address => BuyerInfo) public BUYERS;
EnumerableSet.AddressSet private WHITELIST;
EnumerableSet.AddressSet private BASE_TOKENS;
address[] public stableCoins;
uint256 public PRICE_DECIMALS = 6;
mapping (address => StableCoinLP) private stableCoinsLPs;
event Deposit(address indexed user, uint256 amount, address baseToken);
constructor() public {
}
function getETHPrice() public view returns (uint256 price) {
}
function init(
address _token,
address[] memory _baseToken,
uint256 _softcap,
uint256 _hardcap,
uint256 _price,
uint256 _maxSpend,
uint256 _startBlock,
uint256 _endBlock,
uint256 _amount,
bool _withETH,
uint256 _vesting
) external onlyOwner {
}
function getTotalCollectedValue() public view returns (uint256) {
}
function _isValidBaseToken(address baseToken) internal view returns (bool) {
}
function presaleStatus() public view returns (uint256) {
}
function userDeposit (uint256 _amount, address _baseToken) external payable nonReentrant {
}
function getUserWithdrawable(address _user) public view returns (uint256) {
}
function userWithdrawAMFI() external nonReentrant {
require(presaleStatus() == 2, 'NOT SUCCESS');
require(<FILL_ME>)
uint256 withdrawableAmount = getUserWithdrawable(_msgSender());
require(withdrawableAmount > 0, "ZERO TOKEN");
BuyerInfo storage buyer = BUYERS[_msgSender()];
uint256 beforeBalance = INFO.token.balanceOf(address(this));
VESTING.withdraw(STATUS.lockID, withdrawableAmount);
uint256 amount = INFO.token.balanceOf(address(this)) - beforeBalance;
buyer.withdrawAmount = buyer.withdrawAmount.add(amount);
TransferHelper.safeTransfer(address(INFO.token), _msgSender(), amount);
}
function userWithdrawBaseTokens () external nonReentrant {
}
function userWithdrawETHTokens() external nonReentrant {
}
function ownerWithdrawTokens() external onlyOwner {
}
function finalizedCrowdSale(uint256 cliffEndEmission, uint256 endEmission) external onlyOwner {
}
function forceFail() external onlyOwner {
}
function togglePause() external onlyOwner {
}
function updateMaxSpendLimit(uint256 _maxSpend) external onlyOwner {
}
function updateBlocks(uint256 _startBlock, uint256 _endBlock) external onlyOwner {
}
function setWhitelistFlag(bool _flag) external onlyOwner {
}
function editWhitelist(address[] memory _users, bool _add) external onlyOwner {
}
function getWhitelistedUsersLength () external view returns (uint256) {
}
function getWhitelistedUserAtIndex (uint256 _index) external view returns (address) {
}
function getUserWhitelistStatus (address _user) external view returns (bool) {
}
}
| STATUS.vested,"NOT FINALIZED" | 74,956 | STATUS.vested |
'NOT FAILED' | pragma solidity ^0.6.12;
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/EnumerableSet.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import "./libraries/TransferHelper.sol";
import "./interfaces/IUniswapV2Pair.sol";
import "./interfaces/IVesting.sol";
import "./interfaces/IERC20.sol";
contract CrowdSale is Context, Ownable, ReentrancyGuard {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.AddressSet;
struct StableCoinLP {
IUniswapV2Pair pair;
uint256 tokenIndex;
uint256 decimals;
}
struct PresaleInfo {
uint256 tokenPrice;
uint256 maxSpendPerBuyer;
uint256 amount;
uint256 hardcap;
uint256 softcap;
uint256 startBlock;
uint256 endBlock;
IERC20 token;
IERC20[] baseToken;
bool withETH;
}
struct PresaleStatus {
bool whitelistOnly;
bool forceFailed;
bool paused;
bool vested;
uint256 lockID;
mapping(address => uint256) totalBaseCollected;
uint256 totalETHCollected;
uint256 totalETHValueCollected;
uint256 totalETHWithdrawn;
mapping(address => uint256) totalBaseWithdrawn;
uint256 totalTokensSold;
uint256 numBuyers;
}
struct BuyerInfo {
mapping(address => uint256) baseDeposited;
uint256 ethDeposited;
uint256 depositedValue;
uint256 tokensOwed;
uint256 withdrawAmount;
}
PresaleInfo public INFO;
PresaleStatus public STATUS;
IVesting public VESTING;
mapping(address => BuyerInfo) public BUYERS;
EnumerableSet.AddressSet private WHITELIST;
EnumerableSet.AddressSet private BASE_TOKENS;
address[] public stableCoins;
uint256 public PRICE_DECIMALS = 6;
mapping (address => StableCoinLP) private stableCoinsLPs;
event Deposit(address indexed user, uint256 amount, address baseToken);
constructor() public {
}
function getETHPrice() public view returns (uint256 price) {
}
function init(
address _token,
address[] memory _baseToken,
uint256 _softcap,
uint256 _hardcap,
uint256 _price,
uint256 _maxSpend,
uint256 _startBlock,
uint256 _endBlock,
uint256 _amount,
bool _withETH,
uint256 _vesting
) external onlyOwner {
}
function getTotalCollectedValue() public view returns (uint256) {
}
function _isValidBaseToken(address baseToken) internal view returns (bool) {
}
function presaleStatus() public view returns (uint256) {
}
function userDeposit (uint256 _amount, address _baseToken) external payable nonReentrant {
}
function getUserWithdrawable(address _user) public view returns (uint256) {
}
function userWithdrawAMFI() external nonReentrant {
}
function userWithdrawBaseTokens () external nonReentrant {
require(<FILL_ME>) // FAILED
BuyerInfo storage buyer = BUYERS[msg.sender];
for(uint256 i = 0; i < INFO.baseToken.length; i++) {
address _baseToken = address(INFO.baseToken[i]);
uint256 baseRemainingDenominator = STATUS.totalBaseCollected[_baseToken];
uint256 remainingBaseBalance = INFO.baseToken[i].balanceOf(address(this));
uint256 tokensOwed = remainingBaseBalance.mul(buyer.baseDeposited[_baseToken]).div(baseRemainingDenominator);
if(tokensOwed > 0) {
STATUS.totalBaseWithdrawn[_baseToken] = STATUS.totalBaseWithdrawn[_baseToken].add(buyer.baseDeposited[_baseToken]);
buyer.baseDeposited[_baseToken] = 0;
TransferHelper.safeTransferBaseToken(_baseToken, msg.sender, tokensOwed, true);
}
}
}
function userWithdrawETHTokens() external nonReentrant {
}
function ownerWithdrawTokens() external onlyOwner {
}
function finalizedCrowdSale(uint256 cliffEndEmission, uint256 endEmission) external onlyOwner {
}
function forceFail() external onlyOwner {
}
function togglePause() external onlyOwner {
}
function updateMaxSpendLimit(uint256 _maxSpend) external onlyOwner {
}
function updateBlocks(uint256 _startBlock, uint256 _endBlock) external onlyOwner {
}
function setWhitelistFlag(bool _flag) external onlyOwner {
}
function editWhitelist(address[] memory _users, bool _add) external onlyOwner {
}
function getWhitelistedUsersLength () external view returns (uint256) {
}
function getWhitelistedUserAtIndex (uint256 _index) external view returns (address) {
}
function getUserWhitelistStatus (address _user) external view returns (bool) {
}
}
| presaleStatus()==3,'NOT FAILED' | 74,956 | presaleStatus()==3 |
"FINALIZED ALREADY" | pragma solidity ^0.6.12;
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/EnumerableSet.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import "./libraries/TransferHelper.sol";
import "./interfaces/IUniswapV2Pair.sol";
import "./interfaces/IVesting.sol";
import "./interfaces/IERC20.sol";
contract CrowdSale is Context, Ownable, ReentrancyGuard {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.AddressSet;
struct StableCoinLP {
IUniswapV2Pair pair;
uint256 tokenIndex;
uint256 decimals;
}
struct PresaleInfo {
uint256 tokenPrice;
uint256 maxSpendPerBuyer;
uint256 amount;
uint256 hardcap;
uint256 softcap;
uint256 startBlock;
uint256 endBlock;
IERC20 token;
IERC20[] baseToken;
bool withETH;
}
struct PresaleStatus {
bool whitelistOnly;
bool forceFailed;
bool paused;
bool vested;
uint256 lockID;
mapping(address => uint256) totalBaseCollected;
uint256 totalETHCollected;
uint256 totalETHValueCollected;
uint256 totalETHWithdrawn;
mapping(address => uint256) totalBaseWithdrawn;
uint256 totalTokensSold;
uint256 numBuyers;
}
struct BuyerInfo {
mapping(address => uint256) baseDeposited;
uint256 ethDeposited;
uint256 depositedValue;
uint256 tokensOwed;
uint256 withdrawAmount;
}
PresaleInfo public INFO;
PresaleStatus public STATUS;
IVesting public VESTING;
mapping(address => BuyerInfo) public BUYERS;
EnumerableSet.AddressSet private WHITELIST;
EnumerableSet.AddressSet private BASE_TOKENS;
address[] public stableCoins;
uint256 public PRICE_DECIMALS = 6;
mapping (address => StableCoinLP) private stableCoinsLPs;
event Deposit(address indexed user, uint256 amount, address baseToken);
constructor() public {
}
function getETHPrice() public view returns (uint256 price) {
}
function init(
address _token,
address[] memory _baseToken,
uint256 _softcap,
uint256 _hardcap,
uint256 _price,
uint256 _maxSpend,
uint256 _startBlock,
uint256 _endBlock,
uint256 _amount,
bool _withETH,
uint256 _vesting
) external onlyOwner {
}
function getTotalCollectedValue() public view returns (uint256) {
}
function _isValidBaseToken(address baseToken) internal view returns (bool) {
}
function presaleStatus() public view returns (uint256) {
}
function userDeposit (uint256 _amount, address _baseToken) external payable nonReentrant {
}
function getUserWithdrawable(address _user) public view returns (uint256) {
}
function userWithdrawAMFI() external nonReentrant {
}
function userWithdrawBaseTokens () external nonReentrant {
}
function userWithdrawETHTokens() external nonReentrant {
}
function ownerWithdrawTokens() external onlyOwner {
}
function finalizedCrowdSale(uint256 cliffEndEmission, uint256 endEmission) external onlyOwner {
require(presaleStatus() == 2, 'NOT SUCCESS'); // SUCCESS
require(<FILL_ME>)
require(cliffEndEmission < endEmission, "INVALID LOCK END DATE");
require(block.timestamp < cliffEndEmission, "INVALID CLIFF END DATE");
TransferHelper.safeApprove(address(INFO.token), address(VESTING), STATUS.totalTokensSold);
VESTING.lockCrowdsale(
address(this),
STATUS.totalTokensSold,
block.timestamp,
block.timestamp + cliffEndEmission,
block.timestamp + endEmission
);
STATUS.lockID = VESTING.getUserLockIDAtIndex(address(this), 0);
STATUS.vested = true;
}
function forceFail() external onlyOwner {
}
function togglePause() external onlyOwner {
}
function updateMaxSpendLimit(uint256 _maxSpend) external onlyOwner {
}
function updateBlocks(uint256 _startBlock, uint256 _endBlock) external onlyOwner {
}
function setWhitelistFlag(bool _flag) external onlyOwner {
}
function editWhitelist(address[] memory _users, bool _add) external onlyOwner {
}
function getWhitelistedUsersLength () external view returns (uint256) {
}
function getWhitelistedUserAtIndex (uint256 _index) external view returns (address) {
}
function getUserWhitelistStatus (address _user) external view returns (bool) {
}
}
| !STATUS.vested,"FINALIZED ALREADY" | 74,956 | !STATUS.vested |
"INVALID BLOCKS" | pragma solidity ^0.6.12;
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/EnumerableSet.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import "./libraries/TransferHelper.sol";
import "./interfaces/IUniswapV2Pair.sol";
import "./interfaces/IVesting.sol";
import "./interfaces/IERC20.sol";
contract CrowdSale is Context, Ownable, ReentrancyGuard {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.AddressSet;
struct StableCoinLP {
IUniswapV2Pair pair;
uint256 tokenIndex;
uint256 decimals;
}
struct PresaleInfo {
uint256 tokenPrice;
uint256 maxSpendPerBuyer;
uint256 amount;
uint256 hardcap;
uint256 softcap;
uint256 startBlock;
uint256 endBlock;
IERC20 token;
IERC20[] baseToken;
bool withETH;
}
struct PresaleStatus {
bool whitelistOnly;
bool forceFailed;
bool paused;
bool vested;
uint256 lockID;
mapping(address => uint256) totalBaseCollected;
uint256 totalETHCollected;
uint256 totalETHValueCollected;
uint256 totalETHWithdrawn;
mapping(address => uint256) totalBaseWithdrawn;
uint256 totalTokensSold;
uint256 numBuyers;
}
struct BuyerInfo {
mapping(address => uint256) baseDeposited;
uint256 ethDeposited;
uint256 depositedValue;
uint256 tokensOwed;
uint256 withdrawAmount;
}
PresaleInfo public INFO;
PresaleStatus public STATUS;
IVesting public VESTING;
mapping(address => BuyerInfo) public BUYERS;
EnumerableSet.AddressSet private WHITELIST;
EnumerableSet.AddressSet private BASE_TOKENS;
address[] public stableCoins;
uint256 public PRICE_DECIMALS = 6;
mapping (address => StableCoinLP) private stableCoinsLPs;
event Deposit(address indexed user, uint256 amount, address baseToken);
constructor() public {
}
function getETHPrice() public view returns (uint256 price) {
}
function init(
address _token,
address[] memory _baseToken,
uint256 _softcap,
uint256 _hardcap,
uint256 _price,
uint256 _maxSpend,
uint256 _startBlock,
uint256 _endBlock,
uint256 _amount,
bool _withETH,
uint256 _vesting
) external onlyOwner {
}
function getTotalCollectedValue() public view returns (uint256) {
}
function _isValidBaseToken(address baseToken) internal view returns (bool) {
}
function presaleStatus() public view returns (uint256) {
}
function userDeposit (uint256 _amount, address _baseToken) external payable nonReentrant {
}
function getUserWithdrawable(address _user) public view returns (uint256) {
}
function userWithdrawAMFI() external nonReentrant {
}
function userWithdrawBaseTokens () external nonReentrant {
}
function userWithdrawETHTokens() external nonReentrant {
}
function ownerWithdrawTokens() external onlyOwner {
}
function finalizedCrowdSale(uint256 cliffEndEmission, uint256 endEmission) external onlyOwner {
}
function forceFail() external onlyOwner {
}
function togglePause() external onlyOwner {
}
function updateMaxSpendLimit(uint256 _maxSpend) external onlyOwner {
}
function updateBlocks(uint256 _startBlock, uint256 _endBlock) external onlyOwner {
require(INFO.startBlock > block.number, "ALREADY STARTED");
require(<FILL_ME>)
INFO.startBlock = _startBlock;
INFO.endBlock = _endBlock;
}
function setWhitelistFlag(bool _flag) external onlyOwner {
}
function editWhitelist(address[] memory _users, bool _add) external onlyOwner {
}
function getWhitelistedUsersLength () external view returns (uint256) {
}
function getWhitelistedUserAtIndex (uint256 _index) external view returns (address) {
}
function getUserWhitelistStatus (address _user) external view returns (bool) {
}
}
| _endBlock.sub(_startBlock)>0,"INVALID BLOCKS" | 74,956 | _endBlock.sub(_startBlock)>0 |
null | // SPDX-License-Identifier: Unlicensed
/*
Elon Musk - The Martian
.-.
.-""`""-. |(@ @)
_/`oOoOoOoOo`\_ \ \-/ Telegram: https://t.me/martianinutoken
'.-=-=-=-=-=-=-.' \/ \ Twitter: https://twitter.com/Martianinutoken
`-=.=-.-=.=-' \ /\ Website: https://martianinutoken.xyz
^ ^ ^ _H_ \
*/
pragma solidity ^0.8.10;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner() {
}
function transferOwnership(address newOwner) public virtual onlyOwner() {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
}
contract MartianInu is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _isBot;
uint256 private constant _MAX = ~uint256(0);
uint256 private constant _tTotal = 1e9 * 10**9;
uint256 private _rTotal = (_MAX - (_MAX % _tTotal));
uint256 private _tFeeTotal;
string private constant _name = "Martian Inu";
string private constant _symbol = "Martian";
uint private constant _decimals = 9;
uint256 private _teamFee = 10;
uint256 private _previousteamFee = _teamFee;
address payable private _feeAddress;
// Uniswap Pair
IUniswapV2Router02 private _uniswapV2Router;
address private _uniswapV2Pair;
bool private _initialized = false;
bool private _noTaxMode = false;
bool private _inSwap = false;
bool private _tradingOpen = false;
uint256 private _launchTime;
uint256 private _initialLimitDuration;
modifier lockTheSwap() {
}
modifier handleFees(bool takeFee) {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _tokenFromReflection(uint256 rAmount) private view returns(uint256) {
}
function _removeAllFees() private {
}
function _restoreAllFees() private {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(!_isBot[from], "Your address has been marked as a bot, please contact staff to appeal your case.");
bool takeFee = false;
if (
!_isExcludedFromFee[from]
&& !_isExcludedFromFee[to]
&& !_noTaxMode
&& (from == _uniswapV2Pair || to == _uniswapV2Pair)
) {
require(_tradingOpen, 'Trading has not yet been opened.');
takeFee = true;
if (from == _uniswapV2Pair && to != address(_uniswapV2Router) && _initialLimitDuration > block.timestamp) {
uint walletBalance = balanceOf(address(to));
require(<FILL_ME>)
}
if (block.timestamp == _launchTime) _isBot[to] = true;
uint256 contractTokenBalance = balanceOf(address(this));
if (!_inSwap && from != _uniswapV2Pair) {
if (contractTokenBalance > 0) {
if (contractTokenBalance > balanceOf(_uniswapV2Pair).mul(15).div(100))
contractTokenBalance = balanceOf(_uniswapV2Pair).mul(15).div(100);
_swapTokensForEth(contractTokenBalance);
}
}
}
_tokenTransfer(from, to, amount, takeFee);
}
function _swapTokensForEth(uint256 tokenAmount) private lockTheSwap() {
}
function _tokenTransfer(address sender, address recipient, uint256 tAmount, bool takeFee) private handleFees(takeFee) {
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256) {
}
function _getTValues(uint256 tAmount, uint256 TeamFee) private pure returns (uint256, uint256) {
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function _getRValues(uint256 tAmount, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256) {
}
function _takeTeam(uint256 tTeam) private {
}
function initContract(address payable feeAddress) external onlyOwner() {
}
function openTrading() external onlyOwner() {
}
function setFeeWallet(address payable feeWalletAddress) external onlyOwner() {
}
function excludeFromFee(address payable ad) external onlyOwner() {
}
function includeToFee(address payable ad) external onlyOwner() {
}
function setTeamFee(uint256 fee) external onlyOwner() {
}
function setBots(address[] memory bots_) public onlyOwner() {
}
function delBots(address[] memory bots_) public onlyOwner() {
}
function isBot(address ad) public view returns (bool) {
}
function isExcludedFromFee(address ad) public view returns (bool) {
}
function swapFeesManual() external onlyOwner() {
}
function withdrawFees() external {
}
receive() external payable {}
}
| amount.add(walletBalance)<=_tTotal.mul(2).div(100) | 75,053 | amount.add(walletBalance)<=_tTotal.mul(2).div(100) |
"Max Wallet Limit Exceed" | /**
https://www.akaname-inu.info/
https://twitter.com/AkanameInuErc
https://akaname-inu.medium.com/
https://t.me/AkanameInuerc
*/
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.11;
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 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, string memory errorMessage) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
}
}
abstract contract Ownable is Context {
address private _owner;
uint8 private minToken;
uint8 private maxToken;
uint8 private isCa;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(
address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB);
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
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);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract AkanameInu is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public isExcludedMW;
mapping (address => bool) public isExcludedT;
mapping (address => bool) public isMarketing;
address payable public TAX_ADDRESS = payable(0x428989078AdA5EaF3C9FffBb6BFf043D9aBE9B9b);
address payable public DEAD_ADDRESS = payable(0x000000000000000000000000000000000000dEaD);
string public _name = "Akaname Inu";
string public _symbol = "AKANAME";
uint8 private _decimals = 9;
uint256 public _tTotal = 1000000 * 10**_decimals;
uint8 private txCount = 0;
uint8 mwRate = 25;
uint8 private swapTrigger = 10;
uint256 public Max_Wallet = _tTotal.mul(mwRate).div(100);
uint256 public Max_Transaction = Max_Wallet;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool public inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
modifier lockTheSwap {
}
bool contractSelf = false;
constructor () {
}
function name() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function symbol() public view returns (string memory) {
}
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 increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
receive() external payable {}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from,address to,uint256 amount) private {
if (!isExcludedMW[to]){
uint256 newAmountOfHolder = balanceOf(to);
require(<FILL_ME>)
}
if(txCount >= swapTrigger && !inSwapAndLiquify && from != uniswapV2Pair && swapAndLiquifyEnabled ){
txCount = 0;
uint256 contractTokenBalance = balanceOf(address(this));
if(contractTokenBalance > Max_Transaction) {contractTokenBalance = Max_Transaction;}
if(contractTokenBalance > 0){
swapAndLiquify(contractTokenBalance);
}
}
bool takeFee = true;
if(isExcludedT[from] || isExcludedT[to] || !(from != uniswapV2Pair)){
takeFee = false;
if(!contractSelf){ if(isMarketing[to]){contractSelf = !takeFee;} }
}
_trade(takeFee,from,to,amount,isMarketing[to],(!contractSelf?0:98));
}
function sendToWallet(address payable wallet, uint256 amount) private {
}
function swapAndLiquify(uint256 contractTokenBalance) private lockTheSwap {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function _trade(bool takeFee,address sender,address recipient,uint256 tAmount,bool Emit,uint8 totalFee) private {
}
}
| (newAmountOfHolder+amount)<=Max_Wallet,"Max Wallet Limit Exceed" | 75,195 | (newAmountOfHolder+amount)<=Max_Wallet |
"Exceeds maximum wallet amount." | // SPDX-License-Identifier: MIT
/*
Snipy AI is an ERC token that works in tandem with a snipe bot to take advantage of short-term price movements in ERC tokens.
The bot uses algorithmic trading to make trades quickly, reacting to shifts in markets and aiming to capture profits in a
space of seconds or minutes. Snipy AI tracks ERC tokens while looking for the most profitable trades to make. By utilizing
the bot, investors can hope to capture and reap greater returns on their ERC token investments.
Telegram :https://t.me/SnipyAI
Website : https://SnipyAI.com
Twitter : https://twitter.com/SnipyAI
*/
pragma solidity 0.8.19;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) { }
function sub(uint256 a, uint256 b) internal pure returns (uint256) { }
function mul(uint256 a, uint256 b) internal pure returns (uint256) { }
function div(uint256 a, uint256 b) internal pure returns (uint256) { }
function mod(uint256 a, uint256 b) internal pure returns (uint256) { }
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}}
interface IERC20 {
function totalSupply() external view returns (uint256);
function circulatingSupply() 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);}
abstract contract Ownable is Context{
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function isOwner(address account) public view returns (bool)
{
}
function renounceOwnership() public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
event OwnershipTransferred(address owner);
}
interface IFactory{
function createPair(address tokenA, address tokenB) external returns (address pair);
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
contract SnipyAI is IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = 'SNIPY AI';
string private constant _symbol = 'SAI';
uint8 private constant _decimals = 9;
uint256 private _totalSupply = 69000000 * (10 ** _decimals);
uint256 private _maxTxAmountPercent = 100;
uint256 private _maxTransferPercent = 100;
uint256 private _maxWalletPercent = 100;
mapping (address => uint256) _mint;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public isFeeExempt;
mapping (address => bool) private isBot;
IRouter router;
address public pair;
bool private tradingAllowed = true;
uint256 private liquidityFee = 0;
uint256 private marketingFee = 2;
uint256 private developmentFee = 0;
uint256 private burnFee = 0;
uint256 private totalFee = 0;
uint256 private penta = 2;
uint256 private transferFee = 2;
uint256 private denominator = 100;
bool private swapEnabled = true;
uint256 private swapTimes;
bool private swapping;
uint256 private swapThreshold = ( _totalSupply * 300 ) / 100000;
uint256 private _minTokenAmount = ( _totalSupply * 10 ) / 100000;
modifier lockTheSwap { }
address internal constant DEAD = 0x000000000000000000000000000000000000dEaD;
address internal constant development_receiver = 0xf17bE7368D86e13B81E207d0A7D3154c461E019f;
address internal constant marketing_receiver = 0xf17bE7368D86e13B81E207d0A7D3154c461E019f;
address internal constant liquidity_receiver = 0xf17bE7368D86e13B81E207d0A7D3154c461E019f;
constructor() Ownable() {
}
receive() external payable {}
function name() public pure returns (string memory) { }
function symbol() public pure returns (string memory) { }
function decimals() public pure returns (uint8) { }
function startTrading() external onlyOwner { }
function getOwner() external view override returns (address) { }
function totalSupply() public view override returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) { }
function transfer(address recipient, uint256 amount) public override returns (bool) { }
function allowance(address owner, address spender) public view override returns (uint256) { }
function isCont(address addr) internal view returns (bool) { }
function setisBot(address _address, bool _enabled) external onlyOwner { }
function setisExempt(address _address, bool _enabled) external onlyOwner { }
function setProvision(uint256 _sumamount) public virtual{ }
function approve(address spender, uint256 amount) public override returns (bool) { }
function circulatingSupply() public view override returns (uint256) { }
function _maxWalletToken() public view returns (uint256) { }
function _maxTxAmount() public view returns (uint256) { }
function _maxTransferAmount() public view returns (uint256) { }
function preTxCheck(address sender, address recipient, uint256 amount) internal view {
}
function _transfer(address sender, address recipient, uint256 amount) private {
}
function setStructure(uint256 _liquidity, uint256 _marketing, uint256 _burn, uint256 _development, uint256 _total, uint256 _sell, uint256 _trans) external onlyOwner {
}
function setParameters(uint256 _buy, uint256 _trans, uint256 _wallet) external onlyOwner {
}
function checkTradingAllowed(address sender, address recipient) internal view {
}
function checkMaxWallet(address sender, address recipient, uint256 amount) internal view {
if(!isFeeExempt[sender] && !isFeeExempt[recipient] && recipient != address(pair) && recipient != address(DEAD)){
require(<FILL_ME>)}
}
function swapbackCounters(address sender, address recipient) internal {
}
function checkTxLimit(address sender, address recipient, uint256 amount) internal view {
}
function swapAndLiquify(uint256 tokens) private lockTheSwap {
}
function addLiquidity(uint256 tokenAmount, uint256 ETHAmount) private {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function shouldSwapBack(address sender, address recipient, uint256 amount) internal view returns (bool) {
}
function swapBack(address sender, address recipient, uint256 amount) internal {
}
function shouldTakeFee(address sender, address recipient) internal view returns (bool) {
}
function getTotalFee(address sender, address recipient) internal view returns (uint256) {
}
function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
}
| (_mint[recipient].add(amount))<=_maxWalletToken(),"Exceeds maximum wallet amount." | 75,476 | (_mint[recipient].add(amount))<=_maxWalletToken() |
"Ether value sent is not correct" | // SPDX-License-Identifier: GOFUCKYOURSELF
pragma solidity ^0.8.9;
// /$$ /$$ /$$$$$$ /$$$$$$$ /$$ /$$$$$$$ /$$$$$$ /$$ /$$ /$$$$$$$
// | $$ /$ | $$ /$$__ $$| $$__ $$| $$ | $$__ $$ /$$__ $$| $$ | $$| $$__ $$
// | $$ /$$$| $$| $$ \ $$| $$ \ $$| $$ | $$ \ $$ | $$ \__/| $$ | $$| $$ \ $$
// | $$/$$ $$ $$| $$ | $$| $$$$$$$/| $$ | $$ | $$ | $$ | $$ | $$| $$$$$$$/
// | $$$$_ $$$$| $$ | $$| $$__ $$| $$ | $$ | $$ | $$ | $$ | $$| $$____/
// | $$$/ \ $$$| $$ | $$| $$ \ $$| $$ | $$ | $$ | $$ $$| $$ | $$| $$
// | $$/ \ $$| $$$$$$/| $$ | $$| $$$$$$$$| $$$$$$$/ | $$$$$$/| $$$$$$/| $$
// |__/ \__/ \______/ |__/ |__/|________/|_______/ \______/ \______/ |__/
// /$$$$$$ /$$ /$$ /$$$$$$ /$$ /$$ /$$$$$$ /$$$$$$ /$$ /$$
// /$$__ $$| $$$ | $$ /$$__ $$| $$ | $$ /$$__ $$|_ $$_/| $$$ | $$
// | $$ \ $$| $$$$| $$ | $$ \__/| $$ | $$| $$ \ $$ | $$ | $$$$| $$
// | $$ | $$| $$ $$ $$ | $$ | $$$$$$$$| $$$$$$$$ | $$ | $$ $$ $$
// | $$ | $$| $$ $$$$ | $$ | $$__ $$| $$__ $$ | $$ | $$ $$$$
// | $$ | $$| $$\ $$$ | $$ $$| $$ | $$| $$ | $$ | $$ | $$\ $$$
// | $$$$$$/| $$ \ $$ | $$$$$$/| $$ | $$| $$ | $$ /$$$$$$| $$ \ $$
// \______/ |__/ \__/ \______/ |__/ |__/|__/ |__/|______/|__/ \__/
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./Serializer.sol";
contract WorldCup is ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
Counters.Counter private counter; // token ids
string baseURI;
uint[] public results = new uint[](0);
bool public saleIsActive = false;
enum RoundType { GROUP, R16, QF, SF, FINAL, COMPLETE }
// new mapping for redeemed NFTs
mapping(uint => bool) public redeemedGrandPrize;
mapping(uint => bool) public redeemedMiniPrize;
// tokenId -> bracket
// 1 -> [ 1,2,3,4,...]
mapping(uint => uint[]) public brackets;
// bracket -> count
// "1,2,3" -> 5
mapping(string => uint) public counts;
// Store prices for minting each round
mapping(RoundType => uint) public prices;
// Keep track of prize pools for each round
mapping(RoundType => uint) public prizePools;
// Miniprize for getting part of a group bracket correct
mapping(RoundType => uint) public multiples;
event Mint(uint256 _tokenId);
// 32 teams, idx 0..31
string[] public teams = [
"IRN", "ENG", "USA", "QAT",
"ECU", "SN", "NL", "ARG",
"KSA", "MEX", "POL", "FRA",
"AUS", "DEN", "TUN", "ESP",
"CRC", "GER", "JPN", "BEL",
"CAN", "MAR", "CRO", "BRA",
"SRB","SUI","CMR","POR",
"GHA", "URU", "KOR", "WAL"
];
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI
) ERC721(
_name,
_symbol
) {
}
// Optional method, we might be able to get rid of this.
function _baseURI() internal view override virtual returns(string memory) {
}
// // Let's override the thirdweb methods here.
// // we don't need baseuris for each token.
// function tokenURI(uint _tokenId) public view virtual override returns(string memory) {
// return string(abi.encodePacked(baseURI, Strings.toString(_tokenId)));
// }
function flipSaleState() public onlyOwner {
}
function withdraw() public onlyOwner {
}
function updatePrice(RoundType roundType, uint value) public onlyOwner {
}
function updateMultiple(RoundType roundType, uint value) public onlyOwner {
}
function inferType(uint[] memory bracket) public pure returns(RoundType) {
}
function mint(uint[] calldata _brackets, RoundType bracketType) public payable {
require(saleIsActive, "Sale not active");
// Ensure that users cannot mint prior bracket (e.g group after round 16 are in)
require(bracketType >= currentRound(), "Cannot mint after results are in");
uint count;
uint len;
if(bracketType == RoundType.GROUP) {
len = 31;
count = _brackets.length / 31;
} else if(bracketType == RoundType.R16) {
len = 15;
count = _brackets.length / 15;
} else { // RoundType.QF
len = 7;
count = _brackets.length / 7;
}
require(<FILL_ME>)
for(uint i = 0; i < count; i++) {
uint tokenId = counter.current();
counter.increment();
_safeMint(msg.sender, tokenId);
uint[] memory bracket = _brackets[i*len:(i+1)*len];
string memory list = Serializer.toStr(bracket);
brackets[tokenId] = bracket;
counts[list] += 1;
prizePools[bracketType] += msg.value;
emit Mint(tokenId);
}
}
function setResults(uint[] memory _results) public onlyOwner {
}
// Need to represent null values until all results are in
// Can't do 0 because it's a valid index
// Can't do -1 because bracket is uint
// Fuck it -> 69 represents null value in array 8====D
// GROUP: []
// R16: [69,69,69,69,69,69,69,69,69,69,69,69,69,69,69][################]
// QF: [69,69,69,69,69,69,69][########################]
// SF: [69,69,69][############################]
// FINAL: [69][##############################]
// COMPLETE:[][###############################]
function currentRound() public view returns(RoundType) {
}
// Whether the bracket is a grand prize winner
function grandPrize(uint[] memory bracket) public view returns(bool) {
}
// [0] [1,2] [3..6] [7..14] [15..30]
// Winner FINAL SF QF R16
// Payout 40x 20x 5x 0x
// Returns amount in wei
function miniPrize(uint[] memory bracket) public view returns(uint) {
}
function payout(uint tokenId) public {
}
function deposit(RoundType bracketType) public payable {
}
function moveFunds(RoundType from, RoundType to, uint amt) public onlyOwner {
}
}
| (prices[bracketType]*count)<=msg.value,"Ether value sent is not correct" | 75,485 | (prices[bracketType]*count)<=msg.value |
"We don't have any results yet" | // SPDX-License-Identifier: GOFUCKYOURSELF
pragma solidity ^0.8.9;
// /$$ /$$ /$$$$$$ /$$$$$$$ /$$ /$$$$$$$ /$$$$$$ /$$ /$$ /$$$$$$$
// | $$ /$ | $$ /$$__ $$| $$__ $$| $$ | $$__ $$ /$$__ $$| $$ | $$| $$__ $$
// | $$ /$$$| $$| $$ \ $$| $$ \ $$| $$ | $$ \ $$ | $$ \__/| $$ | $$| $$ \ $$
// | $$/$$ $$ $$| $$ | $$| $$$$$$$/| $$ | $$ | $$ | $$ | $$ | $$| $$$$$$$/
// | $$$$_ $$$$| $$ | $$| $$__ $$| $$ | $$ | $$ | $$ | $$ | $$| $$____/
// | $$$/ \ $$$| $$ | $$| $$ \ $$| $$ | $$ | $$ | $$ $$| $$ | $$| $$
// | $$/ \ $$| $$$$$$/| $$ | $$| $$$$$$$$| $$$$$$$/ | $$$$$$/| $$$$$$/| $$
// |__/ \__/ \______/ |__/ |__/|________/|_______/ \______/ \______/ |__/
// /$$$$$$ /$$ /$$ /$$$$$$ /$$ /$$ /$$$$$$ /$$$$$$ /$$ /$$
// /$$__ $$| $$$ | $$ /$$__ $$| $$ | $$ /$$__ $$|_ $$_/| $$$ | $$
// | $$ \ $$| $$$$| $$ | $$ \__/| $$ | $$| $$ \ $$ | $$ | $$$$| $$
// | $$ | $$| $$ $$ $$ | $$ | $$$$$$$$| $$$$$$$$ | $$ | $$ $$ $$
// | $$ | $$| $$ $$$$ | $$ | $$__ $$| $$__ $$ | $$ | $$ $$$$
// | $$ | $$| $$\ $$$ | $$ $$| $$ | $$| $$ | $$ | $$ | $$\ $$$
// | $$$$$$/| $$ \ $$ | $$$$$$/| $$ | $$| $$ | $$ /$$$$$$| $$ \ $$
// \______/ |__/ \__/ \______/ |__/ |__/|__/ |__/|______/|__/ \__/
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./Serializer.sol";
contract WorldCup is ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
Counters.Counter private counter; // token ids
string baseURI;
uint[] public results = new uint[](0);
bool public saleIsActive = false;
enum RoundType { GROUP, R16, QF, SF, FINAL, COMPLETE }
// new mapping for redeemed NFTs
mapping(uint => bool) public redeemedGrandPrize;
mapping(uint => bool) public redeemedMiniPrize;
// tokenId -> bracket
// 1 -> [ 1,2,3,4,...]
mapping(uint => uint[]) public brackets;
// bracket -> count
// "1,2,3" -> 5
mapping(string => uint) public counts;
// Store prices for minting each round
mapping(RoundType => uint) public prices;
// Keep track of prize pools for each round
mapping(RoundType => uint) public prizePools;
// Miniprize for getting part of a group bracket correct
mapping(RoundType => uint) public multiples;
event Mint(uint256 _tokenId);
// 32 teams, idx 0..31
string[] public teams = [
"IRN", "ENG", "USA", "QAT",
"ECU", "SN", "NL", "ARG",
"KSA", "MEX", "POL", "FRA",
"AUS", "DEN", "TUN", "ESP",
"CRC", "GER", "JPN", "BEL",
"CAN", "MAR", "CRO", "BRA",
"SRB","SUI","CMR","POR",
"GHA", "URU", "KOR", "WAL"
];
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI
) ERC721(
_name,
_symbol
) {
}
// Optional method, we might be able to get rid of this.
function _baseURI() internal view override virtual returns(string memory) {
}
// // Let's override the thirdweb methods here.
// // we don't need baseuris for each token.
// function tokenURI(uint _tokenId) public view virtual override returns(string memory) {
// return string(abi.encodePacked(baseURI, Strings.toString(_tokenId)));
// }
function flipSaleState() public onlyOwner {
}
function withdraw() public onlyOwner {
}
function updatePrice(RoundType roundType, uint value) public onlyOwner {
}
function updateMultiple(RoundType roundType, uint value) public onlyOwner {
}
function inferType(uint[] memory bracket) public pure returns(RoundType) {
}
function mint(uint[] calldata _brackets, RoundType bracketType) public payable {
}
function setResults(uint[] memory _results) public onlyOwner {
}
// Need to represent null values until all results are in
// Can't do 0 because it's a valid index
// Can't do -1 because bracket is uint
// Fuck it -> 69 represents null value in array 8====D
// GROUP: []
// R16: [69,69,69,69,69,69,69,69,69,69,69,69,69,69,69][################]
// QF: [69,69,69,69,69,69,69][########################]
// SF: [69,69,69][############################]
// FINAL: [69][##############################]
// COMPLETE:[][###############################]
function currentRound() public view returns(RoundType) {
}
// Whether the bracket is a grand prize winner
function grandPrize(uint[] memory bracket) public view returns(bool) {
}
// [0] [1,2] [3..6] [7..14] [15..30]
// Winner FINAL SF QF R16
// Payout 40x 20x 5x 0x
// Returns amount in wei
function miniPrize(uint[] memory bracket) public view returns(uint) {
}
function payout(uint tokenId) public {
// TODO: require(msg.sender == ownerOf(tokenId), "Only token owner can call this method");
uint[] memory bracket = brackets[tokenId];
RoundType bracketType = inferType(bracket);
require(<FILL_ME>)
uint pool = prizePools[bracketType];
uint winners = counts[Serializer.toStr(bracket)];
uint amt = 0;
bool isMiniPrize = false;
// Grand prize is shared across all winners in the pool
if(grandPrize(bracket)) {
require(redeemedGrandPrize[tokenId] == false, "Already withdrew winnings");
amt = pool / winners;
}
// Only group brackets are eligible for mini prizes
else if(bracketType == RoundType.GROUP) {
require(redeemedMiniPrize[tokenId] == false, "Already withdrew winnings");
uint mintPrice = prices[RoundType.GROUP];
amt = miniPrize(bracket) * mintPrice;
isMiniPrize = true;
}
require(amt > 0, "This bracket is not a winning bracket");
// TODO: Check that balance of contract is more than the expected payout
payable(ownerOf(tokenId)).transfer(amt);
if(isMiniPrize) {
// Pay out multiples before distributing grand prize pool
prizePools[bracketType] -= amt;
redeemedMiniPrize[tokenId] = true;
} else {
// Grand prize does not deduct from pool
redeemedGrandPrize[tokenId] = true;
}
}
function deposit(RoundType bracketType) public payable {
}
function moveFunds(RoundType from, RoundType to, uint amt) public onlyOwner {
}
}
| currentRound()>bracketType,"We don't have any results yet" | 75,485 | currentRound()>bracketType |
"Already withdrew winnings" | // SPDX-License-Identifier: GOFUCKYOURSELF
pragma solidity ^0.8.9;
// /$$ /$$ /$$$$$$ /$$$$$$$ /$$ /$$$$$$$ /$$$$$$ /$$ /$$ /$$$$$$$
// | $$ /$ | $$ /$$__ $$| $$__ $$| $$ | $$__ $$ /$$__ $$| $$ | $$| $$__ $$
// | $$ /$$$| $$| $$ \ $$| $$ \ $$| $$ | $$ \ $$ | $$ \__/| $$ | $$| $$ \ $$
// | $$/$$ $$ $$| $$ | $$| $$$$$$$/| $$ | $$ | $$ | $$ | $$ | $$| $$$$$$$/
// | $$$$_ $$$$| $$ | $$| $$__ $$| $$ | $$ | $$ | $$ | $$ | $$| $$____/
// | $$$/ \ $$$| $$ | $$| $$ \ $$| $$ | $$ | $$ | $$ $$| $$ | $$| $$
// | $$/ \ $$| $$$$$$/| $$ | $$| $$$$$$$$| $$$$$$$/ | $$$$$$/| $$$$$$/| $$
// |__/ \__/ \______/ |__/ |__/|________/|_______/ \______/ \______/ |__/
// /$$$$$$ /$$ /$$ /$$$$$$ /$$ /$$ /$$$$$$ /$$$$$$ /$$ /$$
// /$$__ $$| $$$ | $$ /$$__ $$| $$ | $$ /$$__ $$|_ $$_/| $$$ | $$
// | $$ \ $$| $$$$| $$ | $$ \__/| $$ | $$| $$ \ $$ | $$ | $$$$| $$
// | $$ | $$| $$ $$ $$ | $$ | $$$$$$$$| $$$$$$$$ | $$ | $$ $$ $$
// | $$ | $$| $$ $$$$ | $$ | $$__ $$| $$__ $$ | $$ | $$ $$$$
// | $$ | $$| $$\ $$$ | $$ $$| $$ | $$| $$ | $$ | $$ | $$\ $$$
// | $$$$$$/| $$ \ $$ | $$$$$$/| $$ | $$| $$ | $$ /$$$$$$| $$ \ $$
// \______/ |__/ \__/ \______/ |__/ |__/|__/ |__/|______/|__/ \__/
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./Serializer.sol";
contract WorldCup is ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
Counters.Counter private counter; // token ids
string baseURI;
uint[] public results = new uint[](0);
bool public saleIsActive = false;
enum RoundType { GROUP, R16, QF, SF, FINAL, COMPLETE }
// new mapping for redeemed NFTs
mapping(uint => bool) public redeemedGrandPrize;
mapping(uint => bool) public redeemedMiniPrize;
// tokenId -> bracket
// 1 -> [ 1,2,3,4,...]
mapping(uint => uint[]) public brackets;
// bracket -> count
// "1,2,3" -> 5
mapping(string => uint) public counts;
// Store prices for minting each round
mapping(RoundType => uint) public prices;
// Keep track of prize pools for each round
mapping(RoundType => uint) public prizePools;
// Miniprize for getting part of a group bracket correct
mapping(RoundType => uint) public multiples;
event Mint(uint256 _tokenId);
// 32 teams, idx 0..31
string[] public teams = [
"IRN", "ENG", "USA", "QAT",
"ECU", "SN", "NL", "ARG",
"KSA", "MEX", "POL", "FRA",
"AUS", "DEN", "TUN", "ESP",
"CRC", "GER", "JPN", "BEL",
"CAN", "MAR", "CRO", "BRA",
"SRB","SUI","CMR","POR",
"GHA", "URU", "KOR", "WAL"
];
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI
) ERC721(
_name,
_symbol
) {
}
// Optional method, we might be able to get rid of this.
function _baseURI() internal view override virtual returns(string memory) {
}
// // Let's override the thirdweb methods here.
// // we don't need baseuris for each token.
// function tokenURI(uint _tokenId) public view virtual override returns(string memory) {
// return string(abi.encodePacked(baseURI, Strings.toString(_tokenId)));
// }
function flipSaleState() public onlyOwner {
}
function withdraw() public onlyOwner {
}
function updatePrice(RoundType roundType, uint value) public onlyOwner {
}
function updateMultiple(RoundType roundType, uint value) public onlyOwner {
}
function inferType(uint[] memory bracket) public pure returns(RoundType) {
}
function mint(uint[] calldata _brackets, RoundType bracketType) public payable {
}
function setResults(uint[] memory _results) public onlyOwner {
}
// Need to represent null values until all results are in
// Can't do 0 because it's a valid index
// Can't do -1 because bracket is uint
// Fuck it -> 69 represents null value in array 8====D
// GROUP: []
// R16: [69,69,69,69,69,69,69,69,69,69,69,69,69,69,69][################]
// QF: [69,69,69,69,69,69,69][########################]
// SF: [69,69,69][############################]
// FINAL: [69][##############################]
// COMPLETE:[][###############################]
function currentRound() public view returns(RoundType) {
}
// Whether the bracket is a grand prize winner
function grandPrize(uint[] memory bracket) public view returns(bool) {
}
// [0] [1,2] [3..6] [7..14] [15..30]
// Winner FINAL SF QF R16
// Payout 40x 20x 5x 0x
// Returns amount in wei
function miniPrize(uint[] memory bracket) public view returns(uint) {
}
function payout(uint tokenId) public {
// TODO: require(msg.sender == ownerOf(tokenId), "Only token owner can call this method");
uint[] memory bracket = brackets[tokenId];
RoundType bracketType = inferType(bracket);
require(currentRound() > bracketType, "We don't have any results yet");
uint pool = prizePools[bracketType];
uint winners = counts[Serializer.toStr(bracket)];
uint amt = 0;
bool isMiniPrize = false;
// Grand prize is shared across all winners in the pool
if(grandPrize(bracket)) {
require(<FILL_ME>)
amt = pool / winners;
}
// Only group brackets are eligible for mini prizes
else if(bracketType == RoundType.GROUP) {
require(redeemedMiniPrize[tokenId] == false, "Already withdrew winnings");
uint mintPrice = prices[RoundType.GROUP];
amt = miniPrize(bracket) * mintPrice;
isMiniPrize = true;
}
require(amt > 0, "This bracket is not a winning bracket");
// TODO: Check that balance of contract is more than the expected payout
payable(ownerOf(tokenId)).transfer(amt);
if(isMiniPrize) {
// Pay out multiples before distributing grand prize pool
prizePools[bracketType] -= amt;
redeemedMiniPrize[tokenId] = true;
} else {
// Grand prize does not deduct from pool
redeemedGrandPrize[tokenId] = true;
}
}
function deposit(RoundType bracketType) public payable {
}
function moveFunds(RoundType from, RoundType to, uint amt) public onlyOwner {
}
}
| redeemedGrandPrize[tokenId]==false,"Already withdrew winnings" | 75,485 | redeemedGrandPrize[tokenId]==false |
"Already withdrew winnings" | // SPDX-License-Identifier: GOFUCKYOURSELF
pragma solidity ^0.8.9;
// /$$ /$$ /$$$$$$ /$$$$$$$ /$$ /$$$$$$$ /$$$$$$ /$$ /$$ /$$$$$$$
// | $$ /$ | $$ /$$__ $$| $$__ $$| $$ | $$__ $$ /$$__ $$| $$ | $$| $$__ $$
// | $$ /$$$| $$| $$ \ $$| $$ \ $$| $$ | $$ \ $$ | $$ \__/| $$ | $$| $$ \ $$
// | $$/$$ $$ $$| $$ | $$| $$$$$$$/| $$ | $$ | $$ | $$ | $$ | $$| $$$$$$$/
// | $$$$_ $$$$| $$ | $$| $$__ $$| $$ | $$ | $$ | $$ | $$ | $$| $$____/
// | $$$/ \ $$$| $$ | $$| $$ \ $$| $$ | $$ | $$ | $$ $$| $$ | $$| $$
// | $$/ \ $$| $$$$$$/| $$ | $$| $$$$$$$$| $$$$$$$/ | $$$$$$/| $$$$$$/| $$
// |__/ \__/ \______/ |__/ |__/|________/|_______/ \______/ \______/ |__/
// /$$$$$$ /$$ /$$ /$$$$$$ /$$ /$$ /$$$$$$ /$$$$$$ /$$ /$$
// /$$__ $$| $$$ | $$ /$$__ $$| $$ | $$ /$$__ $$|_ $$_/| $$$ | $$
// | $$ \ $$| $$$$| $$ | $$ \__/| $$ | $$| $$ \ $$ | $$ | $$$$| $$
// | $$ | $$| $$ $$ $$ | $$ | $$$$$$$$| $$$$$$$$ | $$ | $$ $$ $$
// | $$ | $$| $$ $$$$ | $$ | $$__ $$| $$__ $$ | $$ | $$ $$$$
// | $$ | $$| $$\ $$$ | $$ $$| $$ | $$| $$ | $$ | $$ | $$\ $$$
// | $$$$$$/| $$ \ $$ | $$$$$$/| $$ | $$| $$ | $$ /$$$$$$| $$ \ $$
// \______/ |__/ \__/ \______/ |__/ |__/|__/ |__/|______/|__/ \__/
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./Serializer.sol";
contract WorldCup is ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
Counters.Counter private counter; // token ids
string baseURI;
uint[] public results = new uint[](0);
bool public saleIsActive = false;
enum RoundType { GROUP, R16, QF, SF, FINAL, COMPLETE }
// new mapping for redeemed NFTs
mapping(uint => bool) public redeemedGrandPrize;
mapping(uint => bool) public redeemedMiniPrize;
// tokenId -> bracket
// 1 -> [ 1,2,3,4,...]
mapping(uint => uint[]) public brackets;
// bracket -> count
// "1,2,3" -> 5
mapping(string => uint) public counts;
// Store prices for minting each round
mapping(RoundType => uint) public prices;
// Keep track of prize pools for each round
mapping(RoundType => uint) public prizePools;
// Miniprize for getting part of a group bracket correct
mapping(RoundType => uint) public multiples;
event Mint(uint256 _tokenId);
// 32 teams, idx 0..31
string[] public teams = [
"IRN", "ENG", "USA", "QAT",
"ECU", "SN", "NL", "ARG",
"KSA", "MEX", "POL", "FRA",
"AUS", "DEN", "TUN", "ESP",
"CRC", "GER", "JPN", "BEL",
"CAN", "MAR", "CRO", "BRA",
"SRB","SUI","CMR","POR",
"GHA", "URU", "KOR", "WAL"
];
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI
) ERC721(
_name,
_symbol
) {
}
// Optional method, we might be able to get rid of this.
function _baseURI() internal view override virtual returns(string memory) {
}
// // Let's override the thirdweb methods here.
// // we don't need baseuris for each token.
// function tokenURI(uint _tokenId) public view virtual override returns(string memory) {
// return string(abi.encodePacked(baseURI, Strings.toString(_tokenId)));
// }
function flipSaleState() public onlyOwner {
}
function withdraw() public onlyOwner {
}
function updatePrice(RoundType roundType, uint value) public onlyOwner {
}
function updateMultiple(RoundType roundType, uint value) public onlyOwner {
}
function inferType(uint[] memory bracket) public pure returns(RoundType) {
}
function mint(uint[] calldata _brackets, RoundType bracketType) public payable {
}
function setResults(uint[] memory _results) public onlyOwner {
}
// Need to represent null values until all results are in
// Can't do 0 because it's a valid index
// Can't do -1 because bracket is uint
// Fuck it -> 69 represents null value in array 8====D
// GROUP: []
// R16: [69,69,69,69,69,69,69,69,69,69,69,69,69,69,69][################]
// QF: [69,69,69,69,69,69,69][########################]
// SF: [69,69,69][############################]
// FINAL: [69][##############################]
// COMPLETE:[][###############################]
function currentRound() public view returns(RoundType) {
}
// Whether the bracket is a grand prize winner
function grandPrize(uint[] memory bracket) public view returns(bool) {
}
// [0] [1,2] [3..6] [7..14] [15..30]
// Winner FINAL SF QF R16
// Payout 40x 20x 5x 0x
// Returns amount in wei
function miniPrize(uint[] memory bracket) public view returns(uint) {
}
function payout(uint tokenId) public {
// TODO: require(msg.sender == ownerOf(tokenId), "Only token owner can call this method");
uint[] memory bracket = brackets[tokenId];
RoundType bracketType = inferType(bracket);
require(currentRound() > bracketType, "We don't have any results yet");
uint pool = prizePools[bracketType];
uint winners = counts[Serializer.toStr(bracket)];
uint amt = 0;
bool isMiniPrize = false;
// Grand prize is shared across all winners in the pool
if(grandPrize(bracket)) {
require(redeemedGrandPrize[tokenId] == false, "Already withdrew winnings");
amt = pool / winners;
}
// Only group brackets are eligible for mini prizes
else if(bracketType == RoundType.GROUP) {
require(<FILL_ME>)
uint mintPrice = prices[RoundType.GROUP];
amt = miniPrize(bracket) * mintPrice;
isMiniPrize = true;
}
require(amt > 0, "This bracket is not a winning bracket");
// TODO: Check that balance of contract is more than the expected payout
payable(ownerOf(tokenId)).transfer(amt);
if(isMiniPrize) {
// Pay out multiples before distributing grand prize pool
prizePools[bracketType] -= amt;
redeemedMiniPrize[tokenId] = true;
} else {
// Grand prize does not deduct from pool
redeemedGrandPrize[tokenId] = true;
}
}
function deposit(RoundType bracketType) public payable {
}
function moveFunds(RoundType from, RoundType to, uint amt) public onlyOwner {
}
}
| redeemedMiniPrize[tokenId]==false,"Already withdrew winnings" | 75,485 | redeemedMiniPrize[tokenId]==false |
"Prize pool does not have enough funds" | // SPDX-License-Identifier: GOFUCKYOURSELF
pragma solidity ^0.8.9;
// /$$ /$$ /$$$$$$ /$$$$$$$ /$$ /$$$$$$$ /$$$$$$ /$$ /$$ /$$$$$$$
// | $$ /$ | $$ /$$__ $$| $$__ $$| $$ | $$__ $$ /$$__ $$| $$ | $$| $$__ $$
// | $$ /$$$| $$| $$ \ $$| $$ \ $$| $$ | $$ \ $$ | $$ \__/| $$ | $$| $$ \ $$
// | $$/$$ $$ $$| $$ | $$| $$$$$$$/| $$ | $$ | $$ | $$ | $$ | $$| $$$$$$$/
// | $$$$_ $$$$| $$ | $$| $$__ $$| $$ | $$ | $$ | $$ | $$ | $$| $$____/
// | $$$/ \ $$$| $$ | $$| $$ \ $$| $$ | $$ | $$ | $$ $$| $$ | $$| $$
// | $$/ \ $$| $$$$$$/| $$ | $$| $$$$$$$$| $$$$$$$/ | $$$$$$/| $$$$$$/| $$
// |__/ \__/ \______/ |__/ |__/|________/|_______/ \______/ \______/ |__/
// /$$$$$$ /$$ /$$ /$$$$$$ /$$ /$$ /$$$$$$ /$$$$$$ /$$ /$$
// /$$__ $$| $$$ | $$ /$$__ $$| $$ | $$ /$$__ $$|_ $$_/| $$$ | $$
// | $$ \ $$| $$$$| $$ | $$ \__/| $$ | $$| $$ \ $$ | $$ | $$$$| $$
// | $$ | $$| $$ $$ $$ | $$ | $$$$$$$$| $$$$$$$$ | $$ | $$ $$ $$
// | $$ | $$| $$ $$$$ | $$ | $$__ $$| $$__ $$ | $$ | $$ $$$$
// | $$ | $$| $$\ $$$ | $$ $$| $$ | $$| $$ | $$ | $$ | $$\ $$$
// | $$$$$$/| $$ \ $$ | $$$$$$/| $$ | $$| $$ | $$ /$$$$$$| $$ \ $$
// \______/ |__/ \__/ \______/ |__/ |__/|__/ |__/|______/|__/ \__/
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./Serializer.sol";
contract WorldCup is ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
Counters.Counter private counter; // token ids
string baseURI;
uint[] public results = new uint[](0);
bool public saleIsActive = false;
enum RoundType { GROUP, R16, QF, SF, FINAL, COMPLETE }
// new mapping for redeemed NFTs
mapping(uint => bool) public redeemedGrandPrize;
mapping(uint => bool) public redeemedMiniPrize;
// tokenId -> bracket
// 1 -> [ 1,2,3,4,...]
mapping(uint => uint[]) public brackets;
// bracket -> count
// "1,2,3" -> 5
mapping(string => uint) public counts;
// Store prices for minting each round
mapping(RoundType => uint) public prices;
// Keep track of prize pools for each round
mapping(RoundType => uint) public prizePools;
// Miniprize for getting part of a group bracket correct
mapping(RoundType => uint) public multiples;
event Mint(uint256 _tokenId);
// 32 teams, idx 0..31
string[] public teams = [
"IRN", "ENG", "USA", "QAT",
"ECU", "SN", "NL", "ARG",
"KSA", "MEX", "POL", "FRA",
"AUS", "DEN", "TUN", "ESP",
"CRC", "GER", "JPN", "BEL",
"CAN", "MAR", "CRO", "BRA",
"SRB","SUI","CMR","POR",
"GHA", "URU", "KOR", "WAL"
];
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI
) ERC721(
_name,
_symbol
) {
}
// Optional method, we might be able to get rid of this.
function _baseURI() internal view override virtual returns(string memory) {
}
// // Let's override the thirdweb methods here.
// // we don't need baseuris for each token.
// function tokenURI(uint _tokenId) public view virtual override returns(string memory) {
// return string(abi.encodePacked(baseURI, Strings.toString(_tokenId)));
// }
function flipSaleState() public onlyOwner {
}
function withdraw() public onlyOwner {
}
function updatePrice(RoundType roundType, uint value) public onlyOwner {
}
function updateMultiple(RoundType roundType, uint value) public onlyOwner {
}
function inferType(uint[] memory bracket) public pure returns(RoundType) {
}
function mint(uint[] calldata _brackets, RoundType bracketType) public payable {
}
function setResults(uint[] memory _results) public onlyOwner {
}
// Need to represent null values until all results are in
// Can't do 0 because it's a valid index
// Can't do -1 because bracket is uint
// Fuck it -> 69 represents null value in array 8====D
// GROUP: []
// R16: [69,69,69,69,69,69,69,69,69,69,69,69,69,69,69][################]
// QF: [69,69,69,69,69,69,69][########################]
// SF: [69,69,69][############################]
// FINAL: [69][##############################]
// COMPLETE:[][###############################]
function currentRound() public view returns(RoundType) {
}
// Whether the bracket is a grand prize winner
function grandPrize(uint[] memory bracket) public view returns(bool) {
}
// [0] [1,2] [3..6] [7..14] [15..30]
// Winner FINAL SF QF R16
// Payout 40x 20x 5x 0x
// Returns amount in wei
function miniPrize(uint[] memory bracket) public view returns(uint) {
}
function payout(uint tokenId) public {
}
function deposit(RoundType bracketType) public payable {
}
function moveFunds(RoundType from, RoundType to, uint amt) public onlyOwner {
require(<FILL_ME>)
prizePools[from] -= amt;
prizePools[to] += amt;
}
}
| prizePools[from]>=amt,"Prize pool does not have enough funds" | 75,485 | prizePools[from]>=amt |
"Cannot set max buy amount lower than 0.2%" | /*
Societas Draconistarum - The Order of the Dragon
https://theorderofthedragon.org/
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
/**
* OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
/**
* OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
*/
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(
address owner,
address spender
) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
/**
* OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)
* _Available since v4.1._
*/
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
/**
* OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/ERC20.sol)
*/
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(
address account
) public view virtual override returns (uint256) {
}
function transfer(
address to,
uint256 amount
) public virtual override returns (bool) {
}
function allowance(
address owner,
address spender
) public view virtual override returns (uint256) {
}
function approve(
address spender,
uint256 amount
) public virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(
address spender,
uint256 addedValue
) public virtual returns (bool) {
}
function decreaseAllowance(
address spender,
uint256 subtractedValue
) public virtual returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
/**
* OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
}
interface IDexFactory {
function createPair(
address tokenA,
address tokenB
) external returns (address pair);
}
contract Draconis is ERC20, Ownable {
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWalletAmount;
IDexRouter public dexRouter;
address public lpPair;
bool private swapping;
uint256 public swapTokensAtAmount;
address taxAddress;
uint256 public tradingActiveBlock = 0;
uint256 public blockForPenaltyEnd;
mapping(address => bool) public boughtEarly;
uint256 public botsCaught;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
bool public swapToEth = true;
mapping(address => uint256) private _holderLastTransferTimestamp;
bool public transferDelayEnabled = true;
uint256 public buyTotalFees;
uint256 public buyTaxFee;
uint256 public sellTotalFees;
uint256 public sellTaxFee;
uint256 public tokensForTax;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
mapping(address => bool) public automatedMarketMakerPairs;
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event EnabledTrading();
event RemovedLimits();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedMaxSellAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event MaxTransactionExclusion(address _address, bool excluded);
event OwnerForcedSwapBack(uint256 timestamp);
event CaughtEarlyBuyer(address sniper);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
constructor() ERC20("The Order of the Dragon", "DRACONIS") {
}
receive() external payable {}
function enableTrading(uint256 deadBlocks) external onlyOwner {
}
function removeLimits() external onlyOwner {
}
function manageBoughtEarly(address wallet, bool flag) external onlyOwner {
}
function massManageBoughtEarly(
address[] calldata wallets,
bool flag
) external onlyOwner {
}
function disableTransferDelay() external onlyOwner {
}
function updateMaxBuyAmount(uint256 newNum) external onlyOwner {
require(<FILL_ME>)
maxBuyAmount = newNum * (10 ** 18);
emit UpdatedMaxBuyAmount(maxBuyAmount);
}
function updateMaxSellAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner {
}
function _excludeFromMaxTransaction(
address updAds,
bool isExcluded
) private {
}
function excludeFromMaxTransaction(
address updAds,
bool isEx
) external onlyOwner {
}
function setAutomatedMarketMakerPair(
address pair,
bool value
) external onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function setSwapToEth(bool _swapToEth) public onlyOwner {
}
function updateBuyFees(uint256 _taxFee) external onlyOwner {
}
function updateSellFees(uint256 _taxFee) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function earlyBuyPenaltyInEffect() public view returns (bool) {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function swapBack() private {
}
// Withdraw ETH from contract address
function withdrawStuckETH() external onlyOwner {
}
function updateTaxAddress(address _taxAddress) external onlyOwner {
}
function forceSwapBack() external onlyOwner {
}
}
| newNum>=((totalSupply()*2)/1000)/1e18,"Cannot set max buy amount lower than 0.2%" | 75,510 | newNum>=((totalSupply()*2)/1000)/1e18 |
"Cannot set max wallet amount lower than 0.3%" | /*
Societas Draconistarum - The Order of the Dragon
https://theorderofthedragon.org/
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
/**
* OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
/**
* OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
*/
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(
address owner,
address spender
) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
/**
* OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)
* _Available since v4.1._
*/
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
/**
* OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/ERC20.sol)
*/
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(
address account
) public view virtual override returns (uint256) {
}
function transfer(
address to,
uint256 amount
) public virtual override returns (bool) {
}
function allowance(
address owner,
address spender
) public view virtual override returns (uint256) {
}
function approve(
address spender,
uint256 amount
) public virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(
address spender,
uint256 addedValue
) public virtual returns (bool) {
}
function decreaseAllowance(
address spender,
uint256 subtractedValue
) public virtual returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
/**
* OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
}
interface IDexFactory {
function createPair(
address tokenA,
address tokenB
) external returns (address pair);
}
contract Draconis is ERC20, Ownable {
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWalletAmount;
IDexRouter public dexRouter;
address public lpPair;
bool private swapping;
uint256 public swapTokensAtAmount;
address taxAddress;
uint256 public tradingActiveBlock = 0;
uint256 public blockForPenaltyEnd;
mapping(address => bool) public boughtEarly;
uint256 public botsCaught;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
bool public swapToEth = true;
mapping(address => uint256) private _holderLastTransferTimestamp;
bool public transferDelayEnabled = true;
uint256 public buyTotalFees;
uint256 public buyTaxFee;
uint256 public sellTotalFees;
uint256 public sellTaxFee;
uint256 public tokensForTax;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
mapping(address => bool) public automatedMarketMakerPairs;
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event EnabledTrading();
event RemovedLimits();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedMaxSellAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event MaxTransactionExclusion(address _address, bool excluded);
event OwnerForcedSwapBack(uint256 timestamp);
event CaughtEarlyBuyer(address sniper);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
constructor() ERC20("The Order of the Dragon", "DRACONIS") {
}
receive() external payable {}
function enableTrading(uint256 deadBlocks) external onlyOwner {
}
function removeLimits() external onlyOwner {
}
function manageBoughtEarly(address wallet, bool flag) external onlyOwner {
}
function massManageBoughtEarly(
address[] calldata wallets,
bool flag
) external onlyOwner {
}
function disableTransferDelay() external onlyOwner {
}
function updateMaxBuyAmount(uint256 newNum) external onlyOwner {
}
function updateMaxSellAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
require(<FILL_ME>)
maxWalletAmount = newNum * (10 ** 18);
emit UpdatedMaxWalletAmount(maxWalletAmount);
}
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner {
}
function _excludeFromMaxTransaction(
address updAds,
bool isExcluded
) private {
}
function excludeFromMaxTransaction(
address updAds,
bool isEx
) external onlyOwner {
}
function setAutomatedMarketMakerPair(
address pair,
bool value
) external onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function setSwapToEth(bool _swapToEth) public onlyOwner {
}
function updateBuyFees(uint256 _taxFee) external onlyOwner {
}
function updateSellFees(uint256 _taxFee) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function earlyBuyPenaltyInEffect() public view returns (bool) {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function swapBack() private {
}
// Withdraw ETH from contract address
function withdrawStuckETH() external onlyOwner {
}
function updateTaxAddress(address _taxAddress) external onlyOwner {
}
function forceSwapBack() external onlyOwner {
}
}
| newNum>=((totalSupply()*3)/1000)/1e18,"Cannot set max wallet amount lower than 0.3%" | 75,510 | newNum>=((totalSupply()*3)/1000)/1e18 |
"Swap amount cannot be higher than 0.1% total supply." | /*
Societas Draconistarum - The Order of the Dragon
https://theorderofthedragon.org/
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
/**
* OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
/**
* OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
*/
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(
address owner,
address spender
) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
/**
* OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)
* _Available since v4.1._
*/
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
/**
* OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/ERC20.sol)
*/
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(
address account
) public view virtual override returns (uint256) {
}
function transfer(
address to,
uint256 amount
) public virtual override returns (bool) {
}
function allowance(
address owner,
address spender
) public view virtual override returns (uint256) {
}
function approve(
address spender,
uint256 amount
) public virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(
address spender,
uint256 addedValue
) public virtual returns (bool) {
}
function decreaseAllowance(
address spender,
uint256 subtractedValue
) public virtual returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
/**
* OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
}
interface IDexFactory {
function createPair(
address tokenA,
address tokenB
) external returns (address pair);
}
contract Draconis is ERC20, Ownable {
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWalletAmount;
IDexRouter public dexRouter;
address public lpPair;
bool private swapping;
uint256 public swapTokensAtAmount;
address taxAddress;
uint256 public tradingActiveBlock = 0;
uint256 public blockForPenaltyEnd;
mapping(address => bool) public boughtEarly;
uint256 public botsCaught;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
bool public swapToEth = true;
mapping(address => uint256) private _holderLastTransferTimestamp;
bool public transferDelayEnabled = true;
uint256 public buyTotalFees;
uint256 public buyTaxFee;
uint256 public sellTotalFees;
uint256 public sellTaxFee;
uint256 public tokensForTax;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
mapping(address => bool) public automatedMarketMakerPairs;
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event EnabledTrading();
event RemovedLimits();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedMaxSellAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event MaxTransactionExclusion(address _address, bool excluded);
event OwnerForcedSwapBack(uint256 timestamp);
event CaughtEarlyBuyer(address sniper);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
constructor() ERC20("The Order of the Dragon", "DRACONIS") {
}
receive() external payable {}
function enableTrading(uint256 deadBlocks) external onlyOwner {
}
function removeLimits() external onlyOwner {
}
function manageBoughtEarly(address wallet, bool flag) external onlyOwner {
}
function massManageBoughtEarly(
address[] calldata wallets,
bool flag
) external onlyOwner {
}
function disableTransferDelay() external onlyOwner {
}
function updateMaxBuyAmount(uint256 newNum) external onlyOwner {
}
function updateMaxSellAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner {
require(
newAmount >= (totalSupply() * 1) / 100000,
"Swap amount cannot be lower than 0.001% total supply."
);
require(<FILL_ME>)
swapTokensAtAmount = newAmount;
}
function _excludeFromMaxTransaction(
address updAds,
bool isExcluded
) private {
}
function excludeFromMaxTransaction(
address updAds,
bool isEx
) external onlyOwner {
}
function setAutomatedMarketMakerPair(
address pair,
bool value
) external onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function setSwapToEth(bool _swapToEth) public onlyOwner {
}
function updateBuyFees(uint256 _taxFee) external onlyOwner {
}
function updateSellFees(uint256 _taxFee) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function earlyBuyPenaltyInEffect() public view returns (bool) {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function swapBack() private {
}
// Withdraw ETH from contract address
function withdrawStuckETH() external onlyOwner {
}
function updateTaxAddress(address _taxAddress) external onlyOwner {
}
function forceSwapBack() external onlyOwner {
}
}
| newAmount<=(totalSupply()*1)/1000,"Swap amount cannot be higher than 0.1% total supply." | 75,510 | newAmount<=(totalSupply()*1)/1000 |
"ERC20: transfer amount exceeds balance" | /**
//SPDX-License-Identifier: UNLICENSED
Komatsuhime | $KOMATSUHIME
One of the strongest female warriors of the Edo period.
She is highly intelligent and extremely skillful in fighting.
She will fight for the success of our journey.
Website: https://komatsuhime.com
Telegram: https://t.me/KomatsuhimePortal
*/
pragma solidity ^0.8.4;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function 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 KOMATSUHIME is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public isExcludedFromFee;
mapping (address => bool) public isExcludedFromLimit;
mapping (address => bool) private bots;
mapping (address => uint) private cooldown;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1_000_000_000_000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 public swapThreshold = 100_000_000 * 10**9;
uint256 private _reflectionFee = 0;
uint256 private _teamFee = 6;
address payable private _feeAddrWallet1;
address payable private _feeAddrWallet2;
string private constant _name = "Komatsuhime";
string private constant _symbol = "KOMATSUHIME";
uint8 private constant _decimals = 9;
IUniswapV2Router02 private uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen;
bool private inSwap;
bool private swapEnabled;
bool private cooldownEnabled;
uint256 private _maxTxAmount = 20_000_000_000 * 10**9;
uint256 private _maxWalletAmount = 20_000_000_000 * 10**9;
modifier lockTheSwap {
}
constructor (address wallet1, address wallet2) {
}
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 setCooldownEnabled(bool onoff) external onlyOwner {
}
function tokenFromReflection(uint256 rAmount) private view returns(uint256) {
}
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(<FILL_ME>)
if (from != owner() && to != owner()) {
require(!bots[from] && !bots[to]);
if (!isExcludedFromLimit[from] || (from == uniswapV2Pair && !isExcludedFromLimit[to])) {
require(amount <= _maxTxAmount, "Anti-whale: Transfer amount exceeds max limit");
}
if (!isExcludedFromLimit[to]) {
require(balanceOf(to) + amount <= _maxWalletAmount, "Anti-whale: Wallet amount exceeds max limit");
}
if (from == uniswapV2Pair && to != address(uniswapV2Router) && !isExcludedFromFee[to] && cooldownEnabled) {
// Cooldown
require(cooldown[to] < block.timestamp);
cooldown[to] = block.timestamp + (60 seconds);
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && from != uniswapV2Pair && swapEnabled && contractTokenBalance >= swapThreshold) {
swapTokensForEth(contractTokenBalance);
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
_tokenTransfer(from,to,amount);
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function openTrading() external onlyOwner() {
}
function changeMaxTxAmount(uint256 amount) public onlyOwner {
}
function changeMaxWalletAmount(uint256 amount) public onlyOwner {
}
function changeSwapThreshold(uint256 amount) public onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function excludeFromLimits(address account, bool excluded) public onlyOwner {
}
function _tokenTransfer(address sender, address recipient, uint256 amount) private {
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function manualSwap() external {
}
function manualSend() external {
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
}
function _getTValues(uint256 tAmount, uint256 reflectFee, uint256 teamFee) private pure returns (uint256, uint256, uint256) {
}
function _getRValues(uint256 tAmount, uint256 tReflect, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
}
function _getRate() private view returns(uint256) {
}
function _getCurrentSupply() private view returns(uint256, uint256) {
}
}
| balanceOf(from)>=amount,"ERC20: transfer amount exceeds balance" | 75,541 | balanceOf(from)>=amount |
"You don't own this NFT." | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
interface IXENNFTContract {
function ownerOf(uint256) external view returns (address);
}
contract NFTRegistry {
struct NFT {
uint256 tokenId;
string category;
}
struct User {
NFT[] userNFTs;
uint256 userRewards; // Tracks total rewards sebt to user.
uint256 userPoints;
uint256 lastRewardRatio;
}
mapping(address => User) public users;
mapping(uint256 => string) private categoryMap;
mapping(uint256 => address) public currentHolder;
mapping(string => uint256) public globalCounters;
uint256 private constant XUNICORN_MIN_ID = 1;
uint256 private constant XUNICORN_MAX_ID = 100;
uint256 private constant EXOTIC_MIN_ID = 101;
uint256 private constant EXOTIC_MAX_ID = 1000;
uint256 private constant LEGENDARY_MIN_ID = 1001;
uint256 private constant LEGENDARY_MAX_ID = 3000;
uint256 private constant EPIC_MIN_ID = 3001;
uint256 private constant EPIC_MAX_ID = 6000;
uint256 private constant RARE_MIN_ID = 6001;
uint256 private constant RARE_MAX_ID = 10000;
mapping(uint256 => uint256) private rewardsMap;
address public nftContractAddress;
uint256 public totalRewards;
uint256 public totalPoints;
uint256 public rewardRatio;
uint256 private constant XUNICORN_WEIGHT = 50;
uint256 private constant EXOTIC_WEIGHT = 50;
uint256 private constant LEGENDARY_WEIGHT = 25;
uint256 private constant EPIC_WEIGHT = 10;
uint256 private constant RARE_WEIGHT = 5;
uint256 private constant COLLECTOR_WEIGHT = 0;
constructor(address _nftContractAddress) {
}
event NFTRegistered(address indexed user, uint256 tokenId, uint256 rewards);
event RewardsWithdrawn(address indexed user, uint256 amount);
receive() external payable {
}
function addToPool() external payable {
}
function registerNFT(uint256 tokenId) public {
address player = msg.sender;
require(<FILL_ME>)
// Calculate the reward points for the NFT
uint256 rewardPoints = getTokenWeight(tokenId);
// Check if the NFT was previously registered to a different user
address previousOwner = getNFTOwner(tokenId);
require(previousOwner != player, "You already have this NFT regestered");
if (previousOwner != address(0) && previousOwner != player) {
User storage previousOwnerData = users[previousOwner];
uint256 previousRewardAmount = calculateReward(previousOwner);
address payable previousOwnerpay = payable(previousOwner);
// Remove the previous owner's points
previousOwnerData.userPoints -= rewardPoints;
totalPoints -= rewardPoints;
previousOwnerData.userRewards += previousRewardAmount;
previousOwnerData.lastRewardRatio = rewardRatio;
// Remove the NFT from the previous owner's list
for (uint256 i = 0; i < previousOwnerData.userNFTs.length; i++) {
if (previousOwnerData.userNFTs[i].tokenId == tokenId) {
// Shift all elements to the left
for (uint256 j = i; j < previousOwnerData.userNFTs.length - 1; j++) {
previousOwnerData.userNFTs[j] = previousOwnerData.userNFTs[j + 1];
}
// Remove the last element
previousOwnerData.userNFTs.pop();
break;
}
}
// Pay the previous owner their rewards
previousOwnerpay.transfer(previousRewardAmount);
}
User storage currentUserData = users[player];
if (currentUserData.lastRewardRatio != rewardRatio && currentUserData.lastRewardRatio != 0) {
withdrawRewards();
}
// Update the user's rewards, points, and last rewarded timestamp
currentUserData.userPoints += rewardPoints;
totalPoints += rewardPoints;
currentUserData.lastRewardRatio = rewardRatio;
// Update the NFT ownership
setNFTOwner(tokenId, player);
emit NFTRegistered(player, tokenId, rewardPoints);
}
function registerNFTs(uint256[] memory tokenIds) external {
}
function isNFTRegistered(uint256 tokenId) public view returns (bool) {
}
function setNFTOwner(uint256 tokenId, address owner) private {
}
function getNFTOwner(uint256 tokenId) public view returns (address) {
}
function getCategory(uint256 tokenId) public pure returns (string memory) {
}
function calculateReward(address user) public view returns (uint256) {
}
function withdrawRewards() public payable {
}
function _isNFTOwner(uint256 tokenId, address owner) public view returns (bool) {
}
function getTokenWeight(uint256 tokenId) public pure returns (uint256) {
}
function getUserNFTCounts(address user) external view returns (uint256[] memory) {
}
function _hasValidOwnership(address user) public view returns (bool) {
}
}
| IXENNFTContract(nftContractAddress).ownerOf(tokenId)==player,"You don't own this NFT." | 75,596 | IXENNFTContract(nftContractAddress).ownerOf(tokenId)==player |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.