comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"u" | pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
// SPDX-License-Identifier: MIT OR Apache-2.0
import "./ReentrancyGuard.sol";
import "./SafeMath.sol";
import "./SafeMathUInt128.sol";
import "./SafeCast.sol";
import "./Utils.sol";
import "./Storage.sol";
import "./Config.sol";
import "./Events.sol";
import "./Bytes.sol";
import "./Operations.sol";
import "./UpgradeableMaster.sol";
/// @title zkSync additional main contract
/// @author Matter Labs
contract AdditionalZkSync is Storage, Config, Events, ReentrancyGuard {
using SafeMath for uint256;
using SafeMathUInt128 for uint128;
function increaseBalanceToWithdraw(bytes22 _packedBalanceKey, uint128 _amount) internal {
}
/// @notice Withdraws token from ZkSync to root chain in case of exodus mode. User must provide proof that he owns funds
/// @param _storedBlockInfo Last verified block
/// @param _owner Owner of the account
/// @param _accountId Id of the account in the tree
/// @param _proof Proof
/// @param _tokenId Verified token id
/// @param _amount Amount for owner (must be total amount, not part of it)
function performExodus(
StoredBlockInfo memory _storedBlockInfo,
address _owner,
uint32 _accountId,
uint32 _tokenId,
uint128 _amount,
uint32 _nftCreatorAccountId,
address _nftCreatorAddress,
uint32 _nftSerialId,
bytes32 _nftContentHash,
uint256[] calldata _proof
) external {
require(_accountId <= MAX_ACCOUNT_ID, "e");
require(_accountId != SPECIAL_ACCOUNT_ID, "v");
require(_tokenId < SPECIAL_NFT_TOKEN_ID, "T");
require(exodusMode, "s"); // must be in exodus mode
require(!performedExodus[_accountId][_tokenId], "t"); // already exited
require(<FILL_ME>) // incorrect stored block info
bool proofCorrect = verifier.verifyExitProof(
_storedBlockInfo.stateHash,
_accountId,
_owner,
_tokenId,
_amount,
_nftCreatorAccountId,
_nftCreatorAddress,
_nftSerialId,
_nftContentHash,
_proof
);
require(proofCorrect, "x");
if (_tokenId <= MAX_FUNGIBLE_TOKEN_ID) {
bytes22 packedBalanceKey = packAddressAndTokenId(_owner, uint16(_tokenId));
increaseBalanceToWithdraw(packedBalanceKey, _amount);
emit WithdrawalPending(uint16(_tokenId), _owner, _amount);
} else {
require(_amount != 0, "Z"); // Unsupported nft amount
Operations.WithdrawNFT memory withdrawNftOp = Operations.WithdrawNFT(
_nftCreatorAccountId,
_nftCreatorAddress,
_nftSerialId,
_nftContentHash,
_owner,
_tokenId
);
pendingWithdrawnNFTs[_tokenId] = withdrawNftOp;
emit WithdrawalNFTPending(_tokenId);
}
performedExodus[_accountId][_tokenId] = true;
}
function cancelOutstandingDepositsForExodusMode(uint64 _n, bytes[] calldata _depositsPubdata) external {
}
uint256 internal constant SECURITY_COUNCIL_THRESHOLD = 9;
/// @notice processing new approval of decrease upgrade notice period time to zero
/// @param addr address of the account that approved the reduction of the upgrade notice period to zero
/// NOTE: does NOT revert if the address is not a security council member or number of approvals is already sufficient
function approveCutUpgradeNoticePeriod(address addr) internal {
}
/// @notice approve to decrease upgrade notice period time to zero
/// NOTE: сan only be called after the start of the upgrade
function cutUpgradeNoticePeriod(bytes32 targetsHash) external {
}
/// @notice approve to decrease upgrade notice period time to zero by signatures
/// NOTE: Can accept many signatures at a time, thus it is possible
/// to completely cut the upgrade notice period in one transaction
function cutUpgradeNoticePeriodBySignature(bytes[] calldata signatures) external {
}
/// @return hash of the concatenation of targets for which there is an upgrade
/// NOTE: revert if upgrade is not active at this moment
function getUpgradeTargetsHash() internal returns (bytes32) {
}
/// @notice Set data for changing pubkey hash using onchain authorization.
/// Transaction author (msg.sender) should be L2 account address
/// @notice New pubkey hash can be reset, to do that user should send two transactions:
/// 1) First `setAuthPubkeyHash` transaction for already used `_nonce` will set timer.
/// 2) After `AUTH_FACT_RESET_TIMELOCK` time is passed second `setAuthPubkeyHash` transaction will reset pubkey hash for `_nonce`.
/// @param _pubkeyHash New pubkey hash
/// @param _nonce Nonce of the change pubkey L2 transaction
function setAuthPubkeyHash(bytes calldata _pubkeyHash, uint32 _nonce) external {
}
/// @notice Reverts unverified blocks
function revertBlocks(StoredBlockInfo[] calldata _blocksToRevert) external {
}
}
| storedBlockHashes[totalBlocksExecuted]==hashStoredBlockInfo(_storedBlockInfo),"u" | 264,523 | storedBlockHashes[totalBlocksExecuted]==hashStoredBlockInfo(_storedBlockInfo) |
"a" | pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
// SPDX-License-Identifier: MIT OR Apache-2.0
import "./ReentrancyGuard.sol";
import "./SafeMath.sol";
import "./SafeMathUInt128.sol";
import "./SafeCast.sol";
import "./Utils.sol";
import "./Storage.sol";
import "./Config.sol";
import "./Events.sol";
import "./Bytes.sol";
import "./Operations.sol";
import "./UpgradeableMaster.sol";
/// @title zkSync additional main contract
/// @author Matter Labs
contract AdditionalZkSync is Storage, Config, Events, ReentrancyGuard {
using SafeMath for uint256;
using SafeMathUInt128 for uint128;
function increaseBalanceToWithdraw(bytes22 _packedBalanceKey, uint128 _amount) internal {
}
/// @notice Withdraws token from ZkSync to root chain in case of exodus mode. User must provide proof that he owns funds
/// @param _storedBlockInfo Last verified block
/// @param _owner Owner of the account
/// @param _accountId Id of the account in the tree
/// @param _proof Proof
/// @param _tokenId Verified token id
/// @param _amount Amount for owner (must be total amount, not part of it)
function performExodus(
StoredBlockInfo memory _storedBlockInfo,
address _owner,
uint32 _accountId,
uint32 _tokenId,
uint128 _amount,
uint32 _nftCreatorAccountId,
address _nftCreatorAddress,
uint32 _nftSerialId,
bytes32 _nftContentHash,
uint256[] calldata _proof
) external {
}
function cancelOutstandingDepositsForExodusMode(uint64 _n, bytes[] calldata _depositsPubdata) external {
require(exodusMode, "8"); // exodus mode not active
uint64 toProcess = Utils.minU64(totalOpenPriorityRequests, _n);
require(toProcess > 0, "9"); // no deposits to process
uint64 currentDepositIdx = 0;
for (uint64 id = firstPriorityRequestId; id < firstPriorityRequestId + toProcess; ++id) {
if (priorityRequests[id].opType == Operations.OpType.Deposit) {
bytes memory depositPubdata = _depositsPubdata[currentDepositIdx];
require(<FILL_ME>)
++currentDepositIdx;
Operations.Deposit memory op = Operations.readDepositPubdata(depositPubdata);
bytes22 packedBalanceKey = packAddressAndTokenId(op.owner, uint16(op.tokenId));
pendingBalances[packedBalanceKey].balanceToWithdraw += op.amount;
}
delete priorityRequests[id];
}
firstPriorityRequestId += toProcess;
totalOpenPriorityRequests -= toProcess;
}
uint256 internal constant SECURITY_COUNCIL_THRESHOLD = 9;
/// @notice processing new approval of decrease upgrade notice period time to zero
/// @param addr address of the account that approved the reduction of the upgrade notice period to zero
/// NOTE: does NOT revert if the address is not a security council member or number of approvals is already sufficient
function approveCutUpgradeNoticePeriod(address addr) internal {
}
/// @notice approve to decrease upgrade notice period time to zero
/// NOTE: сan only be called after the start of the upgrade
function cutUpgradeNoticePeriod(bytes32 targetsHash) external {
}
/// @notice approve to decrease upgrade notice period time to zero by signatures
/// NOTE: Can accept many signatures at a time, thus it is possible
/// to completely cut the upgrade notice period in one transaction
function cutUpgradeNoticePeriodBySignature(bytes[] calldata signatures) external {
}
/// @return hash of the concatenation of targets for which there is an upgrade
/// NOTE: revert if upgrade is not active at this moment
function getUpgradeTargetsHash() internal returns (bytes32) {
}
/// @notice Set data for changing pubkey hash using onchain authorization.
/// Transaction author (msg.sender) should be L2 account address
/// @notice New pubkey hash can be reset, to do that user should send two transactions:
/// 1) First `setAuthPubkeyHash` transaction for already used `_nonce` will set timer.
/// 2) After `AUTH_FACT_RESET_TIMELOCK` time is passed second `setAuthPubkeyHash` transaction will reset pubkey hash for `_nonce`.
/// @param _pubkeyHash New pubkey hash
/// @param _nonce Nonce of the change pubkey L2 transaction
function setAuthPubkeyHash(bytes calldata _pubkeyHash, uint32 _nonce) external {
}
/// @notice Reverts unverified blocks
function revertBlocks(StoredBlockInfo[] calldata _blocksToRevert) external {
}
}
| Utils.hashBytesToBytes20(depositPubdata)==priorityRequests[id].hashedPubData,"a" | 264,523 | Utils.hashBytesToBytes20(depositPubdata)==priorityRequests[id].hashedPubData |
"p3" | pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
// SPDX-License-Identifier: MIT OR Apache-2.0
import "./ReentrancyGuard.sol";
import "./SafeMath.sol";
import "./SafeMathUInt128.sol";
import "./SafeCast.sol";
import "./Utils.sol";
import "./Storage.sol";
import "./Config.sol";
import "./Events.sol";
import "./Bytes.sol";
import "./Operations.sol";
import "./UpgradeableMaster.sol";
/// @title zkSync additional main contract
/// @author Matter Labs
contract AdditionalZkSync is Storage, Config, Events, ReentrancyGuard {
using SafeMath for uint256;
using SafeMathUInt128 for uint128;
function increaseBalanceToWithdraw(bytes22 _packedBalanceKey, uint128 _amount) internal {
}
/// @notice Withdraws token from ZkSync to root chain in case of exodus mode. User must provide proof that he owns funds
/// @param _storedBlockInfo Last verified block
/// @param _owner Owner of the account
/// @param _accountId Id of the account in the tree
/// @param _proof Proof
/// @param _tokenId Verified token id
/// @param _amount Amount for owner (must be total amount, not part of it)
function performExodus(
StoredBlockInfo memory _storedBlockInfo,
address _owner,
uint32 _accountId,
uint32 _tokenId,
uint128 _amount,
uint32 _nftCreatorAccountId,
address _nftCreatorAddress,
uint32 _nftSerialId,
bytes32 _nftContentHash,
uint256[] calldata _proof
) external {
}
function cancelOutstandingDepositsForExodusMode(uint64 _n, bytes[] calldata _depositsPubdata) external {
}
uint256 internal constant SECURITY_COUNCIL_THRESHOLD = 9;
/// @notice processing new approval of decrease upgrade notice period time to zero
/// @param addr address of the account that approved the reduction of the upgrade notice period to zero
/// NOTE: does NOT revert if the address is not a security council member or number of approvals is already sufficient
function approveCutUpgradeNoticePeriod(address addr) internal {
}
/// @notice approve to decrease upgrade notice period time to zero
/// NOTE: сan only be called after the start of the upgrade
function cutUpgradeNoticePeriod(bytes32 targetsHash) external {
require(upgradeStartTimestamp != 0, "p1");
require(<FILL_ME>) // given targets are not in the active upgrade
approveCutUpgradeNoticePeriod(msg.sender);
}
/// @notice approve to decrease upgrade notice period time to zero by signatures
/// NOTE: Can accept many signatures at a time, thus it is possible
/// to completely cut the upgrade notice period in one transaction
function cutUpgradeNoticePeriodBySignature(bytes[] calldata signatures) external {
}
/// @return hash of the concatenation of targets for which there is an upgrade
/// NOTE: revert if upgrade is not active at this moment
function getUpgradeTargetsHash() internal returns (bytes32) {
}
/// @notice Set data for changing pubkey hash using onchain authorization.
/// Transaction author (msg.sender) should be L2 account address
/// @notice New pubkey hash can be reset, to do that user should send two transactions:
/// 1) First `setAuthPubkeyHash` transaction for already used `_nonce` will set timer.
/// 2) After `AUTH_FACT_RESET_TIMELOCK` time is passed second `setAuthPubkeyHash` transaction will reset pubkey hash for `_nonce`.
/// @param _pubkeyHash New pubkey hash
/// @param _nonce Nonce of the change pubkey L2 transaction
function setAuthPubkeyHash(bytes calldata _pubkeyHash, uint32 _nonce) external {
}
/// @notice Reverts unverified blocks
function revertBlocks(StoredBlockInfo[] calldata _blocksToRevert) external {
}
}
| getUpgradeTargetsHash()==targetsHash,"p3" | 264,523 | getUpgradeTargetsHash()==targetsHash |
"p5" | pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
// SPDX-License-Identifier: MIT OR Apache-2.0
import "./ReentrancyGuard.sol";
import "./SafeMath.sol";
import "./SafeMathUInt128.sol";
import "./SafeCast.sol";
import "./Utils.sol";
import "./Storage.sol";
import "./Config.sol";
import "./Events.sol";
import "./Bytes.sol";
import "./Operations.sol";
import "./UpgradeableMaster.sol";
/// @title zkSync additional main contract
/// @author Matter Labs
contract AdditionalZkSync is Storage, Config, Events, ReentrancyGuard {
using SafeMath for uint256;
using SafeMathUInt128 for uint128;
function increaseBalanceToWithdraw(bytes22 _packedBalanceKey, uint128 _amount) internal {
}
/// @notice Withdraws token from ZkSync to root chain in case of exodus mode. User must provide proof that he owns funds
/// @param _storedBlockInfo Last verified block
/// @param _owner Owner of the account
/// @param _accountId Id of the account in the tree
/// @param _proof Proof
/// @param _tokenId Verified token id
/// @param _amount Amount for owner (must be total amount, not part of it)
function performExodus(
StoredBlockInfo memory _storedBlockInfo,
address _owner,
uint32 _accountId,
uint32 _tokenId,
uint128 _amount,
uint32 _nftCreatorAccountId,
address _nftCreatorAddress,
uint32 _nftSerialId,
bytes32 _nftContentHash,
uint256[] calldata _proof
) external {
}
function cancelOutstandingDepositsForExodusMode(uint64 _n, bytes[] calldata _depositsPubdata) external {
}
uint256 internal constant SECURITY_COUNCIL_THRESHOLD = 9;
/// @notice processing new approval of decrease upgrade notice period time to zero
/// @param addr address of the account that approved the reduction of the upgrade notice period to zero
/// NOTE: does NOT revert if the address is not a security council member or number of approvals is already sufficient
function approveCutUpgradeNoticePeriod(address addr) internal {
}
/// @notice approve to decrease upgrade notice period time to zero
/// NOTE: сan only be called after the start of the upgrade
function cutUpgradeNoticePeriod(bytes32 targetsHash) external {
}
/// @notice approve to decrease upgrade notice period time to zero by signatures
/// NOTE: Can accept many signatures at a time, thus it is possible
/// to completely cut the upgrade notice period in one transaction
function cutUpgradeNoticePeriodBySignature(bytes[] calldata signatures) external {
}
/// @return hash of the concatenation of targets for which there is an upgrade
/// NOTE: revert if upgrade is not active at this moment
function getUpgradeTargetsHash() internal returns (bytes32) {
// Get the addresses of contracts that are being prepared for the upgrade.
address gatekeeper = 0x38A43F4330f24fe920F943409709fc9A6084C939;
(bool success0, bytes memory newTarget0) = gatekeeper.staticcall(
abi.encodeWithSignature("nextTargets(uint256)", 0)
);
(bool success1, bytes memory newTarget1) = gatekeeper.staticcall(
abi.encodeWithSignature("nextTargets(uint256)", 1)
);
(bool success2, bytes memory newTarget2) = gatekeeper.staticcall(
abi.encodeWithSignature("nextTargets(uint256)", 2)
);
require(<FILL_ME>) // failed to get new targets
address newTargetAddress0 = abi.decode(newTarget0, (address));
address newTargetAddress1 = abi.decode(newTarget1, (address));
address newTargetAddress2 = abi.decode(newTarget2, (address));
return keccak256(abi.encodePacked(newTargetAddress0, newTargetAddress1, newTargetAddress2));
}
/// @notice Set data for changing pubkey hash using onchain authorization.
/// Transaction author (msg.sender) should be L2 account address
/// @notice New pubkey hash can be reset, to do that user should send two transactions:
/// 1) First `setAuthPubkeyHash` transaction for already used `_nonce` will set timer.
/// 2) After `AUTH_FACT_RESET_TIMELOCK` time is passed second `setAuthPubkeyHash` transaction will reset pubkey hash for `_nonce`.
/// @param _pubkeyHash New pubkey hash
/// @param _nonce Nonce of the change pubkey L2 transaction
function setAuthPubkeyHash(bytes calldata _pubkeyHash, uint32 _nonce) external {
}
/// @notice Reverts unverified blocks
function revertBlocks(StoredBlockInfo[] calldata _blocksToRevert) external {
}
}
| success0&&success1&&success2,"p5" | 264,523 | success0&&success1&&success2 |
"z" | pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
// SPDX-License-Identifier: MIT OR Apache-2.0
import "./ReentrancyGuard.sol";
import "./SafeMath.sol";
import "./SafeMathUInt128.sol";
import "./SafeCast.sol";
import "./Utils.sol";
import "./Storage.sol";
import "./Config.sol";
import "./Events.sol";
import "./Bytes.sol";
import "./Operations.sol";
import "./UpgradeableMaster.sol";
/// @title zkSync additional main contract
/// @author Matter Labs
contract AdditionalZkSync is Storage, Config, Events, ReentrancyGuard {
using SafeMath for uint256;
using SafeMathUInt128 for uint128;
function increaseBalanceToWithdraw(bytes22 _packedBalanceKey, uint128 _amount) internal {
}
/// @notice Withdraws token from ZkSync to root chain in case of exodus mode. User must provide proof that he owns funds
/// @param _storedBlockInfo Last verified block
/// @param _owner Owner of the account
/// @param _accountId Id of the account in the tree
/// @param _proof Proof
/// @param _tokenId Verified token id
/// @param _amount Amount for owner (must be total amount, not part of it)
function performExodus(
StoredBlockInfo memory _storedBlockInfo,
address _owner,
uint32 _accountId,
uint32 _tokenId,
uint128 _amount,
uint32 _nftCreatorAccountId,
address _nftCreatorAddress,
uint32 _nftSerialId,
bytes32 _nftContentHash,
uint256[] calldata _proof
) external {
}
function cancelOutstandingDepositsForExodusMode(uint64 _n, bytes[] calldata _depositsPubdata) external {
}
uint256 internal constant SECURITY_COUNCIL_THRESHOLD = 9;
/// @notice processing new approval of decrease upgrade notice period time to zero
/// @param addr address of the account that approved the reduction of the upgrade notice period to zero
/// NOTE: does NOT revert if the address is not a security council member or number of approvals is already sufficient
function approveCutUpgradeNoticePeriod(address addr) internal {
}
/// @notice approve to decrease upgrade notice period time to zero
/// NOTE: сan only be called after the start of the upgrade
function cutUpgradeNoticePeriod(bytes32 targetsHash) external {
}
/// @notice approve to decrease upgrade notice period time to zero by signatures
/// NOTE: Can accept many signatures at a time, thus it is possible
/// to completely cut the upgrade notice period in one transaction
function cutUpgradeNoticePeriodBySignature(bytes[] calldata signatures) external {
}
/// @return hash of the concatenation of targets for which there is an upgrade
/// NOTE: revert if upgrade is not active at this moment
function getUpgradeTargetsHash() internal returns (bytes32) {
}
/// @notice Set data for changing pubkey hash using onchain authorization.
/// Transaction author (msg.sender) should be L2 account address
/// @notice New pubkey hash can be reset, to do that user should send two transactions:
/// 1) First `setAuthPubkeyHash` transaction for already used `_nonce` will set timer.
/// 2) After `AUTH_FACT_RESET_TIMELOCK` time is passed second `setAuthPubkeyHash` transaction will reset pubkey hash for `_nonce`.
/// @param _pubkeyHash New pubkey hash
/// @param _nonce Nonce of the change pubkey L2 transaction
function setAuthPubkeyHash(bytes calldata _pubkeyHash, uint32 _nonce) external {
requireActive();
require(_pubkeyHash.length == PUBKEY_HASH_BYTES, "y"); // PubKeyHash should be 20 bytes.
if (authFacts[msg.sender][_nonce] == bytes32(0)) {
authFacts[msg.sender][_nonce] = keccak256(_pubkeyHash);
} else {
uint256 currentResetTimer = authFactsResetTimer[msg.sender][_nonce];
if (currentResetTimer == 0) {
authFactsResetTimer[msg.sender][_nonce] = block.timestamp;
} else {
require(<FILL_ME>)
authFactsResetTimer[msg.sender][_nonce] = 0;
authFacts[msg.sender][_nonce] = keccak256(_pubkeyHash);
}
}
}
/// @notice Reverts unverified blocks
function revertBlocks(StoredBlockInfo[] calldata _blocksToRevert) external {
}
}
| block.timestamp.sub(currentResetTimer)>=AUTH_FACT_RESET_TIMELOCK,"z" | 264,523 | block.timestamp.sub(currentResetTimer)>=AUTH_FACT_RESET_TIMELOCK |
"r" | pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
// SPDX-License-Identifier: MIT OR Apache-2.0
import "./ReentrancyGuard.sol";
import "./SafeMath.sol";
import "./SafeMathUInt128.sol";
import "./SafeCast.sol";
import "./Utils.sol";
import "./Storage.sol";
import "./Config.sol";
import "./Events.sol";
import "./Bytes.sol";
import "./Operations.sol";
import "./UpgradeableMaster.sol";
/// @title zkSync additional main contract
/// @author Matter Labs
contract AdditionalZkSync is Storage, Config, Events, ReentrancyGuard {
using SafeMath for uint256;
using SafeMathUInt128 for uint128;
function increaseBalanceToWithdraw(bytes22 _packedBalanceKey, uint128 _amount) internal {
}
/// @notice Withdraws token from ZkSync to root chain in case of exodus mode. User must provide proof that he owns funds
/// @param _storedBlockInfo Last verified block
/// @param _owner Owner of the account
/// @param _accountId Id of the account in the tree
/// @param _proof Proof
/// @param _tokenId Verified token id
/// @param _amount Amount for owner (must be total amount, not part of it)
function performExodus(
StoredBlockInfo memory _storedBlockInfo,
address _owner,
uint32 _accountId,
uint32 _tokenId,
uint128 _amount,
uint32 _nftCreatorAccountId,
address _nftCreatorAddress,
uint32 _nftSerialId,
bytes32 _nftContentHash,
uint256[] calldata _proof
) external {
}
function cancelOutstandingDepositsForExodusMode(uint64 _n, bytes[] calldata _depositsPubdata) external {
}
uint256 internal constant SECURITY_COUNCIL_THRESHOLD = 9;
/// @notice processing new approval of decrease upgrade notice period time to zero
/// @param addr address of the account that approved the reduction of the upgrade notice period to zero
/// NOTE: does NOT revert if the address is not a security council member or number of approvals is already sufficient
function approveCutUpgradeNoticePeriod(address addr) internal {
}
/// @notice approve to decrease upgrade notice period time to zero
/// NOTE: сan only be called after the start of the upgrade
function cutUpgradeNoticePeriod(bytes32 targetsHash) external {
}
/// @notice approve to decrease upgrade notice period time to zero by signatures
/// NOTE: Can accept many signatures at a time, thus it is possible
/// to completely cut the upgrade notice period in one transaction
function cutUpgradeNoticePeriodBySignature(bytes[] calldata signatures) external {
}
/// @return hash of the concatenation of targets for which there is an upgrade
/// NOTE: revert if upgrade is not active at this moment
function getUpgradeTargetsHash() internal returns (bytes32) {
}
/// @notice Set data for changing pubkey hash using onchain authorization.
/// Transaction author (msg.sender) should be L2 account address
/// @notice New pubkey hash can be reset, to do that user should send two transactions:
/// 1) First `setAuthPubkeyHash` transaction for already used `_nonce` will set timer.
/// 2) After `AUTH_FACT_RESET_TIMELOCK` time is passed second `setAuthPubkeyHash` transaction will reset pubkey hash for `_nonce`.
/// @param _pubkeyHash New pubkey hash
/// @param _nonce Nonce of the change pubkey L2 transaction
function setAuthPubkeyHash(bytes calldata _pubkeyHash, uint32 _nonce) external {
}
/// @notice Reverts unverified blocks
function revertBlocks(StoredBlockInfo[] calldata _blocksToRevert) external {
requireActive();
governance.requireActiveValidator(msg.sender);
uint32 blocksCommitted = totalBlocksCommitted;
uint32 blocksToRevert = Utils.minU32(uint32(_blocksToRevert.length), blocksCommitted - totalBlocksExecuted);
uint64 revertedPriorityRequests = 0;
for (uint32 i = 0; i < blocksToRevert; ++i) {
StoredBlockInfo memory storedBlockInfo = _blocksToRevert[i];
require(<FILL_ME>) // incorrect stored block info
delete storedBlockHashes[blocksCommitted];
--blocksCommitted;
revertedPriorityRequests += storedBlockInfo.priorityOperations;
}
totalBlocksCommitted = blocksCommitted;
totalCommittedPriorityRequests -= revertedPriorityRequests;
if (totalBlocksCommitted < totalBlocksProven) {
totalBlocksProven = totalBlocksCommitted;
}
emit BlocksRevert(totalBlocksExecuted, blocksCommitted);
}
}
| storedBlockHashes[blocksCommitted]==hashStoredBlockInfo(storedBlockInfo),"r" | 264,523 | storedBlockHashes[blocksCommitted]==hashStoredBlockInfo(storedBlockInfo) |
"Token transfer failed" | /**
*Submitted for verification at Etherscan.io on 2023-07-22
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;
interface IERC20 {
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
/**
* @dev Returns the value of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the value of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves a `value` amount of tokens from the caller's account to `to`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address to, uint256 value) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender)
external
view
returns (uint256);
/**
* @dev Sets a `value` amount of tokens as the allowance of `spender` over the
* caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 value) external returns (bool);
/**
* @dev Moves a `value` amount of tokens from `from` to `to` using the
* allowance mechanism. `value` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address from,
address to,
uint256 value
) external returns (bool);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface AggregatorV3Interface {
function decimals() external view returns (uint8);
function description() external view returns (string memory);
function version() external view returns (uint256);
function getRoundData(uint80 _roundId)
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
function latestRoundData()
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
}
contract presale is Ownable {
AggregatorV3Interface internal priceFeed;
uint256[] public priceperusd = [
16670000000000000000,
12500000000000000000,
10000000000000000000
];
uint256[] public tokenlimit = [
18000000000000000000000000,
27000000000000000000000000,
15000000000000000000000000
];
uint256 public constant totalTokenAmount = 60000000000000000000000000;
uint256 public constant stages = 6; // Number Of Stages
uint256 public tokenAmountPerStage;
uint256 public lastStagetime;
uint256 public stage = 0;
uint256 public tokenSold = 0;
IERC20 public MIST = IERC20(0xE14Eaf34827ba4E191215b35005373014A6DCDFC);
mapping(address => Purchase[]) public purchases;
mapping(address => uint256) public referralBalances;
struct Purchase {
uint256 stage;
uint256 amount;
bool claimed;
}
bool public isPresaleOpen = true;
bool public isClaimable = false;
constructor() {
}
function getLatestPriceETH() public view returns (int256) {
}
function PurchaseWithETH() public payable {
int256 latestPrice = getLatestPriceETH();
uint256 nativeprice = uint256(latestPrice);
require(isPresaleOpen, "Presale end");
uint256 maxETHAllowred = msg.value * nativeprice;
require(maxETHAllowred <= 1000000000000000000000 , "Maximun of 1000 USDT/ETH Allowed");
uint256 tokensToBuy = msg.value * (priceperusd[stage] * nativeprice);
tokenSold += (tokensToBuy / 1000000000000000000);
purchases[msg.sender].push(
Purchase(stage, tokensToBuy / 1000000000000000000, false)
);
if (tokenSold >= tokenlimit[stage]) {
stage++;
tokenSold = 0;
lastStagetime = block.timestamp;
}
require(<FILL_ME>)
address payable owner = payable(owner());
owner.transfer(msg.value);
}
function getPurchaseInfo(address walletAddress)
public
view
returns (Purchase[] memory)
{
}
function EndPresale(bool status) public onlyOwner {
}
function withdrawLeftover() external onlyOwner {
}
}
| MIST.transfer(msg.sender,tokensToBuy/1000000000000000000),"Token transfer failed" | 264,601 | MIST.transfer(msg.sender,tokensToBuy/1000000000000000000) |
"Total Fee should be less than 20" | /**
https://t.me/AkitaInuETH
*/
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract AKITA is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Akita Inu";
string private constant _symbol = "AKITA";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 0;
uint256 private _taxFeeOnBuy = 6;
uint256 private _redisFeeOnSell = 0;
uint256 private _taxFeeOnSell = 6;
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
mapping(address => bool) public bots; mapping (address => uint256) public _buyMap;
address payable private _developmentAddress = payable(0x3bA319913d1668aa5Ec0D7428ad4703612D8315D);
address payable private _marketingAddress = payable(0x3bA319913d1668aa5Ec0D7428ad4703612D8315D);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen = true;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = 20000000 * 10**9;
uint256 public _maxWalletSize = 20000000 * 10**9;
uint256 public _swapTokensAtAmount = 1000000 * 10**9;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function manualswap() external {
}
function manualsend() external {
}
function blockBots(address[] memory bots_) public onlyOwner {
}
function unblockBot(address notbot) public onlyOwner {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function setFee(uint256 redisFeeOnBuy, uint256 redisFeeOnSell, uint256 taxFeeOnBuy, uint256 taxFeeOnSell) public onlyOwner {
_redisFeeOnBuy = redisFeeOnBuy;
_redisFeeOnSell = redisFeeOnSell;
_taxFeeOnBuy = taxFeeOnBuy;
_taxFeeOnSell = taxFeeOnSell;
require(<FILL_ME>)
}
//Set minimum tokens required to swap.
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
//Set minimum tokens required to swap.
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
//Set maximum transaction
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
}
}
| _redisFeeOnBuy+_redisFeeOnSell+_taxFeeOnBuy+_taxFeeOnSell<=20,"Total Fee should be less than 20" | 264,617 | _redisFeeOnBuy+_redisFeeOnSell+_taxFeeOnBuy+_taxFeeOnSell<=20 |
"max NFT per mint amount exceeded" | // SPDX-License-Identifier: MIT
// Copyright (c) 2022 Kenchiro.
// Source code forked from Keisuke OHNO.
/*
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
pragma solidity >=0.7.0 <0.9.0;
import 'erc721a/contracts/ERC721A.sol';
import "@openzeppelin/contracts/access/Ownable.sol";
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
contract Gadget_Pants_Jeneico is ERC721A, Ownable {
address public withdrawAddress;
string baseURI;
string public baseExtension = ".json";
uint256 public cost = 0.001 ether; //★
uint256 public maxSupply = 8282; //★
uint8 public saleStage = 0; //現在のセール内容
//0 : consruct paused
//1 : WL Sale
//2 : Public Sale
//3 : BurnMint Sale
uint256 public maxPubSaleMintAmount = 10;
mapping(address => uint256) public publicMintedAmount;
uint8 constant MAX_WL_SALE = 30; //WLセール最大回数
uint8 public wlSaleCount = 0; //1回目のセールが0
uint8[MAX_WL_SALE] public maxWLMintAmount; //wlSaleCountごとのMint枚数
bytes32[MAX_WL_SALE] public WLMearkleRoot; //wlSaleCountに応じたMearkleRoot
mapping(address => uint8[MAX_WL_SALE]) public WLMintedAmount; //アドレスに対してwlSaleCountに応じたmint枚数を格納
uint256 public maxBmSupply = 500; //★BMで何体出すか
uint256 public totalBmSupply = 0; //BMで何体出たか
constructor(
) ERC721A("Gadget_Pants_Jeneico", "GPJ") {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
// public
function mint(uint256 _mintAmount) public payable {
uint256 supply = totalSupply();
require(_mintAmount > 0, "need to mint at least 1 NFT");
require(supply + _mintAmount <= maxSupply, "max NFT limit exceeded");
// Owner also can mint.
if (msg.sender != owner()) {
require(saleStage == 2, "the contract is not Public Sale");
require(_mintAmount <= maxPubSaleMintAmount, "max mint amount per session exceeded");
require(<FILL_ME>)
require(msg.value >= cost * _mintAmount, "insufficient funds");
}
_safeMint(msg.sender, _mintAmount);
}
function wl_mint(uint8 _mintAmount, bytes32[] calldata _merkleProof) public payable {
}
function burnMint(uint256[] memory _burnTokenIds, bytes32[] calldata _merkleProof) external payable {
}
function airdropMint(address[] calldata _airdropAddresses , uint256[] memory _UserMintAmount) public onlyOwner{
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function isWhitelisted(address _user, bytes32[] calldata _merkleProof) public view returns (bool) {
}
//only owner
function setCost(uint256 _newCost) public onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner {
}
function setmaxPubSaleMintAmount(uint256 _newmaxPubSaleMintAmount) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setSaleStage(uint8 _saleStage) public onlyOwner {
}
function setWithdrawAddress(address _withdrawAddress) public onlyOwner {
}
//WL
function setMaxWLMintAmount(uint256 _wlSaleCount, uint8 _maxWLMintAmount) public onlyOwner{
}
function setWLMearkleRoot(uint256 _wlSaleCount, bytes32 _wlMearkleRoot) public onlyOwner{
}
function setWlSaleCount(uint8 _wlSaleCount) public onlyOwner{
}
//Burn-Mint
function setMaxBmSupply(uint256 _maxBmSupply) public onlyOwner {
}
//Other
function withdraw() public payable onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
}
| publicMintedAmount[msg.sender]+_mintAmount<=maxPubSaleMintAmount,"max NFT per mint amount exceeded" | 264,638 | publicMintedAmount[msg.sender]+_mintAmount<=maxPubSaleMintAmount |
"You don't have WL." | // SPDX-License-Identifier: MIT
// Copyright (c) 2022 Kenchiro.
// Source code forked from Keisuke OHNO.
/*
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
pragma solidity >=0.7.0 <0.9.0;
import 'erc721a/contracts/ERC721A.sol';
import "@openzeppelin/contracts/access/Ownable.sol";
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
contract Gadget_Pants_Jeneico is ERC721A, Ownable {
address public withdrawAddress;
string baseURI;
string public baseExtension = ".json";
uint256 public cost = 0.001 ether; //★
uint256 public maxSupply = 8282; //★
uint8 public saleStage = 0; //現在のセール内容
//0 : consruct paused
//1 : WL Sale
//2 : Public Sale
//3 : BurnMint Sale
uint256 public maxPubSaleMintAmount = 10;
mapping(address => uint256) public publicMintedAmount;
uint8 constant MAX_WL_SALE = 30; //WLセール最大回数
uint8 public wlSaleCount = 0; //1回目のセールが0
uint8[MAX_WL_SALE] public maxWLMintAmount; //wlSaleCountごとのMint枚数
bytes32[MAX_WL_SALE] public WLMearkleRoot; //wlSaleCountに応じたMearkleRoot
mapping(address => uint8[MAX_WL_SALE]) public WLMintedAmount; //アドレスに対してwlSaleCountに応じたmint枚数を格納
uint256 public maxBmSupply = 500; //★BMで何体出すか
uint256 public totalBmSupply = 0; //BMで何体出たか
constructor(
) ERC721A("Gadget_Pants_Jeneico", "GPJ") {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
// public
function mint(uint256 _mintAmount) public payable {
}
function wl_mint(uint8 _mintAmount, bytes32[] calldata _merkleProof) public payable {
uint256 supply = totalSupply();
require(_mintAmount > 0, "need to mint at least 1 NFT");
require(supply + _mintAmount <= maxSupply, "max NFT limit exceeded");
if (msg.sender != owner()) {
require(saleStage == 1, "the contract is not WL Sale");
require(_mintAmount <= maxWLMintAmount[wlSaleCount], "max mint amount per session exceeded");
require(<FILL_ME>)
require(WLMintedAmount[msg.sender][wlSaleCount] + _mintAmount <= maxWLMintAmount[wlSaleCount], "max NFT per address exceeded");
require(msg.value >= cost * _mintAmount, "insufficient funds. : Wl mint");
WLMintedAmount[msg.sender][wlSaleCount] += _mintAmount;
}
_safeMint(msg.sender, _mintAmount);
}
function burnMint(uint256[] memory _burnTokenIds, bytes32[] calldata _merkleProof) external payable {
}
function airdropMint(address[] calldata _airdropAddresses , uint256[] memory _UserMintAmount) public onlyOwner{
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function isWhitelisted(address _user, bytes32[] calldata _merkleProof) public view returns (bool) {
}
//only owner
function setCost(uint256 _newCost) public onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner {
}
function setmaxPubSaleMintAmount(uint256 _newmaxPubSaleMintAmount) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setSaleStage(uint8 _saleStage) public onlyOwner {
}
function setWithdrawAddress(address _withdrawAddress) public onlyOwner {
}
//WL
function setMaxWLMintAmount(uint256 _wlSaleCount, uint8 _maxWLMintAmount) public onlyOwner{
}
function setWLMearkleRoot(uint256 _wlSaleCount, bytes32 _wlMearkleRoot) public onlyOwner{
}
function setWlSaleCount(uint8 _wlSaleCount) public onlyOwner{
}
//Burn-Mint
function setMaxBmSupply(uint256 _maxBmSupply) public onlyOwner {
}
//Other
function withdraw() public payable onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
}
| isWhitelisted(msg.sender,_merkleProof),"You don't have WL." | 264,638 | isWhitelisted(msg.sender,_merkleProof) |
"max NFT per address exceeded" | // SPDX-License-Identifier: MIT
// Copyright (c) 2022 Kenchiro.
// Source code forked from Keisuke OHNO.
/*
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
pragma solidity >=0.7.0 <0.9.0;
import 'erc721a/contracts/ERC721A.sol';
import "@openzeppelin/contracts/access/Ownable.sol";
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
contract Gadget_Pants_Jeneico is ERC721A, Ownable {
address public withdrawAddress;
string baseURI;
string public baseExtension = ".json";
uint256 public cost = 0.001 ether; //★
uint256 public maxSupply = 8282; //★
uint8 public saleStage = 0; //現在のセール内容
//0 : consruct paused
//1 : WL Sale
//2 : Public Sale
//3 : BurnMint Sale
uint256 public maxPubSaleMintAmount = 10;
mapping(address => uint256) public publicMintedAmount;
uint8 constant MAX_WL_SALE = 30; //WLセール最大回数
uint8 public wlSaleCount = 0; //1回目のセールが0
uint8[MAX_WL_SALE] public maxWLMintAmount; //wlSaleCountごとのMint枚数
bytes32[MAX_WL_SALE] public WLMearkleRoot; //wlSaleCountに応じたMearkleRoot
mapping(address => uint8[MAX_WL_SALE]) public WLMintedAmount; //アドレスに対してwlSaleCountに応じたmint枚数を格納
uint256 public maxBmSupply = 500; //★BMで何体出すか
uint256 public totalBmSupply = 0; //BMで何体出たか
constructor(
) ERC721A("Gadget_Pants_Jeneico", "GPJ") {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
// public
function mint(uint256 _mintAmount) public payable {
}
function wl_mint(uint8 _mintAmount, bytes32[] calldata _merkleProof) public payable {
uint256 supply = totalSupply();
require(_mintAmount > 0, "need to mint at least 1 NFT");
require(supply + _mintAmount <= maxSupply, "max NFT limit exceeded");
if (msg.sender != owner()) {
require(saleStage == 1, "the contract is not WL Sale");
require(_mintAmount <= maxWLMintAmount[wlSaleCount], "max mint amount per session exceeded");
require(isWhitelisted(msg.sender, _merkleProof), "You don't have WL.");
require(<FILL_ME>)
require(msg.value >= cost * _mintAmount, "insufficient funds. : Wl mint");
WLMintedAmount[msg.sender][wlSaleCount] += _mintAmount;
}
_safeMint(msg.sender, _mintAmount);
}
function burnMint(uint256[] memory _burnTokenIds, bytes32[] calldata _merkleProof) external payable {
}
function airdropMint(address[] calldata _airdropAddresses , uint256[] memory _UserMintAmount) public onlyOwner{
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function isWhitelisted(address _user, bytes32[] calldata _merkleProof) public view returns (bool) {
}
//only owner
function setCost(uint256 _newCost) public onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner {
}
function setmaxPubSaleMintAmount(uint256 _newmaxPubSaleMintAmount) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setSaleStage(uint8 _saleStage) public onlyOwner {
}
function setWithdrawAddress(address _withdrawAddress) public onlyOwner {
}
//WL
function setMaxWLMintAmount(uint256 _wlSaleCount, uint8 _maxWLMintAmount) public onlyOwner{
}
function setWLMearkleRoot(uint256 _wlSaleCount, bytes32 _wlMearkleRoot) public onlyOwner{
}
function setWlSaleCount(uint8 _wlSaleCount) public onlyOwner{
}
//Burn-Mint
function setMaxBmSupply(uint256 _maxBmSupply) public onlyOwner {
}
//Other
function withdraw() public payable onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
}
| WLMintedAmount[msg.sender][wlSaleCount]+_mintAmount<=maxWLMintAmount[wlSaleCount],"max NFT per address exceeded" | 264,638 | WLMintedAmount[msg.sender][wlSaleCount]+_mintAmount<=maxWLMintAmount[wlSaleCount] |
"Max Burn mint Supply over!" | // SPDX-License-Identifier: MIT
// Copyright (c) 2022 Kenchiro.
// Source code forked from Keisuke OHNO.
/*
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
pragma solidity >=0.7.0 <0.9.0;
import 'erc721a/contracts/ERC721A.sol';
import "@openzeppelin/contracts/access/Ownable.sol";
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
contract Gadget_Pants_Jeneico is ERC721A, Ownable {
address public withdrawAddress;
string baseURI;
string public baseExtension = ".json";
uint256 public cost = 0.001 ether; //★
uint256 public maxSupply = 8282; //★
uint8 public saleStage = 0; //現在のセール内容
//0 : consruct paused
//1 : WL Sale
//2 : Public Sale
//3 : BurnMint Sale
uint256 public maxPubSaleMintAmount = 10;
mapping(address => uint256) public publicMintedAmount;
uint8 constant MAX_WL_SALE = 30; //WLセール最大回数
uint8 public wlSaleCount = 0; //1回目のセールが0
uint8[MAX_WL_SALE] public maxWLMintAmount; //wlSaleCountごとのMint枚数
bytes32[MAX_WL_SALE] public WLMearkleRoot; //wlSaleCountに応じたMearkleRoot
mapping(address => uint8[MAX_WL_SALE]) public WLMintedAmount; //アドレスに対してwlSaleCountに応じたmint枚数を格納
uint256 public maxBmSupply = 500; //★BMで何体出すか
uint256 public totalBmSupply = 0; //BMで何体出たか
constructor(
) ERC721A("Gadget_Pants_Jeneico", "GPJ") {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
// public
function mint(uint256 _mintAmount) public payable {
}
function wl_mint(uint8 _mintAmount, bytes32[] calldata _merkleProof) public payable {
}
function burnMint(uint256[] memory _burnTokenIds, bytes32[] calldata _merkleProof) external payable {
require(_burnTokenIds.length > 0, "need to burn-mint at least 1 NFT");
require(<FILL_ME>)
if (msg.sender != owner()) {
require(saleStage == 3, "the contract is not BurnMint Sale");
require(_burnTokenIds.length <= maxWLMintAmount[wlSaleCount], "max burn mint amount per session exceeded");
require(isWhitelisted(msg.sender, _merkleProof), "You don't have BMWL.");
require(WLMintedAmount[msg.sender][wlSaleCount] + _burnTokenIds.length <= maxWLMintAmount[wlSaleCount], "max BM per address exceeded.");
require(msg.value >= cost * _burnTokenIds.length, "insufficient funds. : BM");
}
for (uint256 i = 0; i < _burnTokenIds.length; i++) {
uint256 tokenId = _burnTokenIds[i];
require(_msgSender() == ownerOf(tokenId), "you are not owner.");
totalBmSupply++;
_burn(tokenId);
}
WLMintedAmount[msg.sender][wlSaleCount] += (uint8)(_burnTokenIds.length);
_safeMint(msg.sender, _burnTokenIds.length);
}
function airdropMint(address[] calldata _airdropAddresses , uint256[] memory _UserMintAmount) public onlyOwner{
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function isWhitelisted(address _user, bytes32[] calldata _merkleProof) public view returns (bool) {
}
//only owner
function setCost(uint256 _newCost) public onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner {
}
function setmaxPubSaleMintAmount(uint256 _newmaxPubSaleMintAmount) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setSaleStage(uint8 _saleStage) public onlyOwner {
}
function setWithdrawAddress(address _withdrawAddress) public onlyOwner {
}
//WL
function setMaxWLMintAmount(uint256 _wlSaleCount, uint8 _maxWLMintAmount) public onlyOwner{
}
function setWLMearkleRoot(uint256 _wlSaleCount, bytes32 _wlMearkleRoot) public onlyOwner{
}
function setWlSaleCount(uint8 _wlSaleCount) public onlyOwner{
}
//Burn-Mint
function setMaxBmSupply(uint256 _maxBmSupply) public onlyOwner {
}
//Other
function withdraw() public payable onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
}
| totalBmSupply+_burnTokenIds.length<=maxBmSupply,"Max Burn mint Supply over!" | 264,638 | totalBmSupply+_burnTokenIds.length<=maxBmSupply |
"max BM per address exceeded." | // SPDX-License-Identifier: MIT
// Copyright (c) 2022 Kenchiro.
// Source code forked from Keisuke OHNO.
/*
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
pragma solidity >=0.7.0 <0.9.0;
import 'erc721a/contracts/ERC721A.sol';
import "@openzeppelin/contracts/access/Ownable.sol";
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
contract Gadget_Pants_Jeneico is ERC721A, Ownable {
address public withdrawAddress;
string baseURI;
string public baseExtension = ".json";
uint256 public cost = 0.001 ether; //★
uint256 public maxSupply = 8282; //★
uint8 public saleStage = 0; //現在のセール内容
//0 : consruct paused
//1 : WL Sale
//2 : Public Sale
//3 : BurnMint Sale
uint256 public maxPubSaleMintAmount = 10;
mapping(address => uint256) public publicMintedAmount;
uint8 constant MAX_WL_SALE = 30; //WLセール最大回数
uint8 public wlSaleCount = 0; //1回目のセールが0
uint8[MAX_WL_SALE] public maxWLMintAmount; //wlSaleCountごとのMint枚数
bytes32[MAX_WL_SALE] public WLMearkleRoot; //wlSaleCountに応じたMearkleRoot
mapping(address => uint8[MAX_WL_SALE]) public WLMintedAmount; //アドレスに対してwlSaleCountに応じたmint枚数を格納
uint256 public maxBmSupply = 500; //★BMで何体出すか
uint256 public totalBmSupply = 0; //BMで何体出たか
constructor(
) ERC721A("Gadget_Pants_Jeneico", "GPJ") {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
// public
function mint(uint256 _mintAmount) public payable {
}
function wl_mint(uint8 _mintAmount, bytes32[] calldata _merkleProof) public payable {
}
function burnMint(uint256[] memory _burnTokenIds, bytes32[] calldata _merkleProof) external payable {
require(_burnTokenIds.length > 0, "need to burn-mint at least 1 NFT");
require(totalBmSupply + _burnTokenIds.length <= maxBmSupply, "Max Burn mint Supply over!");
if (msg.sender != owner()) {
require(saleStage == 3, "the contract is not BurnMint Sale");
require(_burnTokenIds.length <= maxWLMintAmount[wlSaleCount], "max burn mint amount per session exceeded");
require(isWhitelisted(msg.sender, _merkleProof), "You don't have BMWL.");
require(<FILL_ME>)
require(msg.value >= cost * _burnTokenIds.length, "insufficient funds. : BM");
}
for (uint256 i = 0; i < _burnTokenIds.length; i++) {
uint256 tokenId = _burnTokenIds[i];
require(_msgSender() == ownerOf(tokenId), "you are not owner.");
totalBmSupply++;
_burn(tokenId);
}
WLMintedAmount[msg.sender][wlSaleCount] += (uint8)(_burnTokenIds.length);
_safeMint(msg.sender, _burnTokenIds.length);
}
function airdropMint(address[] calldata _airdropAddresses , uint256[] memory _UserMintAmount) public onlyOwner{
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function isWhitelisted(address _user, bytes32[] calldata _merkleProof) public view returns (bool) {
}
//only owner
function setCost(uint256 _newCost) public onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner {
}
function setmaxPubSaleMintAmount(uint256 _newmaxPubSaleMintAmount) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setSaleStage(uint8 _saleStage) public onlyOwner {
}
function setWithdrawAddress(address _withdrawAddress) public onlyOwner {
}
//WL
function setMaxWLMintAmount(uint256 _wlSaleCount, uint8 _maxWLMintAmount) public onlyOwner{
}
function setWLMearkleRoot(uint256 _wlSaleCount, bytes32 _wlMearkleRoot) public onlyOwner{
}
function setWlSaleCount(uint8 _wlSaleCount) public onlyOwner{
}
//Burn-Mint
function setMaxBmSupply(uint256 _maxBmSupply) public onlyOwner {
}
//Other
function withdraw() public payable onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
}
| WLMintedAmount[msg.sender][wlSaleCount]+_burnTokenIds.length<=maxWLMintAmount[wlSaleCount],"max BM per address exceeded." | 264,638 | WLMintedAmount[msg.sender][wlSaleCount]+_burnTokenIds.length<=maxWLMintAmount[wlSaleCount] |
"max NFT limit exceeded" | // SPDX-License-Identifier: MIT
// Copyright (c) 2022 Kenchiro.
// Source code forked from Keisuke OHNO.
/*
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
pragma solidity >=0.7.0 <0.9.0;
import 'erc721a/contracts/ERC721A.sol';
import "@openzeppelin/contracts/access/Ownable.sol";
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
contract Gadget_Pants_Jeneico is ERC721A, Ownable {
address public withdrawAddress;
string baseURI;
string public baseExtension = ".json";
uint256 public cost = 0.001 ether; //★
uint256 public maxSupply = 8282; //★
uint8 public saleStage = 0; //現在のセール内容
//0 : consruct paused
//1 : WL Sale
//2 : Public Sale
//3 : BurnMint Sale
uint256 public maxPubSaleMintAmount = 10;
mapping(address => uint256) public publicMintedAmount;
uint8 constant MAX_WL_SALE = 30; //WLセール最大回数
uint8 public wlSaleCount = 0; //1回目のセールが0
uint8[MAX_WL_SALE] public maxWLMintAmount; //wlSaleCountごとのMint枚数
bytes32[MAX_WL_SALE] public WLMearkleRoot; //wlSaleCountに応じたMearkleRoot
mapping(address => uint8[MAX_WL_SALE]) public WLMintedAmount; //アドレスに対してwlSaleCountに応じたmint枚数を格納
uint256 public maxBmSupply = 500; //★BMで何体出すか
uint256 public totalBmSupply = 0; //BMで何体出たか
constructor(
) ERC721A("Gadget_Pants_Jeneico", "GPJ") {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
// public
function mint(uint256 _mintAmount) public payable {
}
function wl_mint(uint8 _mintAmount, bytes32[] calldata _merkleProof) public payable {
}
function burnMint(uint256[] memory _burnTokenIds, bytes32[] calldata _merkleProof) external payable {
}
function airdropMint(address[] calldata _airdropAddresses , uint256[] memory _UserMintAmount) public onlyOwner{
uint256 supply = totalSupply();
uint256 totalmintAmount = 0;
for (uint256 i = 0; i < _UserMintAmount.length; i++) {
totalmintAmount += _UserMintAmount[i];
}
require(totalmintAmount > 0, "need to mint at least 1 NFT");
require(<FILL_ME>)
for (uint256 i = 0; i < _UserMintAmount.length; i++) {
_safeMint(_airdropAddresses[i], _UserMintAmount[i] );
}
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function isWhitelisted(address _user, bytes32[] calldata _merkleProof) public view returns (bool) {
}
//only owner
function setCost(uint256 _newCost) public onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner {
}
function setmaxPubSaleMintAmount(uint256 _newmaxPubSaleMintAmount) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setSaleStage(uint8 _saleStage) public onlyOwner {
}
function setWithdrawAddress(address _withdrawAddress) public onlyOwner {
}
//WL
function setMaxWLMintAmount(uint256 _wlSaleCount, uint8 _maxWLMintAmount) public onlyOwner{
}
function setWLMearkleRoot(uint256 _wlSaleCount, bytes32 _wlMearkleRoot) public onlyOwner{
}
function setWlSaleCount(uint8 _wlSaleCount) public onlyOwner{
}
//Burn-Mint
function setMaxBmSupply(uint256 _maxBmSupply) public onlyOwner {
}
//Other
function withdraw() public payable onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
}
| supply+totalmintAmount<=maxSupply,"max NFT limit exceeded" | 264,638 | supply+totalmintAmount<=maxSupply |
null | // SPDX-License-Identifier: MIT
// @author: Exotic Technology LTD
pragma solidity ^0.8.0;
import "./ERC721.sol";
import "./ownable.sol";
import "./ERC721enumerable.sol";
import "./merkle.sol";
interface LVS{
function balanceOf(address owner) external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);
}
contract XOXO_By_Maya_and_Yehuda_Devir is Ownable, ERC721, ERC721Enumerable {
bool public saleIsActive = false;
bool public claim = false;
uint256 constant public claimToken = 101;
uint256 public claimed = 0;
uint256 constant public MAX_TOKEN = 10000;
uint256 constant public MAX_PUBLIC_MINT = 4;
uint256 public royalty = 80;
uint256 public ogPrice = 0.05 ether;
uint256 public lvPrice = 0.075 ether;
uint256 public tokenPrice = 0.101 ether;
uint256 public startingIndex = 0;
uint256 public startingIndexBlock = 0;
uint256 public SALE_START = 0;
address LVScontract;
bytes32 public ogMerkle = 0x6ee8bee8c77b05f5cf46ea9f7c98b6e3571366d95ccdb3f96be8640e43b6ec21;
bytes32 public lvMerkle = 0x6ee8bee8c77b05f5cf46ea9f7c98b6e3571366d95ccdb3f96be8640e43b6ec21;
string private _baseURIextended;
string public PROVENANCE;
mapping(address => uint) public minters;
mapping(address => bool) private senders;
mapping(uint => bool) private claimedTokens;
constructor() ERC721("XOXONFT", "XOXO") {
}
function addSender(address _address) public onlyOwner {
}
function removeSender(address _address) public onlyOwner {
}
function SetStartingIndexBlock() public onlyOwner {
}
function setStartingIndex() public onlyOwner {
}
function updateLvsAddress(address _contract)public {
require(<FILL_ME>)
LVScontract = _contract;
}
function updateOgMerkle(bytes32 _root)public {
}
function updateLvMerkle(bytes32 _root)public{
}
function royaltyInfo(
uint256 _tokenId,
uint256 _salePrice
) external view override returns (
address receiver,
uint256 royaltyAmount
){
}
function flipSaleState() public {
}
function flipclaim() public {
}
function updateRoyalty(uint newRoyalty) public onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable) returns (bool) {
}
function setBaseURI(string memory baseURI_) external {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setProvenance(string memory provenance) public onlyOwner {
}
function getSaleState() public view returns (bool) {
}
function prooveMerkle(bytes32[] calldata _merkleProof, bytes32 _merkleRoot)private view returns (bool) {
}
function launchSale() public {
}
function _confirmMint(uint _tokenNumber, uint _claim) private view returns (bool) {
}
function _doMint(uint numberOfTokens, address _target)private {
}
function TeamReserve(uint _amount)public onlyOwner{
}
function LoveStoryClaim()public{
}
//og mint
function OGMint(uint numberOfTokens, bytes32[] calldata _proof)public payable {
}
// Love Story mint
function LoveListMint(uint numberOfTokens, bytes32[] calldata _proof)public payable {
}
// Public Mint
function XOXOMint(uint256 _amount) public payable {
}
function CreditCardMint(address _target, uint numberOfTokens) public {
}
function withdraw(address _beneficiary) public onlyOwner {
}
function transferOwnership(address newOwner) public override onlyOwner {
}
}
/*
%%%%%* /%%%%*
%%% %%
.%% %%
%% %
%% %
%% %
.% @@@@@@@@@@@@@@@@@@@@@ @@@@
%% @@@ @@@ @@@ ,
% @@@ @@@ @@@
%% &&& &@@@ @@@ %
% &&& @@@@ @@@
,% &&&&&&&&&&&&&&&&&&&%%(. @@@@@
% %%% @@@@@@@
% %%% @@@@ @@@@
%% %%% @@@@ @@@ %
%% %%% @@@ @@@ %
%% %%% @@@ @@@ %
%% %%%%%%%%%%%%%%%%@@@ @@@@ %
%% %
%% %
%% %
%%% %%
%%% %%#
#%%%%%%%
*/
| senders[_msgSender()] | 264,653 | senders[_msgSender()] |
"4!" | // SPDX-License-Identifier: MIT
// @author: Exotic Technology LTD
pragma solidity ^0.8.0;
import "./ERC721.sol";
import "./ownable.sol";
import "./ERC721enumerable.sol";
import "./merkle.sol";
interface LVS{
function balanceOf(address owner) external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);
}
contract XOXO_By_Maya_and_Yehuda_Devir is Ownable, ERC721, ERC721Enumerable {
bool public saleIsActive = false;
bool public claim = false;
uint256 constant public claimToken = 101;
uint256 public claimed = 0;
uint256 constant public MAX_TOKEN = 10000;
uint256 constant public MAX_PUBLIC_MINT = 4;
uint256 public royalty = 80;
uint256 public ogPrice = 0.05 ether;
uint256 public lvPrice = 0.075 ether;
uint256 public tokenPrice = 0.101 ether;
uint256 public startingIndex = 0;
uint256 public startingIndexBlock = 0;
uint256 public SALE_START = 0;
address LVScontract;
bytes32 public ogMerkle = 0x6ee8bee8c77b05f5cf46ea9f7c98b6e3571366d95ccdb3f96be8640e43b6ec21;
bytes32 public lvMerkle = 0x6ee8bee8c77b05f5cf46ea9f7c98b6e3571366d95ccdb3f96be8640e43b6ec21;
string private _baseURIextended;
string public PROVENANCE;
mapping(address => uint) public minters;
mapping(address => bool) private senders;
mapping(uint => bool) private claimedTokens;
constructor() ERC721("XOXONFT", "XOXO") {
}
function addSender(address _address) public onlyOwner {
}
function removeSender(address _address) public onlyOwner {
}
function SetStartingIndexBlock() public onlyOwner {
}
function setStartingIndex() public onlyOwner {
}
function updateLvsAddress(address _contract)public {
}
function updateOgMerkle(bytes32 _root)public {
}
function updateLvMerkle(bytes32 _root)public{
}
function royaltyInfo(
uint256 _tokenId,
uint256 _salePrice
) external view override returns (
address receiver,
uint256 royaltyAmount
){
}
function flipSaleState() public {
}
function flipclaim() public {
}
function updateRoyalty(uint newRoyalty) public onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable) returns (bool) {
}
function setBaseURI(string memory baseURI_) external {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setProvenance(string memory provenance) public onlyOwner {
}
function getSaleState() public view returns (bool) {
}
function prooveMerkle(bytes32[] calldata _merkleProof, bytes32 _merkleRoot)private view returns (bool) {
}
function launchSale() public {
}
function _confirmMint(uint _tokenNumber, uint _claim) private view returns (bool) {
uint256 ts = totalSupply();
uint256 msBalance = balanceOf(_msgSender());
uint256 totalMinted = minters[_msgSender()];
if(_claim == 0){
require(_tokenNumber <= MAX_PUBLIC_MINT,"max!");
require(<FILL_ME>)
require(msBalance + _tokenNumber <= MAX_PUBLIC_MINT, "4");
}
require(!Address.isContract(_msgSender()),"contract");
require(saleIsActive, "closed!");
require(ts + _tokenNumber <= MAX_TOKEN, "max");
if(claim == true){
require(ts + _tokenNumber <= MAX_TOKEN - claimToken + claimed, "max");
}
return true;
}
function _doMint(uint numberOfTokens, address _target)private {
}
function TeamReserve(uint _amount)public onlyOwner{
}
function LoveStoryClaim()public{
}
//og mint
function OGMint(uint numberOfTokens, bytes32[] calldata _proof)public payable {
}
// Love Story mint
function LoveListMint(uint numberOfTokens, bytes32[] calldata _proof)public payable {
}
// Public Mint
function XOXOMint(uint256 _amount) public payable {
}
function CreditCardMint(address _target, uint numberOfTokens) public {
}
function withdraw(address _beneficiary) public onlyOwner {
}
function transferOwnership(address newOwner) public override onlyOwner {
}
}
/*
%%%%%* /%%%%*
%%% %%
.%% %%
%% %
%% %
%% %
.% @@@@@@@@@@@@@@@@@@@@@ @@@@
%% @@@ @@@ @@@ ,
% @@@ @@@ @@@
%% &&& &@@@ @@@ %
% &&& @@@@ @@@
,% &&&&&&&&&&&&&&&&&&&%%(. @@@@@
% %%% @@@@@@@
% %%% @@@@ @@@@
%% %%% @@@@ @@@ %
%% %%% @@@ @@@ %
%% %%% @@@ @@@ %
%% %%%%%%%%%%%%%%%%@@@ @@@@ %
%% %
%% %
%% %
%%% %%
%%% %%#
#%%%%%%%
*/
| totalMinted+_tokenNumber<=MAX_PUBLIC_MINT,"4!" | 264,653 | totalMinted+_tokenNumber<=MAX_PUBLIC_MINT |
"4" | // SPDX-License-Identifier: MIT
// @author: Exotic Technology LTD
pragma solidity ^0.8.0;
import "./ERC721.sol";
import "./ownable.sol";
import "./ERC721enumerable.sol";
import "./merkle.sol";
interface LVS{
function balanceOf(address owner) external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);
}
contract XOXO_By_Maya_and_Yehuda_Devir is Ownable, ERC721, ERC721Enumerable {
bool public saleIsActive = false;
bool public claim = false;
uint256 constant public claimToken = 101;
uint256 public claimed = 0;
uint256 constant public MAX_TOKEN = 10000;
uint256 constant public MAX_PUBLIC_MINT = 4;
uint256 public royalty = 80;
uint256 public ogPrice = 0.05 ether;
uint256 public lvPrice = 0.075 ether;
uint256 public tokenPrice = 0.101 ether;
uint256 public startingIndex = 0;
uint256 public startingIndexBlock = 0;
uint256 public SALE_START = 0;
address LVScontract;
bytes32 public ogMerkle = 0x6ee8bee8c77b05f5cf46ea9f7c98b6e3571366d95ccdb3f96be8640e43b6ec21;
bytes32 public lvMerkle = 0x6ee8bee8c77b05f5cf46ea9f7c98b6e3571366d95ccdb3f96be8640e43b6ec21;
string private _baseURIextended;
string public PROVENANCE;
mapping(address => uint) public minters;
mapping(address => bool) private senders;
mapping(uint => bool) private claimedTokens;
constructor() ERC721("XOXONFT", "XOXO") {
}
function addSender(address _address) public onlyOwner {
}
function removeSender(address _address) public onlyOwner {
}
function SetStartingIndexBlock() public onlyOwner {
}
function setStartingIndex() public onlyOwner {
}
function updateLvsAddress(address _contract)public {
}
function updateOgMerkle(bytes32 _root)public {
}
function updateLvMerkle(bytes32 _root)public{
}
function royaltyInfo(
uint256 _tokenId,
uint256 _salePrice
) external view override returns (
address receiver,
uint256 royaltyAmount
){
}
function flipSaleState() public {
}
function flipclaim() public {
}
function updateRoyalty(uint newRoyalty) public onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable) returns (bool) {
}
function setBaseURI(string memory baseURI_) external {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setProvenance(string memory provenance) public onlyOwner {
}
function getSaleState() public view returns (bool) {
}
function prooveMerkle(bytes32[] calldata _merkleProof, bytes32 _merkleRoot)private view returns (bool) {
}
function launchSale() public {
}
function _confirmMint(uint _tokenNumber, uint _claim) private view returns (bool) {
uint256 ts = totalSupply();
uint256 msBalance = balanceOf(_msgSender());
uint256 totalMinted = minters[_msgSender()];
if(_claim == 0){
require(_tokenNumber <= MAX_PUBLIC_MINT,"max!");
require(totalMinted + _tokenNumber <= MAX_PUBLIC_MINT,"4!");
require(<FILL_ME>)
}
require(!Address.isContract(_msgSender()),"contract");
require(saleIsActive, "closed!");
require(ts + _tokenNumber <= MAX_TOKEN, "max");
if(claim == true){
require(ts + _tokenNumber <= MAX_TOKEN - claimToken + claimed, "max");
}
return true;
}
function _doMint(uint numberOfTokens, address _target)private {
}
function TeamReserve(uint _amount)public onlyOwner{
}
function LoveStoryClaim()public{
}
//og mint
function OGMint(uint numberOfTokens, bytes32[] calldata _proof)public payable {
}
// Love Story mint
function LoveListMint(uint numberOfTokens, bytes32[] calldata _proof)public payable {
}
// Public Mint
function XOXOMint(uint256 _amount) public payable {
}
function CreditCardMint(address _target, uint numberOfTokens) public {
}
function withdraw(address _beneficiary) public onlyOwner {
}
function transferOwnership(address newOwner) public override onlyOwner {
}
}
/*
%%%%%* /%%%%*
%%% %%
.%% %%
%% %
%% %
%% %
.% @@@@@@@@@@@@@@@@@@@@@ @@@@
%% @@@ @@@ @@@ ,
% @@@ @@@ @@@
%% &&& &@@@ @@@ %
% &&& @@@@ @@@
,% &&&&&&&&&&&&&&&&&&&%%(. @@@@@
% %%% @@@@@@@
% %%% @@@@ @@@@
%% %%% @@@@ @@@ %
%% %%% @@@ @@@ %
%% %%% @@@ @@@ %
%% %%%%%%%%%%%%%%%%@@@ @@@@ %
%% %
%% %
%% %
%%% %%
%%% %%#
#%%%%%%%
*/
| msBalance+_tokenNumber<=MAX_PUBLIC_MINT,"4" | 264,653 | msBalance+_tokenNumber<=MAX_PUBLIC_MINT |
"max" | // SPDX-License-Identifier: MIT
// @author: Exotic Technology LTD
pragma solidity ^0.8.0;
import "./ERC721.sol";
import "./ownable.sol";
import "./ERC721enumerable.sol";
import "./merkle.sol";
interface LVS{
function balanceOf(address owner) external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);
}
contract XOXO_By_Maya_and_Yehuda_Devir is Ownable, ERC721, ERC721Enumerable {
bool public saleIsActive = false;
bool public claim = false;
uint256 constant public claimToken = 101;
uint256 public claimed = 0;
uint256 constant public MAX_TOKEN = 10000;
uint256 constant public MAX_PUBLIC_MINT = 4;
uint256 public royalty = 80;
uint256 public ogPrice = 0.05 ether;
uint256 public lvPrice = 0.075 ether;
uint256 public tokenPrice = 0.101 ether;
uint256 public startingIndex = 0;
uint256 public startingIndexBlock = 0;
uint256 public SALE_START = 0;
address LVScontract;
bytes32 public ogMerkle = 0x6ee8bee8c77b05f5cf46ea9f7c98b6e3571366d95ccdb3f96be8640e43b6ec21;
bytes32 public lvMerkle = 0x6ee8bee8c77b05f5cf46ea9f7c98b6e3571366d95ccdb3f96be8640e43b6ec21;
string private _baseURIextended;
string public PROVENANCE;
mapping(address => uint) public minters;
mapping(address => bool) private senders;
mapping(uint => bool) private claimedTokens;
constructor() ERC721("XOXONFT", "XOXO") {
}
function addSender(address _address) public onlyOwner {
}
function removeSender(address _address) public onlyOwner {
}
function SetStartingIndexBlock() public onlyOwner {
}
function setStartingIndex() public onlyOwner {
}
function updateLvsAddress(address _contract)public {
}
function updateOgMerkle(bytes32 _root)public {
}
function updateLvMerkle(bytes32 _root)public{
}
function royaltyInfo(
uint256 _tokenId,
uint256 _salePrice
) external view override returns (
address receiver,
uint256 royaltyAmount
){
}
function flipSaleState() public {
}
function flipclaim() public {
}
function updateRoyalty(uint newRoyalty) public onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable) returns (bool) {
}
function setBaseURI(string memory baseURI_) external {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setProvenance(string memory provenance) public onlyOwner {
}
function getSaleState() public view returns (bool) {
}
function prooveMerkle(bytes32[] calldata _merkleProof, bytes32 _merkleRoot)private view returns (bool) {
}
function launchSale() public {
}
function _confirmMint(uint _tokenNumber, uint _claim) private view returns (bool) {
uint256 ts = totalSupply();
uint256 msBalance = balanceOf(_msgSender());
uint256 totalMinted = minters[_msgSender()];
if(_claim == 0){
require(_tokenNumber <= MAX_PUBLIC_MINT,"max!");
require(totalMinted + _tokenNumber <= MAX_PUBLIC_MINT,"4!");
require(msBalance + _tokenNumber <= MAX_PUBLIC_MINT, "4");
}
require(!Address.isContract(_msgSender()),"contract");
require(saleIsActive, "closed!");
require(<FILL_ME>)
if(claim == true){
require(ts + _tokenNumber <= MAX_TOKEN - claimToken + claimed, "max");
}
return true;
}
function _doMint(uint numberOfTokens, address _target)private {
}
function TeamReserve(uint _amount)public onlyOwner{
}
function LoveStoryClaim()public{
}
//og mint
function OGMint(uint numberOfTokens, bytes32[] calldata _proof)public payable {
}
// Love Story mint
function LoveListMint(uint numberOfTokens, bytes32[] calldata _proof)public payable {
}
// Public Mint
function XOXOMint(uint256 _amount) public payable {
}
function CreditCardMint(address _target, uint numberOfTokens) public {
}
function withdraw(address _beneficiary) public onlyOwner {
}
function transferOwnership(address newOwner) public override onlyOwner {
}
}
/*
%%%%%* /%%%%*
%%% %%
.%% %%
%% %
%% %
%% %
.% @@@@@@@@@@@@@@@@@@@@@ @@@@
%% @@@ @@@ @@@ ,
% @@@ @@@ @@@
%% &&& &@@@ @@@ %
% &&& @@@@ @@@
,% &&&&&&&&&&&&&&&&&&&%%(. @@@@@
% %%% @@@@@@@
% %%% @@@@ @@@@
%% %%% @@@@ @@@ %
%% %%% @@@ @@@ %
%% %%% @@@ @@@ %
%% %%%%%%%%%%%%%%%%@@@ @@@@ %
%% %
%% %
%% %
%%% %%
%%% %%#
#%%%%%%%
*/
| ts+_tokenNumber<=MAX_TOKEN,"max" | 264,653 | ts+_tokenNumber<=MAX_TOKEN |
"max" | // SPDX-License-Identifier: MIT
// @author: Exotic Technology LTD
pragma solidity ^0.8.0;
import "./ERC721.sol";
import "./ownable.sol";
import "./ERC721enumerable.sol";
import "./merkle.sol";
interface LVS{
function balanceOf(address owner) external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);
}
contract XOXO_By_Maya_and_Yehuda_Devir is Ownable, ERC721, ERC721Enumerable {
bool public saleIsActive = false;
bool public claim = false;
uint256 constant public claimToken = 101;
uint256 public claimed = 0;
uint256 constant public MAX_TOKEN = 10000;
uint256 constant public MAX_PUBLIC_MINT = 4;
uint256 public royalty = 80;
uint256 public ogPrice = 0.05 ether;
uint256 public lvPrice = 0.075 ether;
uint256 public tokenPrice = 0.101 ether;
uint256 public startingIndex = 0;
uint256 public startingIndexBlock = 0;
uint256 public SALE_START = 0;
address LVScontract;
bytes32 public ogMerkle = 0x6ee8bee8c77b05f5cf46ea9f7c98b6e3571366d95ccdb3f96be8640e43b6ec21;
bytes32 public lvMerkle = 0x6ee8bee8c77b05f5cf46ea9f7c98b6e3571366d95ccdb3f96be8640e43b6ec21;
string private _baseURIextended;
string public PROVENANCE;
mapping(address => uint) public minters;
mapping(address => bool) private senders;
mapping(uint => bool) private claimedTokens;
constructor() ERC721("XOXONFT", "XOXO") {
}
function addSender(address _address) public onlyOwner {
}
function removeSender(address _address) public onlyOwner {
}
function SetStartingIndexBlock() public onlyOwner {
}
function setStartingIndex() public onlyOwner {
}
function updateLvsAddress(address _contract)public {
}
function updateOgMerkle(bytes32 _root)public {
}
function updateLvMerkle(bytes32 _root)public{
}
function royaltyInfo(
uint256 _tokenId,
uint256 _salePrice
) external view override returns (
address receiver,
uint256 royaltyAmount
){
}
function flipSaleState() public {
}
function flipclaim() public {
}
function updateRoyalty(uint newRoyalty) public onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable) returns (bool) {
}
function setBaseURI(string memory baseURI_) external {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setProvenance(string memory provenance) public onlyOwner {
}
function getSaleState() public view returns (bool) {
}
function prooveMerkle(bytes32[] calldata _merkleProof, bytes32 _merkleRoot)private view returns (bool) {
}
function launchSale() public {
}
function _confirmMint(uint _tokenNumber, uint _claim) private view returns (bool) {
uint256 ts = totalSupply();
uint256 msBalance = balanceOf(_msgSender());
uint256 totalMinted = minters[_msgSender()];
if(_claim == 0){
require(_tokenNumber <= MAX_PUBLIC_MINT,"max!");
require(totalMinted + _tokenNumber <= MAX_PUBLIC_MINT,"4!");
require(msBalance + _tokenNumber <= MAX_PUBLIC_MINT, "4");
}
require(!Address.isContract(_msgSender()),"contract");
require(saleIsActive, "closed!");
require(ts + _tokenNumber <= MAX_TOKEN, "max");
if(claim == true){
require(<FILL_ME>)
}
return true;
}
function _doMint(uint numberOfTokens, address _target)private {
}
function TeamReserve(uint _amount)public onlyOwner{
}
function LoveStoryClaim()public{
}
//og mint
function OGMint(uint numberOfTokens, bytes32[] calldata _proof)public payable {
}
// Love Story mint
function LoveListMint(uint numberOfTokens, bytes32[] calldata _proof)public payable {
}
// Public Mint
function XOXOMint(uint256 _amount) public payable {
}
function CreditCardMint(address _target, uint numberOfTokens) public {
}
function withdraw(address _beneficiary) public onlyOwner {
}
function transferOwnership(address newOwner) public override onlyOwner {
}
}
/*
%%%%%* /%%%%*
%%% %%
.%% %%
%% %
%% %
%% %
.% @@@@@@@@@@@@@@@@@@@@@ @@@@
%% @@@ @@@ @@@ ,
% @@@ @@@ @@@
%% &&& &@@@ @@@ %
% &&& @@@@ @@@
,% &&&&&&&&&&&&&&&&&&&%%(. @@@@@
% %%% @@@@@@@
% %%% @@@@ @@@@
%% %%% @@@@ @@@ %
%% %%% @@@ @@@ %
%% %%% @@@ @@@ %
%% %%%%%%%%%%%%%%%%@@@ @@@@ %
%% %
%% %
%% %
%%% %%
%%% %%#
#%%%%%%%
*/
| ts+_tokenNumber<=MAX_TOKEN-claimToken+claimed,"max" | 264,653 | ts+_tokenNumber<=MAX_TOKEN-claimToken+claimed |
null | // SPDX-License-Identifier: MIT
// @author: Exotic Technology LTD
pragma solidity ^0.8.0;
import "./ERC721.sol";
import "./ownable.sol";
import "./ERC721enumerable.sol";
import "./merkle.sol";
interface LVS{
function balanceOf(address owner) external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);
}
contract XOXO_By_Maya_and_Yehuda_Devir is Ownable, ERC721, ERC721Enumerable {
bool public saleIsActive = false;
bool public claim = false;
uint256 constant public claimToken = 101;
uint256 public claimed = 0;
uint256 constant public MAX_TOKEN = 10000;
uint256 constant public MAX_PUBLIC_MINT = 4;
uint256 public royalty = 80;
uint256 public ogPrice = 0.05 ether;
uint256 public lvPrice = 0.075 ether;
uint256 public tokenPrice = 0.101 ether;
uint256 public startingIndex = 0;
uint256 public startingIndexBlock = 0;
uint256 public SALE_START = 0;
address LVScontract;
bytes32 public ogMerkle = 0x6ee8bee8c77b05f5cf46ea9f7c98b6e3571366d95ccdb3f96be8640e43b6ec21;
bytes32 public lvMerkle = 0x6ee8bee8c77b05f5cf46ea9f7c98b6e3571366d95ccdb3f96be8640e43b6ec21;
string private _baseURIextended;
string public PROVENANCE;
mapping(address => uint) public minters;
mapping(address => bool) private senders;
mapping(uint => bool) private claimedTokens;
constructor() ERC721("XOXONFT", "XOXO") {
}
function addSender(address _address) public onlyOwner {
}
function removeSender(address _address) public onlyOwner {
}
function SetStartingIndexBlock() public onlyOwner {
}
function setStartingIndex() public onlyOwner {
}
function updateLvsAddress(address _contract)public {
}
function updateOgMerkle(bytes32 _root)public {
}
function updateLvMerkle(bytes32 _root)public{
}
function royaltyInfo(
uint256 _tokenId,
uint256 _salePrice
) external view override returns (
address receiver,
uint256 royaltyAmount
){
}
function flipSaleState() public {
}
function flipclaim() public {
}
function updateRoyalty(uint newRoyalty) public onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable) returns (bool) {
}
function setBaseURI(string memory baseURI_) external {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setProvenance(string memory provenance) public onlyOwner {
}
function getSaleState() public view returns (bool) {
}
function prooveMerkle(bytes32[] calldata _merkleProof, bytes32 _merkleRoot)private view returns (bool) {
}
function launchSale() public {
}
function _confirmMint(uint _tokenNumber, uint _claim) private view returns (bool) {
}
function _doMint(uint numberOfTokens, address _target)private {
}
function TeamReserve(uint _amount)public onlyOwner{
require(_amount >0);
uint256 ts = totalSupply();
require(<FILL_ME>)
_doMint(_amount,_msgSender());
}
function LoveStoryClaim()public{
}
//og mint
function OGMint(uint numberOfTokens, bytes32[] calldata _proof)public payable {
}
// Love Story mint
function LoveListMint(uint numberOfTokens, bytes32[] calldata _proof)public payable {
}
// Public Mint
function XOXOMint(uint256 _amount) public payable {
}
function CreditCardMint(address _target, uint numberOfTokens) public {
}
function withdraw(address _beneficiary) public onlyOwner {
}
function transferOwnership(address newOwner) public override onlyOwner {
}
}
/*
%%%%%* /%%%%*
%%% %%
.%% %%
%% %
%% %
%% %
.% @@@@@@@@@@@@@@@@@@@@@ @@@@
%% @@@ @@@ @@@ ,
% @@@ @@@ @@@
%% &&& &@@@ @@@ %
% &&& @@@@ @@@
,% &&&&&&&&&&&&&&&&&&&%%(. @@@@@
% %%% @@@@@@@
% %%% @@@@ @@@@
%% %%% @@@@ @@@ %
%% %%% @@@ @@@ %
%% %%% @@@ @@@ %
%% %%%%%%%%%%%%%%%%@@@ @@@@ %
%% %
%% %
%% %
%%% %%
%%% %%#
#%%%%%%%
*/
| ts+_amount<=MAX_TOKEN | 264,653 | ts+_amount<=MAX_TOKEN |
"claimed" | // SPDX-License-Identifier: MIT
// @author: Exotic Technology LTD
pragma solidity ^0.8.0;
import "./ERC721.sol";
import "./ownable.sol";
import "./ERC721enumerable.sol";
import "./merkle.sol";
interface LVS{
function balanceOf(address owner) external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);
}
contract XOXO_By_Maya_and_Yehuda_Devir is Ownable, ERC721, ERC721Enumerable {
bool public saleIsActive = false;
bool public claim = false;
uint256 constant public claimToken = 101;
uint256 public claimed = 0;
uint256 constant public MAX_TOKEN = 10000;
uint256 constant public MAX_PUBLIC_MINT = 4;
uint256 public royalty = 80;
uint256 public ogPrice = 0.05 ether;
uint256 public lvPrice = 0.075 ether;
uint256 public tokenPrice = 0.101 ether;
uint256 public startingIndex = 0;
uint256 public startingIndexBlock = 0;
uint256 public SALE_START = 0;
address LVScontract;
bytes32 public ogMerkle = 0x6ee8bee8c77b05f5cf46ea9f7c98b6e3571366d95ccdb3f96be8640e43b6ec21;
bytes32 public lvMerkle = 0x6ee8bee8c77b05f5cf46ea9f7c98b6e3571366d95ccdb3f96be8640e43b6ec21;
string private _baseURIextended;
string public PROVENANCE;
mapping(address => uint) public minters;
mapping(address => bool) private senders;
mapping(uint => bool) private claimedTokens;
constructor() ERC721("XOXONFT", "XOXO") {
}
function addSender(address _address) public onlyOwner {
}
function removeSender(address _address) public onlyOwner {
}
function SetStartingIndexBlock() public onlyOwner {
}
function setStartingIndex() public onlyOwner {
}
function updateLvsAddress(address _contract)public {
}
function updateOgMerkle(bytes32 _root)public {
}
function updateLvMerkle(bytes32 _root)public{
}
function royaltyInfo(
uint256 _tokenId,
uint256 _salePrice
) external view override returns (
address receiver,
uint256 royaltyAmount
){
}
function flipSaleState() public {
}
function flipclaim() public {
}
function updateRoyalty(uint newRoyalty) public onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable) returns (bool) {
}
function setBaseURI(string memory baseURI_) external {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setProvenance(string memory provenance) public onlyOwner {
}
function getSaleState() public view returns (bool) {
}
function prooveMerkle(bytes32[] calldata _merkleProof, bytes32 _merkleRoot)private view returns (bool) {
}
function launchSale() public {
}
function _confirmMint(uint _tokenNumber, uint _claim) private view returns (bool) {
}
function _doMint(uint numberOfTokens, address _target)private {
}
function TeamReserve(uint _amount)public onlyOwner{
}
function LoveStoryClaim()public{
require(claim == true, "claim");
uint ownerBalance = LVS(LVScontract).balanceOf(_msgSender()); // check LVS balance for owner
require(ownerBalance > 0,"balance");
for (uint i = 0; i < ownerBalance; i++){ // add token to claimed list
uint claimedToken = LVS(LVScontract).tokenOfOwnerByIndex(_msgSender(),i);
require(<FILL_ME>)
claimedTokens[claimedToken] = true;
}
require(_confirmMint(ownerBalance,1));
claimed = claimed + ownerBalance;
_doMint(ownerBalance, _msgSender());
}
//og mint
function OGMint(uint numberOfTokens, bytes32[] calldata _proof)public payable {
}
// Love Story mint
function LoveListMint(uint numberOfTokens, bytes32[] calldata _proof)public payable {
}
// Public Mint
function XOXOMint(uint256 _amount) public payable {
}
function CreditCardMint(address _target, uint numberOfTokens) public {
}
function withdraw(address _beneficiary) public onlyOwner {
}
function transferOwnership(address newOwner) public override onlyOwner {
}
}
/*
%%%%%* /%%%%*
%%% %%
.%% %%
%% %
%% %
%% %
.% @@@@@@@@@@@@@@@@@@@@@ @@@@
%% @@@ @@@ @@@ ,
% @@@ @@@ @@@
%% &&& &@@@ @@@ %
% &&& @@@@ @@@
,% &&&&&&&&&&&&&&&&&&&%%(. @@@@@
% %%% @@@@@@@
% %%% @@@@ @@@@
%% %%% @@@@ @@@ %
%% %%% @@@ @@@ %
%% %%% @@@ @@@ %
%% %%%%%%%%%%%%%%%%@@@ @@@@ %
%% %
%% %
%% %
%%% %%
%%% %%#
#%%%%%%%
*/
| claimedTokens[claimedToken]==false,"claimed" | 264,653 | claimedTokens[claimedToken]==false |
null | // SPDX-License-Identifier: MIT
// @author: Exotic Technology LTD
pragma solidity ^0.8.0;
import "./ERC721.sol";
import "./ownable.sol";
import "./ERC721enumerable.sol";
import "./merkle.sol";
interface LVS{
function balanceOf(address owner) external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);
}
contract XOXO_By_Maya_and_Yehuda_Devir is Ownable, ERC721, ERC721Enumerable {
bool public saleIsActive = false;
bool public claim = false;
uint256 constant public claimToken = 101;
uint256 public claimed = 0;
uint256 constant public MAX_TOKEN = 10000;
uint256 constant public MAX_PUBLIC_MINT = 4;
uint256 public royalty = 80;
uint256 public ogPrice = 0.05 ether;
uint256 public lvPrice = 0.075 ether;
uint256 public tokenPrice = 0.101 ether;
uint256 public startingIndex = 0;
uint256 public startingIndexBlock = 0;
uint256 public SALE_START = 0;
address LVScontract;
bytes32 public ogMerkle = 0x6ee8bee8c77b05f5cf46ea9f7c98b6e3571366d95ccdb3f96be8640e43b6ec21;
bytes32 public lvMerkle = 0x6ee8bee8c77b05f5cf46ea9f7c98b6e3571366d95ccdb3f96be8640e43b6ec21;
string private _baseURIextended;
string public PROVENANCE;
mapping(address => uint) public minters;
mapping(address => bool) private senders;
mapping(uint => bool) private claimedTokens;
constructor() ERC721("XOXONFT", "XOXO") {
}
function addSender(address _address) public onlyOwner {
}
function removeSender(address _address) public onlyOwner {
}
function SetStartingIndexBlock() public onlyOwner {
}
function setStartingIndex() public onlyOwner {
}
function updateLvsAddress(address _contract)public {
}
function updateOgMerkle(bytes32 _root)public {
}
function updateLvMerkle(bytes32 _root)public{
}
function royaltyInfo(
uint256 _tokenId,
uint256 _salePrice
) external view override returns (
address receiver,
uint256 royaltyAmount
){
}
function flipSaleState() public {
}
function flipclaim() public {
}
function updateRoyalty(uint newRoyalty) public onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable) returns (bool) {
}
function setBaseURI(string memory baseURI_) external {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setProvenance(string memory provenance) public onlyOwner {
}
function getSaleState() public view returns (bool) {
}
function prooveMerkle(bytes32[] calldata _merkleProof, bytes32 _merkleRoot)private view returns (bool) {
}
function launchSale() public {
}
function _confirmMint(uint _tokenNumber, uint _claim) private view returns (bool) {
}
function _doMint(uint numberOfTokens, address _target)private {
}
function TeamReserve(uint _amount)public onlyOwner{
}
function LoveStoryClaim()public{
require(claim == true, "claim");
uint ownerBalance = LVS(LVScontract).balanceOf(_msgSender()); // check LVS balance for owner
require(ownerBalance > 0,"balance");
for (uint i = 0; i < ownerBalance; i++){ // add token to claimed list
uint claimedToken = LVS(LVScontract).tokenOfOwnerByIndex(_msgSender(),i);
require(claimedTokens[claimedToken] == false, "claimed");
claimedTokens[claimedToken] = true;
}
require(<FILL_ME>)
claimed = claimed + ownerBalance;
_doMint(ownerBalance, _msgSender());
}
//og mint
function OGMint(uint numberOfTokens, bytes32[] calldata _proof)public payable {
}
// Love Story mint
function LoveListMint(uint numberOfTokens, bytes32[] calldata _proof)public payable {
}
// Public Mint
function XOXOMint(uint256 _amount) public payable {
}
function CreditCardMint(address _target, uint numberOfTokens) public {
}
function withdraw(address _beneficiary) public onlyOwner {
}
function transferOwnership(address newOwner) public override onlyOwner {
}
}
/*
%%%%%* /%%%%*
%%% %%
.%% %%
%% %
%% %
%% %
.% @@@@@@@@@@@@@@@@@@@@@ @@@@
%% @@@ @@@ @@@ ,
% @@@ @@@ @@@
%% &&& &@@@ @@@ %
% &&& @@@@ @@@
,% &&&&&&&&&&&&&&&&&&&%%(. @@@@@
% %%% @@@@@@@
% %%% @@@@ @@@@
%% %%% @@@@ @@@ %
%% %%% @@@ @@@ %
%% %%% @@@ @@@ %
%% %%%%%%%%%%%%%%%%@@@ @@@@ %
%% %
%% %
%% %
%%% %%
%%% %%#
#%%%%%%%
*/
| _confirmMint(ownerBalance,1) | 264,653 | _confirmMint(ownerBalance,1) |
"whitelist" | // SPDX-License-Identifier: MIT
// @author: Exotic Technology LTD
pragma solidity ^0.8.0;
import "./ERC721.sol";
import "./ownable.sol";
import "./ERC721enumerable.sol";
import "./merkle.sol";
interface LVS{
function balanceOf(address owner) external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);
}
contract XOXO_By_Maya_and_Yehuda_Devir is Ownable, ERC721, ERC721Enumerable {
bool public saleIsActive = false;
bool public claim = false;
uint256 constant public claimToken = 101;
uint256 public claimed = 0;
uint256 constant public MAX_TOKEN = 10000;
uint256 constant public MAX_PUBLIC_MINT = 4;
uint256 public royalty = 80;
uint256 public ogPrice = 0.05 ether;
uint256 public lvPrice = 0.075 ether;
uint256 public tokenPrice = 0.101 ether;
uint256 public startingIndex = 0;
uint256 public startingIndexBlock = 0;
uint256 public SALE_START = 0;
address LVScontract;
bytes32 public ogMerkle = 0x6ee8bee8c77b05f5cf46ea9f7c98b6e3571366d95ccdb3f96be8640e43b6ec21;
bytes32 public lvMerkle = 0x6ee8bee8c77b05f5cf46ea9f7c98b6e3571366d95ccdb3f96be8640e43b6ec21;
string private _baseURIextended;
string public PROVENANCE;
mapping(address => uint) public minters;
mapping(address => bool) private senders;
mapping(uint => bool) private claimedTokens;
constructor() ERC721("XOXONFT", "XOXO") {
}
function addSender(address _address) public onlyOwner {
}
function removeSender(address _address) public onlyOwner {
}
function SetStartingIndexBlock() public onlyOwner {
}
function setStartingIndex() public onlyOwner {
}
function updateLvsAddress(address _contract)public {
}
function updateOgMerkle(bytes32 _root)public {
}
function updateLvMerkle(bytes32 _root)public{
}
function royaltyInfo(
uint256 _tokenId,
uint256 _salePrice
) external view override returns (
address receiver,
uint256 royaltyAmount
){
}
function flipSaleState() public {
}
function flipclaim() public {
}
function updateRoyalty(uint newRoyalty) public onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable) returns (bool) {
}
function setBaseURI(string memory baseURI_) external {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setProvenance(string memory provenance) public onlyOwner {
}
function getSaleState() public view returns (bool) {
}
function prooveMerkle(bytes32[] calldata _merkleProof, bytes32 _merkleRoot)private view returns (bool) {
}
function launchSale() public {
}
function _confirmMint(uint _tokenNumber, uint _claim) private view returns (bool) {
}
function _doMint(uint numberOfTokens, address _target)private {
}
function TeamReserve(uint _amount)public onlyOwner{
}
function LoveStoryClaim()public{
}
//og mint
function OGMint(uint numberOfTokens, bytes32[] calldata _proof)public payable {
require(block.timestamp < SALE_START, "presale");
require(<FILL_ME>)
require(_confirmMint(numberOfTokens,0));
require(ogPrice * (numberOfTokens) <= msg.value, "Ether");
_doMint(numberOfTokens, _msgSender());
}
// Love Story mint
function LoveListMint(uint numberOfTokens, bytes32[] calldata _proof)public payable {
}
// Public Mint
function XOXOMint(uint256 _amount) public payable {
}
function CreditCardMint(address _target, uint numberOfTokens) public {
}
function withdraw(address _beneficiary) public onlyOwner {
}
function transferOwnership(address newOwner) public override onlyOwner {
}
}
/*
%%%%%* /%%%%*
%%% %%
.%% %%
%% %
%% %
%% %
.% @@@@@@@@@@@@@@@@@@@@@ @@@@
%% @@@ @@@ @@@ ,
% @@@ @@@ @@@
%% &&& &@@@ @@@ %
% &&& @@@@ @@@
,% &&&&&&&&&&&&&&&&&&&%%(. @@@@@
% %%% @@@@@@@
% %%% @@@@ @@@@
%% %%% @@@@ @@@ %
%% %%% @@@ @@@ %
%% %%% @@@ @@@ %
%% %%%%%%%%%%%%%%%%@@@ @@@@ %
%% %
%% %
%% %
%%% %%
%%% %%#
#%%%%%%%
*/
| prooveMerkle(_proof,ogMerkle),"whitelist" | 264,653 | prooveMerkle(_proof,ogMerkle) |
null | // SPDX-License-Identifier: MIT
// @author: Exotic Technology LTD
pragma solidity ^0.8.0;
import "./ERC721.sol";
import "./ownable.sol";
import "./ERC721enumerable.sol";
import "./merkle.sol";
interface LVS{
function balanceOf(address owner) external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);
}
contract XOXO_By_Maya_and_Yehuda_Devir is Ownable, ERC721, ERC721Enumerable {
bool public saleIsActive = false;
bool public claim = false;
uint256 constant public claimToken = 101;
uint256 public claimed = 0;
uint256 constant public MAX_TOKEN = 10000;
uint256 constant public MAX_PUBLIC_MINT = 4;
uint256 public royalty = 80;
uint256 public ogPrice = 0.05 ether;
uint256 public lvPrice = 0.075 ether;
uint256 public tokenPrice = 0.101 ether;
uint256 public startingIndex = 0;
uint256 public startingIndexBlock = 0;
uint256 public SALE_START = 0;
address LVScontract;
bytes32 public ogMerkle = 0x6ee8bee8c77b05f5cf46ea9f7c98b6e3571366d95ccdb3f96be8640e43b6ec21;
bytes32 public lvMerkle = 0x6ee8bee8c77b05f5cf46ea9f7c98b6e3571366d95ccdb3f96be8640e43b6ec21;
string private _baseURIextended;
string public PROVENANCE;
mapping(address => uint) public minters;
mapping(address => bool) private senders;
mapping(uint => bool) private claimedTokens;
constructor() ERC721("XOXONFT", "XOXO") {
}
function addSender(address _address) public onlyOwner {
}
function removeSender(address _address) public onlyOwner {
}
function SetStartingIndexBlock() public onlyOwner {
}
function setStartingIndex() public onlyOwner {
}
function updateLvsAddress(address _contract)public {
}
function updateOgMerkle(bytes32 _root)public {
}
function updateLvMerkle(bytes32 _root)public{
}
function royaltyInfo(
uint256 _tokenId,
uint256 _salePrice
) external view override returns (
address receiver,
uint256 royaltyAmount
){
}
function flipSaleState() public {
}
function flipclaim() public {
}
function updateRoyalty(uint newRoyalty) public onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable) returns (bool) {
}
function setBaseURI(string memory baseURI_) external {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setProvenance(string memory provenance) public onlyOwner {
}
function getSaleState() public view returns (bool) {
}
function prooveMerkle(bytes32[] calldata _merkleProof, bytes32 _merkleRoot)private view returns (bool) {
}
function launchSale() public {
}
function _confirmMint(uint _tokenNumber, uint _claim) private view returns (bool) {
}
function _doMint(uint numberOfTokens, address _target)private {
}
function TeamReserve(uint _amount)public onlyOwner{
}
function LoveStoryClaim()public{
}
//og mint
function OGMint(uint numberOfTokens, bytes32[] calldata _proof)public payable {
require(block.timestamp < SALE_START, "presale");
require(prooveMerkle(_proof, ogMerkle),"whitelist");
require(<FILL_ME>)
require(ogPrice * (numberOfTokens) <= msg.value, "Ether");
_doMint(numberOfTokens, _msgSender());
}
// Love Story mint
function LoveListMint(uint numberOfTokens, bytes32[] calldata _proof)public payable {
}
// Public Mint
function XOXOMint(uint256 _amount) public payable {
}
function CreditCardMint(address _target, uint numberOfTokens) public {
}
function withdraw(address _beneficiary) public onlyOwner {
}
function transferOwnership(address newOwner) public override onlyOwner {
}
}
/*
%%%%%* /%%%%*
%%% %%
.%% %%
%% %
%% %
%% %
.% @@@@@@@@@@@@@@@@@@@@@ @@@@
%% @@@ @@@ @@@ ,
% @@@ @@@ @@@
%% &&& &@@@ @@@ %
% &&& @@@@ @@@
,% &&&&&&&&&&&&&&&&&&&%%(. @@@@@
% %%% @@@@@@@
% %%% @@@@ @@@@
%% %%% @@@@ @@@ %
%% %%% @@@ @@@ %
%% %%% @@@ @@@ %
%% %%%%%%%%%%%%%%%%@@@ @@@@ %
%% %
%% %
%% %
%%% %%
%%% %%#
#%%%%%%%
*/
| _confirmMint(numberOfTokens,0) | 264,653 | _confirmMint(numberOfTokens,0) |
"Ether" | // SPDX-License-Identifier: MIT
// @author: Exotic Technology LTD
pragma solidity ^0.8.0;
import "./ERC721.sol";
import "./ownable.sol";
import "./ERC721enumerable.sol";
import "./merkle.sol";
interface LVS{
function balanceOf(address owner) external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);
}
contract XOXO_By_Maya_and_Yehuda_Devir is Ownable, ERC721, ERC721Enumerable {
bool public saleIsActive = false;
bool public claim = false;
uint256 constant public claimToken = 101;
uint256 public claimed = 0;
uint256 constant public MAX_TOKEN = 10000;
uint256 constant public MAX_PUBLIC_MINT = 4;
uint256 public royalty = 80;
uint256 public ogPrice = 0.05 ether;
uint256 public lvPrice = 0.075 ether;
uint256 public tokenPrice = 0.101 ether;
uint256 public startingIndex = 0;
uint256 public startingIndexBlock = 0;
uint256 public SALE_START = 0;
address LVScontract;
bytes32 public ogMerkle = 0x6ee8bee8c77b05f5cf46ea9f7c98b6e3571366d95ccdb3f96be8640e43b6ec21;
bytes32 public lvMerkle = 0x6ee8bee8c77b05f5cf46ea9f7c98b6e3571366d95ccdb3f96be8640e43b6ec21;
string private _baseURIextended;
string public PROVENANCE;
mapping(address => uint) public minters;
mapping(address => bool) private senders;
mapping(uint => bool) private claimedTokens;
constructor() ERC721("XOXONFT", "XOXO") {
}
function addSender(address _address) public onlyOwner {
}
function removeSender(address _address) public onlyOwner {
}
function SetStartingIndexBlock() public onlyOwner {
}
function setStartingIndex() public onlyOwner {
}
function updateLvsAddress(address _contract)public {
}
function updateOgMerkle(bytes32 _root)public {
}
function updateLvMerkle(bytes32 _root)public{
}
function royaltyInfo(
uint256 _tokenId,
uint256 _salePrice
) external view override returns (
address receiver,
uint256 royaltyAmount
){
}
function flipSaleState() public {
}
function flipclaim() public {
}
function updateRoyalty(uint newRoyalty) public onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable) returns (bool) {
}
function setBaseURI(string memory baseURI_) external {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setProvenance(string memory provenance) public onlyOwner {
}
function getSaleState() public view returns (bool) {
}
function prooveMerkle(bytes32[] calldata _merkleProof, bytes32 _merkleRoot)private view returns (bool) {
}
function launchSale() public {
}
function _confirmMint(uint _tokenNumber, uint _claim) private view returns (bool) {
}
function _doMint(uint numberOfTokens, address _target)private {
}
function TeamReserve(uint _amount)public onlyOwner{
}
function LoveStoryClaim()public{
}
//og mint
function OGMint(uint numberOfTokens, bytes32[] calldata _proof)public payable {
require(block.timestamp < SALE_START, "presale");
require(prooveMerkle(_proof, ogMerkle),"whitelist");
require(_confirmMint(numberOfTokens,0));
require(<FILL_ME>)
_doMint(numberOfTokens, _msgSender());
}
// Love Story mint
function LoveListMint(uint numberOfTokens, bytes32[] calldata _proof)public payable {
}
// Public Mint
function XOXOMint(uint256 _amount) public payable {
}
function CreditCardMint(address _target, uint numberOfTokens) public {
}
function withdraw(address _beneficiary) public onlyOwner {
}
function transferOwnership(address newOwner) public override onlyOwner {
}
}
/*
%%%%%* /%%%%*
%%% %%
.%% %%
%% %
%% %
%% %
.% @@@@@@@@@@@@@@@@@@@@@ @@@@
%% @@@ @@@ @@@ ,
% @@@ @@@ @@@
%% &&& &@@@ @@@ %
% &&& @@@@ @@@
,% &&&&&&&&&&&&&&&&&&&%%(. @@@@@
% %%% @@@@@@@
% %%% @@@@ @@@@
%% %%% @@@@ @@@ %
%% %%% @@@ @@@ %
%% %%% @@@ @@@ %
%% %%%%%%%%%%%%%%%%@@@ @@@@ %
%% %
%% %
%% %
%%% %%
%%% %%#
#%%%%%%%
*/
| ogPrice*(numberOfTokens)<=msg.value,"Ether" | 264,653 | ogPrice*(numberOfTokens)<=msg.value |
"whitelist" | // SPDX-License-Identifier: MIT
// @author: Exotic Technology LTD
pragma solidity ^0.8.0;
import "./ERC721.sol";
import "./ownable.sol";
import "./ERC721enumerable.sol";
import "./merkle.sol";
interface LVS{
function balanceOf(address owner) external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);
}
contract XOXO_By_Maya_and_Yehuda_Devir is Ownable, ERC721, ERC721Enumerable {
bool public saleIsActive = false;
bool public claim = false;
uint256 constant public claimToken = 101;
uint256 public claimed = 0;
uint256 constant public MAX_TOKEN = 10000;
uint256 constant public MAX_PUBLIC_MINT = 4;
uint256 public royalty = 80;
uint256 public ogPrice = 0.05 ether;
uint256 public lvPrice = 0.075 ether;
uint256 public tokenPrice = 0.101 ether;
uint256 public startingIndex = 0;
uint256 public startingIndexBlock = 0;
uint256 public SALE_START = 0;
address LVScontract;
bytes32 public ogMerkle = 0x6ee8bee8c77b05f5cf46ea9f7c98b6e3571366d95ccdb3f96be8640e43b6ec21;
bytes32 public lvMerkle = 0x6ee8bee8c77b05f5cf46ea9f7c98b6e3571366d95ccdb3f96be8640e43b6ec21;
string private _baseURIextended;
string public PROVENANCE;
mapping(address => uint) public minters;
mapping(address => bool) private senders;
mapping(uint => bool) private claimedTokens;
constructor() ERC721("XOXONFT", "XOXO") {
}
function addSender(address _address) public onlyOwner {
}
function removeSender(address _address) public onlyOwner {
}
function SetStartingIndexBlock() public onlyOwner {
}
function setStartingIndex() public onlyOwner {
}
function updateLvsAddress(address _contract)public {
}
function updateOgMerkle(bytes32 _root)public {
}
function updateLvMerkle(bytes32 _root)public{
}
function royaltyInfo(
uint256 _tokenId,
uint256 _salePrice
) external view override returns (
address receiver,
uint256 royaltyAmount
){
}
function flipSaleState() public {
}
function flipclaim() public {
}
function updateRoyalty(uint newRoyalty) public onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable) returns (bool) {
}
function setBaseURI(string memory baseURI_) external {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setProvenance(string memory provenance) public onlyOwner {
}
function getSaleState() public view returns (bool) {
}
function prooveMerkle(bytes32[] calldata _merkleProof, bytes32 _merkleRoot)private view returns (bool) {
}
function launchSale() public {
}
function _confirmMint(uint _tokenNumber, uint _claim) private view returns (bool) {
}
function _doMint(uint numberOfTokens, address _target)private {
}
function TeamReserve(uint _amount)public onlyOwner{
}
function LoveStoryClaim()public{
}
//og mint
function OGMint(uint numberOfTokens, bytes32[] calldata _proof)public payable {
}
// Love Story mint
function LoveListMint(uint numberOfTokens, bytes32[] calldata _proof)public payable {
require(block.timestamp < SALE_START, "presale");
require(<FILL_ME>)
require(_confirmMint(numberOfTokens,0), "failed");
require(lvPrice * (numberOfTokens) <= msg.value, "Ether");
_doMint(numberOfTokens, _msgSender());
}
// Public Mint
function XOXOMint(uint256 _amount) public payable {
}
function CreditCardMint(address _target, uint numberOfTokens) public {
}
function withdraw(address _beneficiary) public onlyOwner {
}
function transferOwnership(address newOwner) public override onlyOwner {
}
}
/*
%%%%%* /%%%%*
%%% %%
.%% %%
%% %
%% %
%% %
.% @@@@@@@@@@@@@@@@@@@@@ @@@@
%% @@@ @@@ @@@ ,
% @@@ @@@ @@@
%% &&& &@@@ @@@ %
% &&& @@@@ @@@
,% &&&&&&&&&&&&&&&&&&&%%(. @@@@@
% %%% @@@@@@@
% %%% @@@@ @@@@
%% %%% @@@@ @@@ %
%% %%% @@@ @@@ %
%% %%% @@@ @@@ %
%% %%%%%%%%%%%%%%%%@@@ @@@@ %
%% %
%% %
%% %
%%% %%
%%% %%#
#%%%%%%%
*/
| prooveMerkle(_proof,lvMerkle),"whitelist" | 264,653 | prooveMerkle(_proof,lvMerkle) |
"Ether" | // SPDX-License-Identifier: MIT
// @author: Exotic Technology LTD
pragma solidity ^0.8.0;
import "./ERC721.sol";
import "./ownable.sol";
import "./ERC721enumerable.sol";
import "./merkle.sol";
interface LVS{
function balanceOf(address owner) external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);
}
contract XOXO_By_Maya_and_Yehuda_Devir is Ownable, ERC721, ERC721Enumerable {
bool public saleIsActive = false;
bool public claim = false;
uint256 constant public claimToken = 101;
uint256 public claimed = 0;
uint256 constant public MAX_TOKEN = 10000;
uint256 constant public MAX_PUBLIC_MINT = 4;
uint256 public royalty = 80;
uint256 public ogPrice = 0.05 ether;
uint256 public lvPrice = 0.075 ether;
uint256 public tokenPrice = 0.101 ether;
uint256 public startingIndex = 0;
uint256 public startingIndexBlock = 0;
uint256 public SALE_START = 0;
address LVScontract;
bytes32 public ogMerkle = 0x6ee8bee8c77b05f5cf46ea9f7c98b6e3571366d95ccdb3f96be8640e43b6ec21;
bytes32 public lvMerkle = 0x6ee8bee8c77b05f5cf46ea9f7c98b6e3571366d95ccdb3f96be8640e43b6ec21;
string private _baseURIextended;
string public PROVENANCE;
mapping(address => uint) public minters;
mapping(address => bool) private senders;
mapping(uint => bool) private claimedTokens;
constructor() ERC721("XOXONFT", "XOXO") {
}
function addSender(address _address) public onlyOwner {
}
function removeSender(address _address) public onlyOwner {
}
function SetStartingIndexBlock() public onlyOwner {
}
function setStartingIndex() public onlyOwner {
}
function updateLvsAddress(address _contract)public {
}
function updateOgMerkle(bytes32 _root)public {
}
function updateLvMerkle(bytes32 _root)public{
}
function royaltyInfo(
uint256 _tokenId,
uint256 _salePrice
) external view override returns (
address receiver,
uint256 royaltyAmount
){
}
function flipSaleState() public {
}
function flipclaim() public {
}
function updateRoyalty(uint newRoyalty) public onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable) returns (bool) {
}
function setBaseURI(string memory baseURI_) external {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setProvenance(string memory provenance) public onlyOwner {
}
function getSaleState() public view returns (bool) {
}
function prooveMerkle(bytes32[] calldata _merkleProof, bytes32 _merkleRoot)private view returns (bool) {
}
function launchSale() public {
}
function _confirmMint(uint _tokenNumber, uint _claim) private view returns (bool) {
}
function _doMint(uint numberOfTokens, address _target)private {
}
function TeamReserve(uint _amount)public onlyOwner{
}
function LoveStoryClaim()public{
}
//og mint
function OGMint(uint numberOfTokens, bytes32[] calldata _proof)public payable {
}
// Love Story mint
function LoveListMint(uint numberOfTokens, bytes32[] calldata _proof)public payable {
require(block.timestamp < SALE_START, "presale");
require(prooveMerkle(_proof, lvMerkle ),"whitelist");
require(_confirmMint(numberOfTokens,0), "failed");
require(<FILL_ME>)
_doMint(numberOfTokens, _msgSender());
}
// Public Mint
function XOXOMint(uint256 _amount) public payable {
}
function CreditCardMint(address _target, uint numberOfTokens) public {
}
function withdraw(address _beneficiary) public onlyOwner {
}
function transferOwnership(address newOwner) public override onlyOwner {
}
}
/*
%%%%%* /%%%%*
%%% %%
.%% %%
%% %
%% %
%% %
.% @@@@@@@@@@@@@@@@@@@@@ @@@@
%% @@@ @@@ @@@ ,
% @@@ @@@ @@@
%% &&& &@@@ @@@ %
% &&& @@@@ @@@
,% &&&&&&&&&&&&&&&&&&&%%(. @@@@@
% %%% @@@@@@@
% %%% @@@@ @@@@
%% %%% @@@@ @@@ %
%% %%% @@@ @@@ %
%% %%% @@@ @@@ %
%% %%%%%%%%%%%%%%%%@@@ @@@@ %
%% %
%% %
%% %
%%% %%
%%% %%#
#%%%%%%%
*/
| lvPrice*(numberOfTokens)<=msg.value,"Ether" | 264,653 | lvPrice*(numberOfTokens)<=msg.value |
"Ether" | // SPDX-License-Identifier: MIT
// @author: Exotic Technology LTD
pragma solidity ^0.8.0;
import "./ERC721.sol";
import "./ownable.sol";
import "./ERC721enumerable.sol";
import "./merkle.sol";
interface LVS{
function balanceOf(address owner) external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);
}
contract XOXO_By_Maya_and_Yehuda_Devir is Ownable, ERC721, ERC721Enumerable {
bool public saleIsActive = false;
bool public claim = false;
uint256 constant public claimToken = 101;
uint256 public claimed = 0;
uint256 constant public MAX_TOKEN = 10000;
uint256 constant public MAX_PUBLIC_MINT = 4;
uint256 public royalty = 80;
uint256 public ogPrice = 0.05 ether;
uint256 public lvPrice = 0.075 ether;
uint256 public tokenPrice = 0.101 ether;
uint256 public startingIndex = 0;
uint256 public startingIndexBlock = 0;
uint256 public SALE_START = 0;
address LVScontract;
bytes32 public ogMerkle = 0x6ee8bee8c77b05f5cf46ea9f7c98b6e3571366d95ccdb3f96be8640e43b6ec21;
bytes32 public lvMerkle = 0x6ee8bee8c77b05f5cf46ea9f7c98b6e3571366d95ccdb3f96be8640e43b6ec21;
string private _baseURIextended;
string public PROVENANCE;
mapping(address => uint) public minters;
mapping(address => bool) private senders;
mapping(uint => bool) private claimedTokens;
constructor() ERC721("XOXONFT", "XOXO") {
}
function addSender(address _address) public onlyOwner {
}
function removeSender(address _address) public onlyOwner {
}
function SetStartingIndexBlock() public onlyOwner {
}
function setStartingIndex() public onlyOwner {
}
function updateLvsAddress(address _contract)public {
}
function updateOgMerkle(bytes32 _root)public {
}
function updateLvMerkle(bytes32 _root)public{
}
function royaltyInfo(
uint256 _tokenId,
uint256 _salePrice
) external view override returns (
address receiver,
uint256 royaltyAmount
){
}
function flipSaleState() public {
}
function flipclaim() public {
}
function updateRoyalty(uint newRoyalty) public onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable) returns (bool) {
}
function setBaseURI(string memory baseURI_) external {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setProvenance(string memory provenance) public onlyOwner {
}
function getSaleState() public view returns (bool) {
}
function prooveMerkle(bytes32[] calldata _merkleProof, bytes32 _merkleRoot)private view returns (bool) {
}
function launchSale() public {
}
function _confirmMint(uint _tokenNumber, uint _claim) private view returns (bool) {
}
function _doMint(uint numberOfTokens, address _target)private {
}
function TeamReserve(uint _amount)public onlyOwner{
}
function LoveStoryClaim()public{
}
//og mint
function OGMint(uint numberOfTokens, bytes32[] calldata _proof)public payable {
}
// Love Story mint
function LoveListMint(uint numberOfTokens, bytes32[] calldata _proof)public payable {
}
// Public Mint
function XOXOMint(uint256 _amount) public payable {
require(block.timestamp >= SALE_START, "not yet");
require(<FILL_ME>)
require(_confirmMint(_amount,0), "closed");
_doMint(_amount, _msgSender());
}
function CreditCardMint(address _target, uint numberOfTokens) public {
}
function withdraw(address _beneficiary) public onlyOwner {
}
function transferOwnership(address newOwner) public override onlyOwner {
}
}
/*
%%%%%* /%%%%*
%%% %%
.%% %%
%% %
%% %
%% %
.% @@@@@@@@@@@@@@@@@@@@@ @@@@
%% @@@ @@@ @@@ ,
% @@@ @@@ @@@
%% &&& &@@@ @@@ %
% &&& @@@@ @@@
,% &&&&&&&&&&&&&&&&&&&%%(. @@@@@
% %%% @@@@@@@
% %%% @@@@ @@@@
%% %%% @@@@ @@@ %
%% %%% @@@ @@@ %
%% %%% @@@ @@@ %
%% %%%%%%%%%%%%%%%%@@@ @@@@ %
%% %
%% %
%% %
%%% %%
%%% %%#
#%%%%%%%
*/
| tokenPrice*(_amount)<=msg.value,"Ether" | 264,653 | tokenPrice*(_amount)<=msg.value |
"closed" | // SPDX-License-Identifier: MIT
// @author: Exotic Technology LTD
pragma solidity ^0.8.0;
import "./ERC721.sol";
import "./ownable.sol";
import "./ERC721enumerable.sol";
import "./merkle.sol";
interface LVS{
function balanceOf(address owner) external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);
}
contract XOXO_By_Maya_and_Yehuda_Devir is Ownable, ERC721, ERC721Enumerable {
bool public saleIsActive = false;
bool public claim = false;
uint256 constant public claimToken = 101;
uint256 public claimed = 0;
uint256 constant public MAX_TOKEN = 10000;
uint256 constant public MAX_PUBLIC_MINT = 4;
uint256 public royalty = 80;
uint256 public ogPrice = 0.05 ether;
uint256 public lvPrice = 0.075 ether;
uint256 public tokenPrice = 0.101 ether;
uint256 public startingIndex = 0;
uint256 public startingIndexBlock = 0;
uint256 public SALE_START = 0;
address LVScontract;
bytes32 public ogMerkle = 0x6ee8bee8c77b05f5cf46ea9f7c98b6e3571366d95ccdb3f96be8640e43b6ec21;
bytes32 public lvMerkle = 0x6ee8bee8c77b05f5cf46ea9f7c98b6e3571366d95ccdb3f96be8640e43b6ec21;
string private _baseURIextended;
string public PROVENANCE;
mapping(address => uint) public minters;
mapping(address => bool) private senders;
mapping(uint => bool) private claimedTokens;
constructor() ERC721("XOXONFT", "XOXO") {
}
function addSender(address _address) public onlyOwner {
}
function removeSender(address _address) public onlyOwner {
}
function SetStartingIndexBlock() public onlyOwner {
}
function setStartingIndex() public onlyOwner {
}
function updateLvsAddress(address _contract)public {
}
function updateOgMerkle(bytes32 _root)public {
}
function updateLvMerkle(bytes32 _root)public{
}
function royaltyInfo(
uint256 _tokenId,
uint256 _salePrice
) external view override returns (
address receiver,
uint256 royaltyAmount
){
}
function flipSaleState() public {
}
function flipclaim() public {
}
function updateRoyalty(uint newRoyalty) public onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable) returns (bool) {
}
function setBaseURI(string memory baseURI_) external {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setProvenance(string memory provenance) public onlyOwner {
}
function getSaleState() public view returns (bool) {
}
function prooveMerkle(bytes32[] calldata _merkleProof, bytes32 _merkleRoot)private view returns (bool) {
}
function launchSale() public {
}
function _confirmMint(uint _tokenNumber, uint _claim) private view returns (bool) {
}
function _doMint(uint numberOfTokens, address _target)private {
}
function TeamReserve(uint _amount)public onlyOwner{
}
function LoveStoryClaim()public{
}
//og mint
function OGMint(uint numberOfTokens, bytes32[] calldata _proof)public payable {
}
// Love Story mint
function LoveListMint(uint numberOfTokens, bytes32[] calldata _proof)public payable {
}
// Public Mint
function XOXOMint(uint256 _amount) public payable {
require(block.timestamp >= SALE_START, "not yet");
require(tokenPrice * (_amount) <= msg.value, "Ether");
require(<FILL_ME>)
_doMint(_amount, _msgSender());
}
function CreditCardMint(address _target, uint numberOfTokens) public {
}
function withdraw(address _beneficiary) public onlyOwner {
}
function transferOwnership(address newOwner) public override onlyOwner {
}
}
/*
%%%%%* /%%%%*
%%% %%
.%% %%
%% %
%% %
%% %
.% @@@@@@@@@@@@@@@@@@@@@ @@@@
%% @@@ @@@ @@@ ,
% @@@ @@@ @@@
%% &&& &@@@ @@@ %
% &&& @@@@ @@@
,% &&&&&&&&&&&&&&&&&&&%%(. @@@@@
% %%% @@@@@@@
% %%% @@@@ @@@@
%% %%% @@@@ @@@ %
%% %%% @@@ @@@ %
%% %%% @@@ @@@ %
%% %%%%%%%%%%%%%%%%@@@ @@@@ %
%% %
%% %
%% %
%%% %%
%%% %%#
#%%%%%%%
*/
| _confirmMint(_amount,0),"closed" | 264,653 | _confirmMint(_amount,0) |
"max" | // SPDX-License-Identifier: MIT
// @author: Exotic Technology LTD
pragma solidity ^0.8.0;
import "./ERC721.sol";
import "./ownable.sol";
import "./ERC721enumerable.sol";
import "./merkle.sol";
interface LVS{
function balanceOf(address owner) external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);
}
contract XOXO_By_Maya_and_Yehuda_Devir is Ownable, ERC721, ERC721Enumerable {
bool public saleIsActive = false;
bool public claim = false;
uint256 constant public claimToken = 101;
uint256 public claimed = 0;
uint256 constant public MAX_TOKEN = 10000;
uint256 constant public MAX_PUBLIC_MINT = 4;
uint256 public royalty = 80;
uint256 public ogPrice = 0.05 ether;
uint256 public lvPrice = 0.075 ether;
uint256 public tokenPrice = 0.101 ether;
uint256 public startingIndex = 0;
uint256 public startingIndexBlock = 0;
uint256 public SALE_START = 0;
address LVScontract;
bytes32 public ogMerkle = 0x6ee8bee8c77b05f5cf46ea9f7c98b6e3571366d95ccdb3f96be8640e43b6ec21;
bytes32 public lvMerkle = 0x6ee8bee8c77b05f5cf46ea9f7c98b6e3571366d95ccdb3f96be8640e43b6ec21;
string private _baseURIextended;
string public PROVENANCE;
mapping(address => uint) public minters;
mapping(address => bool) private senders;
mapping(uint => bool) private claimedTokens;
constructor() ERC721("XOXONFT", "XOXO") {
}
function addSender(address _address) public onlyOwner {
}
function removeSender(address _address) public onlyOwner {
}
function SetStartingIndexBlock() public onlyOwner {
}
function setStartingIndex() public onlyOwner {
}
function updateLvsAddress(address _contract)public {
}
function updateOgMerkle(bytes32 _root)public {
}
function updateLvMerkle(bytes32 _root)public{
}
function royaltyInfo(
uint256 _tokenId,
uint256 _salePrice
) external view override returns (
address receiver,
uint256 royaltyAmount
){
}
function flipSaleState() public {
}
function flipclaim() public {
}
function updateRoyalty(uint newRoyalty) public onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable) returns (bool) {
}
function setBaseURI(string memory baseURI_) external {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setProvenance(string memory provenance) public onlyOwner {
}
function getSaleState() public view returns (bool) {
}
function prooveMerkle(bytes32[] calldata _merkleProof, bytes32 _merkleRoot)private view returns (bool) {
}
function launchSale() public {
}
function _confirmMint(uint _tokenNumber, uint _claim) private view returns (bool) {
}
function _doMint(uint numberOfTokens, address _target)private {
}
function TeamReserve(uint _amount)public onlyOwner{
}
function LoveStoryClaim()public{
}
//og mint
function OGMint(uint numberOfTokens, bytes32[] calldata _proof)public payable {
}
// Love Story mint
function LoveListMint(uint numberOfTokens, bytes32[] calldata _proof)public payable {
}
// Public Mint
function XOXOMint(uint256 _amount) public payable {
}
function CreditCardMint(address _target, uint numberOfTokens) public {
require(senders[_msgSender()]);
require(numberOfTokens >0);
uint256 ts = totalSupply();
require(<FILL_ME>)
_doMint(numberOfTokens, _target);
}
function withdraw(address _beneficiary) public onlyOwner {
}
function transferOwnership(address newOwner) public override onlyOwner {
}
}
/*
%%%%%* /%%%%*
%%% %%
.%% %%
%% %
%% %
%% %
.% @@@@@@@@@@@@@@@@@@@@@ @@@@
%% @@@ @@@ @@@ ,
% @@@ @@@ @@@
%% &&& &@@@ @@@ %
% &&& @@@@ @@@
,% &&&&&&&&&&&&&&&&&&&%%(. @@@@@
% %%% @@@@@@@
% %%% @@@@ @@@@
%% %%% @@@@ @@@ %
%% %%% @@@ @@@ %
%% %%% @@@ @@@ %
%% %%%%%%%%%%%%%%%%@@@ @@@@ %
%% %
%% %
%% %
%%% %%
%%% %%#
#%%%%%%%
*/
| ts+numberOfTokens<=MAX_TOKEN,"max" | 264,653 | ts+numberOfTokens<=MAX_TOKEN |
"All YOKAI NFT minted" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.10 <0.9.0;
import './ERC721A.sol';
import './Ownable.sol';
// 0.033eth and ERC721A contract (low GAS Fee)
// 4444 Supply and 3 NFT per wallte & per tx
contract YOKAI is ERC721A, Ownable {
constructor() ERC721A("Yokai Labs v1", "YOKAI") {
}
string _baseTokenURI;
mapping(address => uint256) _minted;
uint public constant RESERVED = 44;
uint public Lab_Minted = 0;
function WLmint(uint256 quantity) public payable {
require(<FILL_ME>)
require(quantity <= 3, "Cant mint more than 3 YOKAI NFT in one tx");
require(_minted[msg.sender] < 3, "Cant mint more than 3 YOKAI NFT per wallet");
_minted[msg.sender] += quantity;
_mint(msg.sender, quantity);
}
function mintReserved(address toaddress, uint256 quantity) external onlyOwner
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
}
| totalSupply()+quantity<=4444-RESERVED-Lab_Minted,"All YOKAI NFT minted" | 264,675 | totalSupply()+quantity<=4444-RESERVED-Lab_Minted |
"Cant mint more than 3 YOKAI NFT per wallet" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.10 <0.9.0;
import './ERC721A.sol';
import './Ownable.sol';
// 0.033eth and ERC721A contract (low GAS Fee)
// 4444 Supply and 3 NFT per wallte & per tx
contract YOKAI is ERC721A, Ownable {
constructor() ERC721A("Yokai Labs v1", "YOKAI") {
}
string _baseTokenURI;
mapping(address => uint256) _minted;
uint public constant RESERVED = 44;
uint public Lab_Minted = 0;
function WLmint(uint256 quantity) public payable {
require(totalSupply() + quantity <= 4444 - RESERVED -Lab_Minted, "All YOKAI NFT minted");
require(quantity <= 3, "Cant mint more than 3 YOKAI NFT in one tx");
require(<FILL_ME>)
_minted[msg.sender] += quantity;
_mint(msg.sender, quantity);
}
function mintReserved(address toaddress, uint256 quantity) external onlyOwner
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
}
| _minted[msg.sender]<3,"Cant mint more than 3 YOKAI NFT per wallet" | 264,675 | _minted[msg.sender]<3 |
"Cant mint more than _RESERVED" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.10 <0.9.0;
import './ERC721A.sol';
import './Ownable.sol';
// 0.033eth and ERC721A contract (low GAS Fee)
// 4444 Supply and 3 NFT per wallte & per tx
contract YOKAI is ERC721A, Ownable {
constructor() ERC721A("Yokai Labs v1", "YOKAI") {
}
string _baseTokenURI;
mapping(address => uint256) _minted;
uint public constant RESERVED = 44;
uint public Lab_Minted = 0;
function WLmint(uint256 quantity) public payable {
}
function mintReserved(address toaddress, uint256 quantity) external onlyOwner
{
require(<FILL_ME>)
Lab_Minted = Lab_Minted + quantity;
_mint(toaddress, quantity);
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
}
| Lab_Minted+quantity<=RESERVED,"Cant mint more than _RESERVED" | 264,675 | Lab_Minted+quantity<=RESERVED |
"Bridge: wrong epoch number" | // SPDX-License-Identifier: UNLICENSED
// Copyright (c) Eywa.Fi, 2021-2023 - all rights reserved
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/AccessControlEnumerable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "../interfaces/IBridgeV2.sol";
import "../utils/Block.sol";
import "../utils/Bls.sol";
import "../utils/Merkle.sol";
import "../utils/RequestIdChecker.sol";
import "../utils/Typecast.sol";
contract BridgeV2 is IBridgeV2, AccessControlEnumerable, Typecast, ReentrancyGuard {
using Address for address;
using Bls for Bls.Epoch;
/// @dev gate keeper role id
bytes32 public constant GATEKEEPER_ROLE = keccak256("GATEKEEPER_ROLE");
/// @dev validator role id
bytes32 public constant VALIDATOR_ROLE = keccak256("VALIDATOR_ROLE");
/// @dev operator role id
bytes32 public constant OPERATOR_ROLE = keccak256("OPERATOR_ROLE");
/// @dev human readable version
string public version;
/// @dev current state Active\Inactive
State public state;
/// @dev nonces
mapping(address => uint256) public nonces;
/// @dev received request IDs against relay
RequestIdChecker public currentRequestIdChecker;
/// @dev received request IDs against relay
RequestIdChecker public previousRequestIdChecker;
// current epoch
Bls.Epoch internal currentEpoch;
// previous epoch
Bls.Epoch internal previousEpoch;
event EpochUpdated(bytes key, uint32 epochNum, uint64 protocolVersion);
event RequestSent(
bytes32 requestId,
bytes data,
address to,
uint64 chainIdTo
);
event RequestReceived(bytes32 requestId, string error);
event StateSet(State state);
constructor() {
}
/**
* @dev Get current epoch.
*/
function getCurrentEpoch() public view returns (bytes memory, uint8, uint32) {
}
/**
* @dev Get previous epoch.
*/
function getPreviousEpoch() public view returns (bytes memory, uint8, uint32) {
}
/**
* @dev Updates current epoch.
*
* @param params ReceiveParams struct.
*/
function updateEpoch(ReceiveParams calldata params) external onlyRole(VALIDATOR_ROLE) {
// TODO ensure that new epoch really next one after previous (by hash)
bytes memory payload = Merkle.prove(params.merkleProof, Block.txRootHash(params.blockHeader));
(uint64 newEpochProtocolVersion, uint32 newEpochNum, bytes memory newKey, uint8 newParticipantsCount) = Block
.decodeEpochUpdate(payload);
require(<FILL_ME>)
// TODO remove if when resetEpoch will be removed
if (currentEpoch.isSet()) {
verifyEpoch(currentEpoch, params);
rotateEpoch();
}
// TODO ensure that new epoch really next one after previous (prev hash + params.blockHeader)
bytes32 newHash = sha256(params.blockHeader);
currentEpoch.update(newKey, newParticipantsCount, newEpochNum, newHash);
onEpochStart(newEpochProtocolVersion);
}
/**
* @dev Forcefully reset epoch on all chains.
*/
function resetEpoch() public onlyRole(OPERATOR_ROLE) {
}
/**
* @dev Send crosschain request v2.
*
* @param params struct with requestId, data, receiver and opposite cahinId
* @param from sender's address
* @param nonce sender's nonce
*/
function sendV2(
SendParams calldata params,
address from,
uint256 nonce
) external override onlyRole(GATEKEEPER_ROLE) returns (bool) {
}
/**
* @dev Receive (batch) crosschain request v2.
*
* @param params array with ReceiveParams structs.
*/
function receiveV2(ReceiveParams[] calldata params) external override onlyRole(VALIDATOR_ROLE) nonReentrant returns (bool) {
}
/**
* @dev Set new state.
*
* @param state_ Active\Inactive state
*/
function setState(State state_) external onlyRole(OPERATOR_ROLE) {
}
/**
* @dev Verifies epoch.
*
* @param epoch current or previous epoch;
* @param params oracle tx params
*/
function verifyEpoch(Bls.Epoch storage epoch, ReceiveParams calldata params) internal view {
}
/**
* @dev Verifies and updates the sender's nonce.
*
* @param from sender's address
* @param nonce provided nonce
*/
function verifyAndUpdateNonce(address from, uint256 nonce) internal {
}
/**
* @dev Moves current epoch and current request filter to previous.
*/
function rotateEpoch() internal {
}
/**
* @dev Hook on start new epoch.
*/
function onEpochStart(uint64 protocolVersion_) internal virtual {
}
}
| currentEpoch.epochNum+1==newEpochNum,"Bridge: wrong epoch number" | 264,839 | currentEpoch.epochNum+1==newEpochNum |
"Bridge: epoch not set" | // SPDX-License-Identifier: UNLICENSED
// Copyright (c) Eywa.Fi, 2021-2023 - all rights reserved
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/AccessControlEnumerable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "../interfaces/IBridgeV2.sol";
import "../utils/Block.sol";
import "../utils/Bls.sol";
import "../utils/Merkle.sol";
import "../utils/RequestIdChecker.sol";
import "../utils/Typecast.sol";
contract BridgeV2 is IBridgeV2, AccessControlEnumerable, Typecast, ReentrancyGuard {
using Address for address;
using Bls for Bls.Epoch;
/// @dev gate keeper role id
bytes32 public constant GATEKEEPER_ROLE = keccak256("GATEKEEPER_ROLE");
/// @dev validator role id
bytes32 public constant VALIDATOR_ROLE = keccak256("VALIDATOR_ROLE");
/// @dev operator role id
bytes32 public constant OPERATOR_ROLE = keccak256("OPERATOR_ROLE");
/// @dev human readable version
string public version;
/// @dev current state Active\Inactive
State public state;
/// @dev nonces
mapping(address => uint256) public nonces;
/// @dev received request IDs against relay
RequestIdChecker public currentRequestIdChecker;
/// @dev received request IDs against relay
RequestIdChecker public previousRequestIdChecker;
// current epoch
Bls.Epoch internal currentEpoch;
// previous epoch
Bls.Epoch internal previousEpoch;
event EpochUpdated(bytes key, uint32 epochNum, uint64 protocolVersion);
event RequestSent(
bytes32 requestId,
bytes data,
address to,
uint64 chainIdTo
);
event RequestReceived(bytes32 requestId, string error);
event StateSet(State state);
constructor() {
}
/**
* @dev Get current epoch.
*/
function getCurrentEpoch() public view returns (bytes memory, uint8, uint32) {
}
/**
* @dev Get previous epoch.
*/
function getPreviousEpoch() public view returns (bytes memory, uint8, uint32) {
}
/**
* @dev Updates current epoch.
*
* @param params ReceiveParams struct.
*/
function updateEpoch(ReceiveParams calldata params) external onlyRole(VALIDATOR_ROLE) {
}
/**
* @dev Forcefully reset epoch on all chains.
*/
function resetEpoch() public onlyRole(OPERATOR_ROLE) {
}
/**
* @dev Send crosschain request v2.
*
* @param params struct with requestId, data, receiver and opposite cahinId
* @param from sender's address
* @param nonce sender's nonce
*/
function sendV2(
SendParams calldata params,
address from,
uint256 nonce
) external override onlyRole(GATEKEEPER_ROLE) returns (bool) {
require(state == State.Active, "Bridge: state inactive");
require(<FILL_ME>)
verifyAndUpdateNonce(from, nonce);
emit RequestSent(
params.requestId,
params.data,
params.to,
uint64(params.chainIdTo)
);
return true;
}
/**
* @dev Receive (batch) crosschain request v2.
*
* @param params array with ReceiveParams structs.
*/
function receiveV2(ReceiveParams[] calldata params) external override onlyRole(VALIDATOR_ROLE) nonReentrant returns (bool) {
}
/**
* @dev Set new state.
*
* @param state_ Active\Inactive state
*/
function setState(State state_) external onlyRole(OPERATOR_ROLE) {
}
/**
* @dev Verifies epoch.
*
* @param epoch current or previous epoch;
* @param params oracle tx params
*/
function verifyEpoch(Bls.Epoch storage epoch, ReceiveParams calldata params) internal view {
}
/**
* @dev Verifies and updates the sender's nonce.
*
* @param from sender's address
* @param nonce provided nonce
*/
function verifyAndUpdateNonce(address from, uint256 nonce) internal {
}
/**
* @dev Moves current epoch and current request filter to previous.
*/
function rotateEpoch() internal {
}
/**
* @dev Hook on start new epoch.
*/
function onEpochStart(uint64 protocolVersion_) internal virtual {
}
}
| previousEpoch.isSet()||currentEpoch.isSet(),"Bridge: epoch not set" | 264,839 | previousEpoch.isSet()||currentEpoch.isSet() |
"Bridge: epoch not set" | // SPDX-License-Identifier: UNLICENSED
// Copyright (c) Eywa.Fi, 2021-2023 - all rights reserved
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/AccessControlEnumerable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "../interfaces/IBridgeV2.sol";
import "../utils/Block.sol";
import "../utils/Bls.sol";
import "../utils/Merkle.sol";
import "../utils/RequestIdChecker.sol";
import "../utils/Typecast.sol";
contract BridgeV2 is IBridgeV2, AccessControlEnumerable, Typecast, ReentrancyGuard {
using Address for address;
using Bls for Bls.Epoch;
/// @dev gate keeper role id
bytes32 public constant GATEKEEPER_ROLE = keccak256("GATEKEEPER_ROLE");
/// @dev validator role id
bytes32 public constant VALIDATOR_ROLE = keccak256("VALIDATOR_ROLE");
/// @dev operator role id
bytes32 public constant OPERATOR_ROLE = keccak256("OPERATOR_ROLE");
/// @dev human readable version
string public version;
/// @dev current state Active\Inactive
State public state;
/// @dev nonces
mapping(address => uint256) public nonces;
/// @dev received request IDs against relay
RequestIdChecker public currentRequestIdChecker;
/// @dev received request IDs against relay
RequestIdChecker public previousRequestIdChecker;
// current epoch
Bls.Epoch internal currentEpoch;
// previous epoch
Bls.Epoch internal previousEpoch;
event EpochUpdated(bytes key, uint32 epochNum, uint64 protocolVersion);
event RequestSent(
bytes32 requestId,
bytes data,
address to,
uint64 chainIdTo
);
event RequestReceived(bytes32 requestId, string error);
event StateSet(State state);
constructor() {
}
/**
* @dev Get current epoch.
*/
function getCurrentEpoch() public view returns (bytes memory, uint8, uint32) {
}
/**
* @dev Get previous epoch.
*/
function getPreviousEpoch() public view returns (bytes memory, uint8, uint32) {
}
/**
* @dev Updates current epoch.
*
* @param params ReceiveParams struct.
*/
function updateEpoch(ReceiveParams calldata params) external onlyRole(VALIDATOR_ROLE) {
}
/**
* @dev Forcefully reset epoch on all chains.
*/
function resetEpoch() public onlyRole(OPERATOR_ROLE) {
}
/**
* @dev Send crosschain request v2.
*
* @param params struct with requestId, data, receiver and opposite cahinId
* @param from sender's address
* @param nonce sender's nonce
*/
function sendV2(
SendParams calldata params,
address from,
uint256 nonce
) external override onlyRole(GATEKEEPER_ROLE) returns (bool) {
}
/**
* @dev Receive (batch) crosschain request v2.
*
* @param params array with ReceiveParams structs.
*/
function receiveV2(ReceiveParams[] calldata params) external override onlyRole(VALIDATOR_ROLE) nonReentrant returns (bool) {
require(state != State.Inactive, "Bridge: state inactive");
for (uint256 i = 0; i < params.length; ++i) {
bytes32 epochHash = Block.epochHash(params[i].blockHeader);
// verify the block signature
if (epochHash == currentEpoch.epochHash) {
require(<FILL_ME>)
verifyEpoch(currentEpoch, params[i]);
} else if (epochHash == previousEpoch.epochHash) {
require(previousEpoch.isSet(), "Bridge: epoch not set");
verifyEpoch(previousEpoch, params[i]);
} else {
revert("Bridge: wrong epoch");
}
// verify that the transaction is really in the block
bytes memory payload = Merkle.prove(params[i].merkleProof, Block.txRootHash(params[i].blockHeader));
// get call data
(bytes32 requestId, bytes memory receivedData, address to, uint64 chainIdTo) = Block.decodeRequest(payload);
require(chainIdTo == block.chainid, "Bridge: wrong chain id");
require(to.isContract(), "Bridge: receiver is not a contract");
bool isRequestIdUniq;
if (epochHash == currentEpoch.epochHash) {
isRequestIdUniq = currentRequestIdChecker.check(requestId);
} else {
isRequestIdUniq = previousRequestIdChecker.check(requestId);
}
string memory err;
if (isRequestIdUniq) {
(bytes memory data, bytes memory check) = abi.decode(receivedData, (bytes, bytes));
bytes memory result = to.functionCall(check);
require(abi.decode(result, (bool)), "Bridge: check failed");
to.functionCall(data, "Bridge: receive failed");
} else {
revert("Bridge: request id already seen");
}
emit RequestReceived(requestId, err);
}
return true;
}
/**
* @dev Set new state.
*
* @param state_ Active\Inactive state
*/
function setState(State state_) external onlyRole(OPERATOR_ROLE) {
}
/**
* @dev Verifies epoch.
*
* @param epoch current or previous epoch;
* @param params oracle tx params
*/
function verifyEpoch(Bls.Epoch storage epoch, ReceiveParams calldata params) internal view {
}
/**
* @dev Verifies and updates the sender's nonce.
*
* @param from sender's address
* @param nonce provided nonce
*/
function verifyAndUpdateNonce(address from, uint256 nonce) internal {
}
/**
* @dev Moves current epoch and current request filter to previous.
*/
function rotateEpoch() internal {
}
/**
* @dev Hook on start new epoch.
*/
function onEpochStart(uint64 protocolVersion_) internal virtual {
}
}
| currentEpoch.isSet(),"Bridge: epoch not set" | 264,839 | currentEpoch.isSet() |
"Bridge: epoch not set" | // SPDX-License-Identifier: UNLICENSED
// Copyright (c) Eywa.Fi, 2021-2023 - all rights reserved
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/AccessControlEnumerable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "../interfaces/IBridgeV2.sol";
import "../utils/Block.sol";
import "../utils/Bls.sol";
import "../utils/Merkle.sol";
import "../utils/RequestIdChecker.sol";
import "../utils/Typecast.sol";
contract BridgeV2 is IBridgeV2, AccessControlEnumerable, Typecast, ReentrancyGuard {
using Address for address;
using Bls for Bls.Epoch;
/// @dev gate keeper role id
bytes32 public constant GATEKEEPER_ROLE = keccak256("GATEKEEPER_ROLE");
/// @dev validator role id
bytes32 public constant VALIDATOR_ROLE = keccak256("VALIDATOR_ROLE");
/// @dev operator role id
bytes32 public constant OPERATOR_ROLE = keccak256("OPERATOR_ROLE");
/// @dev human readable version
string public version;
/// @dev current state Active\Inactive
State public state;
/// @dev nonces
mapping(address => uint256) public nonces;
/// @dev received request IDs against relay
RequestIdChecker public currentRequestIdChecker;
/// @dev received request IDs against relay
RequestIdChecker public previousRequestIdChecker;
// current epoch
Bls.Epoch internal currentEpoch;
// previous epoch
Bls.Epoch internal previousEpoch;
event EpochUpdated(bytes key, uint32 epochNum, uint64 protocolVersion);
event RequestSent(
bytes32 requestId,
bytes data,
address to,
uint64 chainIdTo
);
event RequestReceived(bytes32 requestId, string error);
event StateSet(State state);
constructor() {
}
/**
* @dev Get current epoch.
*/
function getCurrentEpoch() public view returns (bytes memory, uint8, uint32) {
}
/**
* @dev Get previous epoch.
*/
function getPreviousEpoch() public view returns (bytes memory, uint8, uint32) {
}
/**
* @dev Updates current epoch.
*
* @param params ReceiveParams struct.
*/
function updateEpoch(ReceiveParams calldata params) external onlyRole(VALIDATOR_ROLE) {
}
/**
* @dev Forcefully reset epoch on all chains.
*/
function resetEpoch() public onlyRole(OPERATOR_ROLE) {
}
/**
* @dev Send crosschain request v2.
*
* @param params struct with requestId, data, receiver and opposite cahinId
* @param from sender's address
* @param nonce sender's nonce
*/
function sendV2(
SendParams calldata params,
address from,
uint256 nonce
) external override onlyRole(GATEKEEPER_ROLE) returns (bool) {
}
/**
* @dev Receive (batch) crosschain request v2.
*
* @param params array with ReceiveParams structs.
*/
function receiveV2(ReceiveParams[] calldata params) external override onlyRole(VALIDATOR_ROLE) nonReentrant returns (bool) {
require(state != State.Inactive, "Bridge: state inactive");
for (uint256 i = 0; i < params.length; ++i) {
bytes32 epochHash = Block.epochHash(params[i].blockHeader);
// verify the block signature
if (epochHash == currentEpoch.epochHash) {
require(currentEpoch.isSet(), "Bridge: epoch not set");
verifyEpoch(currentEpoch, params[i]);
} else if (epochHash == previousEpoch.epochHash) {
require(<FILL_ME>)
verifyEpoch(previousEpoch, params[i]);
} else {
revert("Bridge: wrong epoch");
}
// verify that the transaction is really in the block
bytes memory payload = Merkle.prove(params[i].merkleProof, Block.txRootHash(params[i].blockHeader));
// get call data
(bytes32 requestId, bytes memory receivedData, address to, uint64 chainIdTo) = Block.decodeRequest(payload);
require(chainIdTo == block.chainid, "Bridge: wrong chain id");
require(to.isContract(), "Bridge: receiver is not a contract");
bool isRequestIdUniq;
if (epochHash == currentEpoch.epochHash) {
isRequestIdUniq = currentRequestIdChecker.check(requestId);
} else {
isRequestIdUniq = previousRequestIdChecker.check(requestId);
}
string memory err;
if (isRequestIdUniq) {
(bytes memory data, bytes memory check) = abi.decode(receivedData, (bytes, bytes));
bytes memory result = to.functionCall(check);
require(abi.decode(result, (bool)), "Bridge: check failed");
to.functionCall(data, "Bridge: receive failed");
} else {
revert("Bridge: request id already seen");
}
emit RequestReceived(requestId, err);
}
return true;
}
/**
* @dev Set new state.
*
* @param state_ Active\Inactive state
*/
function setState(State state_) external onlyRole(OPERATOR_ROLE) {
}
/**
* @dev Verifies epoch.
*
* @param epoch current or previous epoch;
* @param params oracle tx params
*/
function verifyEpoch(Bls.Epoch storage epoch, ReceiveParams calldata params) internal view {
}
/**
* @dev Verifies and updates the sender's nonce.
*
* @param from sender's address
* @param nonce provided nonce
*/
function verifyAndUpdateNonce(address from, uint256 nonce) internal {
}
/**
* @dev Moves current epoch and current request filter to previous.
*/
function rotateEpoch() internal {
}
/**
* @dev Hook on start new epoch.
*/
function onEpochStart(uint64 protocolVersion_) internal virtual {
}
}
| previousEpoch.isSet(),"Bridge: epoch not set" | 264,839 | previousEpoch.isSet() |
"Bridge: receiver is not a contract" | // SPDX-License-Identifier: UNLICENSED
// Copyright (c) Eywa.Fi, 2021-2023 - all rights reserved
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/AccessControlEnumerable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "../interfaces/IBridgeV2.sol";
import "../utils/Block.sol";
import "../utils/Bls.sol";
import "../utils/Merkle.sol";
import "../utils/RequestIdChecker.sol";
import "../utils/Typecast.sol";
contract BridgeV2 is IBridgeV2, AccessControlEnumerable, Typecast, ReentrancyGuard {
using Address for address;
using Bls for Bls.Epoch;
/// @dev gate keeper role id
bytes32 public constant GATEKEEPER_ROLE = keccak256("GATEKEEPER_ROLE");
/// @dev validator role id
bytes32 public constant VALIDATOR_ROLE = keccak256("VALIDATOR_ROLE");
/// @dev operator role id
bytes32 public constant OPERATOR_ROLE = keccak256("OPERATOR_ROLE");
/// @dev human readable version
string public version;
/// @dev current state Active\Inactive
State public state;
/// @dev nonces
mapping(address => uint256) public nonces;
/// @dev received request IDs against relay
RequestIdChecker public currentRequestIdChecker;
/// @dev received request IDs against relay
RequestIdChecker public previousRequestIdChecker;
// current epoch
Bls.Epoch internal currentEpoch;
// previous epoch
Bls.Epoch internal previousEpoch;
event EpochUpdated(bytes key, uint32 epochNum, uint64 protocolVersion);
event RequestSent(
bytes32 requestId,
bytes data,
address to,
uint64 chainIdTo
);
event RequestReceived(bytes32 requestId, string error);
event StateSet(State state);
constructor() {
}
/**
* @dev Get current epoch.
*/
function getCurrentEpoch() public view returns (bytes memory, uint8, uint32) {
}
/**
* @dev Get previous epoch.
*/
function getPreviousEpoch() public view returns (bytes memory, uint8, uint32) {
}
/**
* @dev Updates current epoch.
*
* @param params ReceiveParams struct.
*/
function updateEpoch(ReceiveParams calldata params) external onlyRole(VALIDATOR_ROLE) {
}
/**
* @dev Forcefully reset epoch on all chains.
*/
function resetEpoch() public onlyRole(OPERATOR_ROLE) {
}
/**
* @dev Send crosschain request v2.
*
* @param params struct with requestId, data, receiver and opposite cahinId
* @param from sender's address
* @param nonce sender's nonce
*/
function sendV2(
SendParams calldata params,
address from,
uint256 nonce
) external override onlyRole(GATEKEEPER_ROLE) returns (bool) {
}
/**
* @dev Receive (batch) crosschain request v2.
*
* @param params array with ReceiveParams structs.
*/
function receiveV2(ReceiveParams[] calldata params) external override onlyRole(VALIDATOR_ROLE) nonReentrant returns (bool) {
require(state != State.Inactive, "Bridge: state inactive");
for (uint256 i = 0; i < params.length; ++i) {
bytes32 epochHash = Block.epochHash(params[i].blockHeader);
// verify the block signature
if (epochHash == currentEpoch.epochHash) {
require(currentEpoch.isSet(), "Bridge: epoch not set");
verifyEpoch(currentEpoch, params[i]);
} else if (epochHash == previousEpoch.epochHash) {
require(previousEpoch.isSet(), "Bridge: epoch not set");
verifyEpoch(previousEpoch, params[i]);
} else {
revert("Bridge: wrong epoch");
}
// verify that the transaction is really in the block
bytes memory payload = Merkle.prove(params[i].merkleProof, Block.txRootHash(params[i].blockHeader));
// get call data
(bytes32 requestId, bytes memory receivedData, address to, uint64 chainIdTo) = Block.decodeRequest(payload);
require(chainIdTo == block.chainid, "Bridge: wrong chain id");
require(<FILL_ME>)
bool isRequestIdUniq;
if (epochHash == currentEpoch.epochHash) {
isRequestIdUniq = currentRequestIdChecker.check(requestId);
} else {
isRequestIdUniq = previousRequestIdChecker.check(requestId);
}
string memory err;
if (isRequestIdUniq) {
(bytes memory data, bytes memory check) = abi.decode(receivedData, (bytes, bytes));
bytes memory result = to.functionCall(check);
require(abi.decode(result, (bool)), "Bridge: check failed");
to.functionCall(data, "Bridge: receive failed");
} else {
revert("Bridge: request id already seen");
}
emit RequestReceived(requestId, err);
}
return true;
}
/**
* @dev Set new state.
*
* @param state_ Active\Inactive state
*/
function setState(State state_) external onlyRole(OPERATOR_ROLE) {
}
/**
* @dev Verifies epoch.
*
* @param epoch current or previous epoch;
* @param params oracle tx params
*/
function verifyEpoch(Bls.Epoch storage epoch, ReceiveParams calldata params) internal view {
}
/**
* @dev Verifies and updates the sender's nonce.
*
* @param from sender's address
* @param nonce provided nonce
*/
function verifyAndUpdateNonce(address from, uint256 nonce) internal {
}
/**
* @dev Moves current epoch and current request filter to previous.
*/
function rotateEpoch() internal {
}
/**
* @dev Hook on start new epoch.
*/
function onEpochStart(uint64 protocolVersion_) internal virtual {
}
}
| to.isContract(),"Bridge: receiver is not a contract" | 264,839 | to.isContract() |
"Bridge: check failed" | // SPDX-License-Identifier: UNLICENSED
// Copyright (c) Eywa.Fi, 2021-2023 - all rights reserved
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/AccessControlEnumerable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "../interfaces/IBridgeV2.sol";
import "../utils/Block.sol";
import "../utils/Bls.sol";
import "../utils/Merkle.sol";
import "../utils/RequestIdChecker.sol";
import "../utils/Typecast.sol";
contract BridgeV2 is IBridgeV2, AccessControlEnumerable, Typecast, ReentrancyGuard {
using Address for address;
using Bls for Bls.Epoch;
/// @dev gate keeper role id
bytes32 public constant GATEKEEPER_ROLE = keccak256("GATEKEEPER_ROLE");
/// @dev validator role id
bytes32 public constant VALIDATOR_ROLE = keccak256("VALIDATOR_ROLE");
/// @dev operator role id
bytes32 public constant OPERATOR_ROLE = keccak256("OPERATOR_ROLE");
/// @dev human readable version
string public version;
/// @dev current state Active\Inactive
State public state;
/// @dev nonces
mapping(address => uint256) public nonces;
/// @dev received request IDs against relay
RequestIdChecker public currentRequestIdChecker;
/// @dev received request IDs against relay
RequestIdChecker public previousRequestIdChecker;
// current epoch
Bls.Epoch internal currentEpoch;
// previous epoch
Bls.Epoch internal previousEpoch;
event EpochUpdated(bytes key, uint32 epochNum, uint64 protocolVersion);
event RequestSent(
bytes32 requestId,
bytes data,
address to,
uint64 chainIdTo
);
event RequestReceived(bytes32 requestId, string error);
event StateSet(State state);
constructor() {
}
/**
* @dev Get current epoch.
*/
function getCurrentEpoch() public view returns (bytes memory, uint8, uint32) {
}
/**
* @dev Get previous epoch.
*/
function getPreviousEpoch() public view returns (bytes memory, uint8, uint32) {
}
/**
* @dev Updates current epoch.
*
* @param params ReceiveParams struct.
*/
function updateEpoch(ReceiveParams calldata params) external onlyRole(VALIDATOR_ROLE) {
}
/**
* @dev Forcefully reset epoch on all chains.
*/
function resetEpoch() public onlyRole(OPERATOR_ROLE) {
}
/**
* @dev Send crosschain request v2.
*
* @param params struct with requestId, data, receiver and opposite cahinId
* @param from sender's address
* @param nonce sender's nonce
*/
function sendV2(
SendParams calldata params,
address from,
uint256 nonce
) external override onlyRole(GATEKEEPER_ROLE) returns (bool) {
}
/**
* @dev Receive (batch) crosschain request v2.
*
* @param params array with ReceiveParams structs.
*/
function receiveV2(ReceiveParams[] calldata params) external override onlyRole(VALIDATOR_ROLE) nonReentrant returns (bool) {
require(state != State.Inactive, "Bridge: state inactive");
for (uint256 i = 0; i < params.length; ++i) {
bytes32 epochHash = Block.epochHash(params[i].blockHeader);
// verify the block signature
if (epochHash == currentEpoch.epochHash) {
require(currentEpoch.isSet(), "Bridge: epoch not set");
verifyEpoch(currentEpoch, params[i]);
} else if (epochHash == previousEpoch.epochHash) {
require(previousEpoch.isSet(), "Bridge: epoch not set");
verifyEpoch(previousEpoch, params[i]);
} else {
revert("Bridge: wrong epoch");
}
// verify that the transaction is really in the block
bytes memory payload = Merkle.prove(params[i].merkleProof, Block.txRootHash(params[i].blockHeader));
// get call data
(bytes32 requestId, bytes memory receivedData, address to, uint64 chainIdTo) = Block.decodeRequest(payload);
require(chainIdTo == block.chainid, "Bridge: wrong chain id");
require(to.isContract(), "Bridge: receiver is not a contract");
bool isRequestIdUniq;
if (epochHash == currentEpoch.epochHash) {
isRequestIdUniq = currentRequestIdChecker.check(requestId);
} else {
isRequestIdUniq = previousRequestIdChecker.check(requestId);
}
string memory err;
if (isRequestIdUniq) {
(bytes memory data, bytes memory check) = abi.decode(receivedData, (bytes, bytes));
bytes memory result = to.functionCall(check);
require(<FILL_ME>)
to.functionCall(data, "Bridge: receive failed");
} else {
revert("Bridge: request id already seen");
}
emit RequestReceived(requestId, err);
}
return true;
}
/**
* @dev Set new state.
*
* @param state_ Active\Inactive state
*/
function setState(State state_) external onlyRole(OPERATOR_ROLE) {
}
/**
* @dev Verifies epoch.
*
* @param epoch current or previous epoch;
* @param params oracle tx params
*/
function verifyEpoch(Bls.Epoch storage epoch, ReceiveParams calldata params) internal view {
}
/**
* @dev Verifies and updates the sender's nonce.
*
* @param from sender's address
* @param nonce provided nonce
*/
function verifyAndUpdateNonce(address from, uint256 nonce) internal {
}
/**
* @dev Moves current epoch and current request filter to previous.
*/
function rotateEpoch() internal {
}
/**
* @dev Hook on start new epoch.
*/
function onEpochStart(uint64 protocolVersion_) internal virtual {
}
}
| abi.decode(result,(bool)),"Bridge: check failed" | 264,839 | abi.decode(result,(bool)) |
"Bridge: nonce mismatch" | // SPDX-License-Identifier: UNLICENSED
// Copyright (c) Eywa.Fi, 2021-2023 - all rights reserved
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/AccessControlEnumerable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "../interfaces/IBridgeV2.sol";
import "../utils/Block.sol";
import "../utils/Bls.sol";
import "../utils/Merkle.sol";
import "../utils/RequestIdChecker.sol";
import "../utils/Typecast.sol";
contract BridgeV2 is IBridgeV2, AccessControlEnumerable, Typecast, ReentrancyGuard {
using Address for address;
using Bls for Bls.Epoch;
/// @dev gate keeper role id
bytes32 public constant GATEKEEPER_ROLE = keccak256("GATEKEEPER_ROLE");
/// @dev validator role id
bytes32 public constant VALIDATOR_ROLE = keccak256("VALIDATOR_ROLE");
/// @dev operator role id
bytes32 public constant OPERATOR_ROLE = keccak256("OPERATOR_ROLE");
/// @dev human readable version
string public version;
/// @dev current state Active\Inactive
State public state;
/// @dev nonces
mapping(address => uint256) public nonces;
/// @dev received request IDs against relay
RequestIdChecker public currentRequestIdChecker;
/// @dev received request IDs against relay
RequestIdChecker public previousRequestIdChecker;
// current epoch
Bls.Epoch internal currentEpoch;
// previous epoch
Bls.Epoch internal previousEpoch;
event EpochUpdated(bytes key, uint32 epochNum, uint64 protocolVersion);
event RequestSent(
bytes32 requestId,
bytes data,
address to,
uint64 chainIdTo
);
event RequestReceived(bytes32 requestId, string error);
event StateSet(State state);
constructor() {
}
/**
* @dev Get current epoch.
*/
function getCurrentEpoch() public view returns (bytes memory, uint8, uint32) {
}
/**
* @dev Get previous epoch.
*/
function getPreviousEpoch() public view returns (bytes memory, uint8, uint32) {
}
/**
* @dev Updates current epoch.
*
* @param params ReceiveParams struct.
*/
function updateEpoch(ReceiveParams calldata params) external onlyRole(VALIDATOR_ROLE) {
}
/**
* @dev Forcefully reset epoch on all chains.
*/
function resetEpoch() public onlyRole(OPERATOR_ROLE) {
}
/**
* @dev Send crosschain request v2.
*
* @param params struct with requestId, data, receiver and opposite cahinId
* @param from sender's address
* @param nonce sender's nonce
*/
function sendV2(
SendParams calldata params,
address from,
uint256 nonce
) external override onlyRole(GATEKEEPER_ROLE) returns (bool) {
}
/**
* @dev Receive (batch) crosschain request v2.
*
* @param params array with ReceiveParams structs.
*/
function receiveV2(ReceiveParams[] calldata params) external override onlyRole(VALIDATOR_ROLE) nonReentrant returns (bool) {
}
/**
* @dev Set new state.
*
* @param state_ Active\Inactive state
*/
function setState(State state_) external onlyRole(OPERATOR_ROLE) {
}
/**
* @dev Verifies epoch.
*
* @param epoch current or previous epoch;
* @param params oracle tx params
*/
function verifyEpoch(Bls.Epoch storage epoch, ReceiveParams calldata params) internal view {
}
/**
* @dev Verifies and updates the sender's nonce.
*
* @param from sender's address
* @param nonce provided nonce
*/
function verifyAndUpdateNonce(address from, uint256 nonce) internal {
require(<FILL_ME>)
}
/**
* @dev Moves current epoch and current request filter to previous.
*/
function rotateEpoch() internal {
}
/**
* @dev Hook on start new epoch.
*/
function onEpochStart(uint64 protocolVersion_) internal virtual {
}
}
| nonces[from]++==nonce,"Bridge: nonce mismatch" | 264,839 | nonces[from]++==nonce |
"Not whitelisted" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/*
@
@@@@@@
@@@@@@@@
@@@@@@@@
@@@@@@@@
@@@@@@@@@@@,
@@@@@@@@@@@@@@@@@@
* @@@@@@@@@@@@@@@@@@@@@@@@#
/@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@,&@@@@@@@@@@@@@@@@@@@@@@@@@&
,@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@%@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@#@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@&@@
/@@@@@@@@@@@@@@@@@@@@@@@@@@@@&
/@@@@&@@@@@@@@@@@@@%@##*%@@@@
@&@@@@@@@@@@@@@@&%@@@@@@@@@@
@@@@@@@&@@&&@@@@@#@@@% @@@@
@@&@@@@@@@@@@&&@&&&@@@@@@#@@
@@@@@&@@@@@@@@@@@@@@@@@@@%@@
@@@@@@@@@@&@@@@@@@@@@@@@@%@@
@&@@@&@@@@@@@@@@@@@@@@@&@&@@
@&@@@@@@@@@@@@@@@@@@@@&&&%@@
%%@@ @@@@%@@@@@@@%@@&%&%%%@@
@@@@@@@&@@&//@@@@@@ &@&%@@@
@@@@&@@@@@@@@@@@@@@&&%&%&@@
&@@%@@@@(@@@@@@&&&&&&&%%@@@
@@@@@@@@@@&/@@@&@&&&@@&&@@@
@@@@@@@@@@@@@@@@@&&&&&@@@@@
%@@@@@@@@@@@@@@(@@&%&@&&&@@@
@@@@@@@@@@@@@@@@@@@@@&&&@@@@.
@@@@@@@@@@@@@@@@@@@&@@@@@@@@@
,##(@@@@@@@@@@@@@@@@@@@@@@@@@@#
@@@@@@@@@@@@@@@@@@@@@@&@@@@@@@@(
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
,%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&%%#
&@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@(
/(#*
*/
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./MultisigOwnable.sol";
import "./ERC721A.sol";
import "./extensions/ERC721ABurnable.sol";
import "./extensions/ERC721AQueryable.sol";
contract LikeABrush is MultisigOwnable, ERC721A, ERC721ABurnable, ERC721AQueryable, PaymentSplitter {
using Strings for uint;
uint public WLSaleDate = 1663675200;
uint public ALSaleDate = 1663696800;
uint public SaleDate = 1663700400;
uint public EndSaleDate = 1663711200;
string public baseURI;
string public unrevealedURI;
uint private constant METADATAS_LENGTH = 3333;
uint private constant MAX_TEAM = 333;
uint private constant MAX_SUPPLY_AL = 3200;
uint private constant MAX_MINT_PER_WI_ACCOUNT = 5;
uint private constant MAX_MINT_PER_WL_ACCOUNT = 2;
uint private constant MAX_MINT_PER_AL_ACCOUNT = 1;
uint private amountOfWLDoubleOwner = 0;
uint private constant MAX_WL_DOUBLE_OWNER = 500;
uint private amountNFTonTM;
mapping(address => uint) private amountNFTsperWLWallet;
mapping(address => uint) private amountNFTsperALWallet;
mapping(address => uint) private amountNFTsperFMWallet;
mapping(address => uint) private amountNFTsperWIWallet;
uint public presalePrice = 0.23 ether;
uint public salePrice = 0.28 ether;
uint public maxSupply = METADATAS_LENGTH;
bytes32 public WLRoot;
bytes32 public OGRoot;
bytes32 public ALRoot;
bytes32 public WIRoot;
bytes32 public TMRoot;
bytes32 public FreeRoot;
bytes32 public IronRoot;
bytes32 public BronzeRoot;
bytes32 public SilverRoot;
bytes32 public GoldRoot;
bytes32 public PlatinumRoot;
uint private teamLength;
constructor(
address[] memory _team,
uint[] memory _teamShares,
string memory _unrevealedURI,
string memory _baseURI)
ERC721A("Like a Brush by Julien Durix", "LIKEABRUSH")
PaymentSplitter(_team, _teamShares) {
}
modifier callerIsUser() {
}
function whitelistMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
require(block.timestamp > WLSaleDate - 1, "Whitelist sale is not activated");
require(block.timestamp < ALSaleDate, "Whitelist sale is not activated");
require(<FILL_ME>)
require(amountOfWLDoubleOwner < MAX_WL_DOUBLE_OWNER || _quantity < 2, "No more double whitelist mint possible");
require(amountNFTsperWLWallet[msg.sender] + _quantity < MAX_MINT_PER_WL_ACCOUNT + 1, "You can only get a maximum of 2 on the Whitelist Sale");
require(totalSupply() + _quantity < maxSupply + 1, "Max supply exceeded");
require(msg.value == _quantity * presalePrice, "Wrong payment");
amountNFTsperWLWallet[msg.sender] += _quantity;
amountOfWLDoubleOwner += (amountNFTsperWLWallet[msg.sender] - 1);
_mint(msg.sender, _quantity);
}
function ogMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function winterMint(address _to, uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function allowlistMint(bytes32[] calldata _proof) external payable callerIsUser {
}
function publicMint(uint _quantity) external payable callerIsUser {
}
function winterPublicMint(address _to, uint _quantity) external payable {
}
function teamMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintIron(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintBronze(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintSilver(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintGold(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintPlatinum(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function setUris(string memory newBaseURI, string memory newUnrevealedURI) external onlyRealOwner {
}
function setRoots(bytes32 _WLRoot, bytes32 _OGRoot, bytes32 _ALRoot, bytes32 _WIRoot, bytes32 _TMRoot, bytes32 _FreeRoot, bytes32 _IronRoot, bytes32 _BronzeRoot, bytes32 _SilverRoot, bytes32 _GoldRoot, bytes32 _PlatinumRoot) external onlyOwner {
}
function setDates(uint _WLSaleDate, uint _ALSaleDate, uint _SaleDate, uint _EndSaleDate) external onlyOwner {
}
function setMaxSupply(uint _maxSupply) external onlyOwner {
}
function isAuthorized(address _account, bytes32[] calldata _proof, bytes32 _root) internal pure returns (bool) {
}
function leaf(address _account) internal pure returns (bytes32) {
}
function _verify(bytes32 _leaf, bytes32[] memory _proof, bytes32 _root) internal pure returns (bool) {
}
uint public lastTokenRevealed = 0;
uint256 public randomness = 0;
function setRandomness(uint256 _randomness) external onlyOwner {
}
function getShuffledTokenId(uint id) view internal returns (uint) {
}
function batchReveal(uint256 batchSize) external onlyOwner {
}
function tokenURI(uint256 id) public view override returns (string memory) {
}
function releaseAll() external onlyRealOwner {
}
receive() override external payable {
}
}
| isAuthorized(msg.sender,_proof,WLRoot),"Not whitelisted" | 264,904 | isAuthorized(msg.sender,_proof,WLRoot) |
"You can only get a maximum of 2 on the Whitelist Sale" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/*
@
@@@@@@
@@@@@@@@
@@@@@@@@
@@@@@@@@
@@@@@@@@@@@,
@@@@@@@@@@@@@@@@@@
* @@@@@@@@@@@@@@@@@@@@@@@@#
/@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@,&@@@@@@@@@@@@@@@@@@@@@@@@@&
,@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@%@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@#@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@&@@
/@@@@@@@@@@@@@@@@@@@@@@@@@@@@&
/@@@@&@@@@@@@@@@@@@%@##*%@@@@
@&@@@@@@@@@@@@@@&%@@@@@@@@@@
@@@@@@@&@@&&@@@@@#@@@% @@@@
@@&@@@@@@@@@@&&@&&&@@@@@@#@@
@@@@@&@@@@@@@@@@@@@@@@@@@%@@
@@@@@@@@@@&@@@@@@@@@@@@@@%@@
@&@@@&@@@@@@@@@@@@@@@@@&@&@@
@&@@@@@@@@@@@@@@@@@@@@&&&%@@
%%@@ @@@@%@@@@@@@%@@&%&%%%@@
@@@@@@@&@@&//@@@@@@ &@&%@@@
@@@@&@@@@@@@@@@@@@@&&%&%&@@
&@@%@@@@(@@@@@@&&&&&&&%%@@@
@@@@@@@@@@&/@@@&@&&&@@&&@@@
@@@@@@@@@@@@@@@@@&&&&&@@@@@
%@@@@@@@@@@@@@@(@@&%&@&&&@@@
@@@@@@@@@@@@@@@@@@@@@&&&@@@@.
@@@@@@@@@@@@@@@@@@@&@@@@@@@@@
,##(@@@@@@@@@@@@@@@@@@@@@@@@@@#
@@@@@@@@@@@@@@@@@@@@@@&@@@@@@@@(
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
,%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&%%#
&@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@(
/(#*
*/
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./MultisigOwnable.sol";
import "./ERC721A.sol";
import "./extensions/ERC721ABurnable.sol";
import "./extensions/ERC721AQueryable.sol";
contract LikeABrush is MultisigOwnable, ERC721A, ERC721ABurnable, ERC721AQueryable, PaymentSplitter {
using Strings for uint;
uint public WLSaleDate = 1663675200;
uint public ALSaleDate = 1663696800;
uint public SaleDate = 1663700400;
uint public EndSaleDate = 1663711200;
string public baseURI;
string public unrevealedURI;
uint private constant METADATAS_LENGTH = 3333;
uint private constant MAX_TEAM = 333;
uint private constant MAX_SUPPLY_AL = 3200;
uint private constant MAX_MINT_PER_WI_ACCOUNT = 5;
uint private constant MAX_MINT_PER_WL_ACCOUNT = 2;
uint private constant MAX_MINT_PER_AL_ACCOUNT = 1;
uint private amountOfWLDoubleOwner = 0;
uint private constant MAX_WL_DOUBLE_OWNER = 500;
uint private amountNFTonTM;
mapping(address => uint) private amountNFTsperWLWallet;
mapping(address => uint) private amountNFTsperALWallet;
mapping(address => uint) private amountNFTsperFMWallet;
mapping(address => uint) private amountNFTsperWIWallet;
uint public presalePrice = 0.23 ether;
uint public salePrice = 0.28 ether;
uint public maxSupply = METADATAS_LENGTH;
bytes32 public WLRoot;
bytes32 public OGRoot;
bytes32 public ALRoot;
bytes32 public WIRoot;
bytes32 public TMRoot;
bytes32 public FreeRoot;
bytes32 public IronRoot;
bytes32 public BronzeRoot;
bytes32 public SilverRoot;
bytes32 public GoldRoot;
bytes32 public PlatinumRoot;
uint private teamLength;
constructor(
address[] memory _team,
uint[] memory _teamShares,
string memory _unrevealedURI,
string memory _baseURI)
ERC721A("Like a Brush by Julien Durix", "LIKEABRUSH")
PaymentSplitter(_team, _teamShares) {
}
modifier callerIsUser() {
}
function whitelistMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
require(block.timestamp > WLSaleDate - 1, "Whitelist sale is not activated");
require(block.timestamp < ALSaleDate, "Whitelist sale is not activated");
require(isAuthorized(msg.sender, _proof, WLRoot), "Not whitelisted");
require(amountOfWLDoubleOwner < MAX_WL_DOUBLE_OWNER || _quantity < 2, "No more double whitelist mint possible");
require(<FILL_ME>)
require(totalSupply() + _quantity < maxSupply + 1, "Max supply exceeded");
require(msg.value == _quantity * presalePrice, "Wrong payment");
amountNFTsperWLWallet[msg.sender] += _quantity;
amountOfWLDoubleOwner += (amountNFTsperWLWallet[msg.sender] - 1);
_mint(msg.sender, _quantity);
}
function ogMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function winterMint(address _to, uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function allowlistMint(bytes32[] calldata _proof) external payable callerIsUser {
}
function publicMint(uint _quantity) external payable callerIsUser {
}
function winterPublicMint(address _to, uint _quantity) external payable {
}
function teamMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintIron(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintBronze(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintSilver(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintGold(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintPlatinum(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function setUris(string memory newBaseURI, string memory newUnrevealedURI) external onlyRealOwner {
}
function setRoots(bytes32 _WLRoot, bytes32 _OGRoot, bytes32 _ALRoot, bytes32 _WIRoot, bytes32 _TMRoot, bytes32 _FreeRoot, bytes32 _IronRoot, bytes32 _BronzeRoot, bytes32 _SilverRoot, bytes32 _GoldRoot, bytes32 _PlatinumRoot) external onlyOwner {
}
function setDates(uint _WLSaleDate, uint _ALSaleDate, uint _SaleDate, uint _EndSaleDate) external onlyOwner {
}
function setMaxSupply(uint _maxSupply) external onlyOwner {
}
function isAuthorized(address _account, bytes32[] calldata _proof, bytes32 _root) internal pure returns (bool) {
}
function leaf(address _account) internal pure returns (bytes32) {
}
function _verify(bytes32 _leaf, bytes32[] memory _proof, bytes32 _root) internal pure returns (bool) {
}
uint public lastTokenRevealed = 0;
uint256 public randomness = 0;
function setRandomness(uint256 _randomness) external onlyOwner {
}
function getShuffledTokenId(uint id) view internal returns (uint) {
}
function batchReveal(uint256 batchSize) external onlyOwner {
}
function tokenURI(uint256 id) public view override returns (string memory) {
}
function releaseAll() external onlyRealOwner {
}
receive() override external payable {
}
}
| amountNFTsperWLWallet[msg.sender]+_quantity<MAX_MINT_PER_WL_ACCOUNT+1,"You can only get a maximum of 2 on the Whitelist Sale" | 264,904 | amountNFTsperWLWallet[msg.sender]+_quantity<MAX_MINT_PER_WL_ACCOUNT+1 |
"Not whitelisted" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/*
@
@@@@@@
@@@@@@@@
@@@@@@@@
@@@@@@@@
@@@@@@@@@@@,
@@@@@@@@@@@@@@@@@@
* @@@@@@@@@@@@@@@@@@@@@@@@#
/@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@,&@@@@@@@@@@@@@@@@@@@@@@@@@&
,@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@%@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@#@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@&@@
/@@@@@@@@@@@@@@@@@@@@@@@@@@@@&
/@@@@&@@@@@@@@@@@@@%@##*%@@@@
@&@@@@@@@@@@@@@@&%@@@@@@@@@@
@@@@@@@&@@&&@@@@@#@@@% @@@@
@@&@@@@@@@@@@&&@&&&@@@@@@#@@
@@@@@&@@@@@@@@@@@@@@@@@@@%@@
@@@@@@@@@@&@@@@@@@@@@@@@@%@@
@&@@@&@@@@@@@@@@@@@@@@@&@&@@
@&@@@@@@@@@@@@@@@@@@@@&&&%@@
%%@@ @@@@%@@@@@@@%@@&%&%%%@@
@@@@@@@&@@&//@@@@@@ &@&%@@@
@@@@&@@@@@@@@@@@@@@&&%&%&@@
&@@%@@@@(@@@@@@&&&&&&&%%@@@
@@@@@@@@@@&/@@@&@&&&@@&&@@@
@@@@@@@@@@@@@@@@@&&&&&@@@@@
%@@@@@@@@@@@@@@(@@&%&@&&&@@@
@@@@@@@@@@@@@@@@@@@@@&&&@@@@.
@@@@@@@@@@@@@@@@@@@&@@@@@@@@@
,##(@@@@@@@@@@@@@@@@@@@@@@@@@@#
@@@@@@@@@@@@@@@@@@@@@@&@@@@@@@@(
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
,%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&%%#
&@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@(
/(#*
*/
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./MultisigOwnable.sol";
import "./ERC721A.sol";
import "./extensions/ERC721ABurnable.sol";
import "./extensions/ERC721AQueryable.sol";
contract LikeABrush is MultisigOwnable, ERC721A, ERC721ABurnable, ERC721AQueryable, PaymentSplitter {
using Strings for uint;
uint public WLSaleDate = 1663675200;
uint public ALSaleDate = 1663696800;
uint public SaleDate = 1663700400;
uint public EndSaleDate = 1663711200;
string public baseURI;
string public unrevealedURI;
uint private constant METADATAS_LENGTH = 3333;
uint private constant MAX_TEAM = 333;
uint private constant MAX_SUPPLY_AL = 3200;
uint private constant MAX_MINT_PER_WI_ACCOUNT = 5;
uint private constant MAX_MINT_PER_WL_ACCOUNT = 2;
uint private constant MAX_MINT_PER_AL_ACCOUNT = 1;
uint private amountOfWLDoubleOwner = 0;
uint private constant MAX_WL_DOUBLE_OWNER = 500;
uint private amountNFTonTM;
mapping(address => uint) private amountNFTsperWLWallet;
mapping(address => uint) private amountNFTsperALWallet;
mapping(address => uint) private amountNFTsperFMWallet;
mapping(address => uint) private amountNFTsperWIWallet;
uint public presalePrice = 0.23 ether;
uint public salePrice = 0.28 ether;
uint public maxSupply = METADATAS_LENGTH;
bytes32 public WLRoot;
bytes32 public OGRoot;
bytes32 public ALRoot;
bytes32 public WIRoot;
bytes32 public TMRoot;
bytes32 public FreeRoot;
bytes32 public IronRoot;
bytes32 public BronzeRoot;
bytes32 public SilverRoot;
bytes32 public GoldRoot;
bytes32 public PlatinumRoot;
uint private teamLength;
constructor(
address[] memory _team,
uint[] memory _teamShares,
string memory _unrevealedURI,
string memory _baseURI)
ERC721A("Like a Brush by Julien Durix", "LIKEABRUSH")
PaymentSplitter(_team, _teamShares) {
}
modifier callerIsUser() {
}
function whitelistMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function ogMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
require(block.timestamp > WLSaleDate - 1, "OG sale is not activated");
require(block.timestamp < ALSaleDate, "OG sale is not activated");
require(<FILL_ME>)
require(amountNFTsperWLWallet[msg.sender] + _quantity < MAX_MINT_PER_WL_ACCOUNT + 1, "You can only get a maximum of 2 on the OG Sale");
require(totalSupply() + _quantity < maxSupply + 1, "Max supply exceeded");
require(msg.value == _quantity * presalePrice, "Wrong payment");
amountNFTsperWLWallet[msg.sender] += _quantity;
_mint(msg.sender, _quantity);
}
function winterMint(address _to, uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function allowlistMint(bytes32[] calldata _proof) external payable callerIsUser {
}
function publicMint(uint _quantity) external payable callerIsUser {
}
function winterPublicMint(address _to, uint _quantity) external payable {
}
function teamMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintIron(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintBronze(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintSilver(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintGold(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintPlatinum(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function setUris(string memory newBaseURI, string memory newUnrevealedURI) external onlyRealOwner {
}
function setRoots(bytes32 _WLRoot, bytes32 _OGRoot, bytes32 _ALRoot, bytes32 _WIRoot, bytes32 _TMRoot, bytes32 _FreeRoot, bytes32 _IronRoot, bytes32 _BronzeRoot, bytes32 _SilverRoot, bytes32 _GoldRoot, bytes32 _PlatinumRoot) external onlyOwner {
}
function setDates(uint _WLSaleDate, uint _ALSaleDate, uint _SaleDate, uint _EndSaleDate) external onlyOwner {
}
function setMaxSupply(uint _maxSupply) external onlyOwner {
}
function isAuthorized(address _account, bytes32[] calldata _proof, bytes32 _root) internal pure returns (bool) {
}
function leaf(address _account) internal pure returns (bytes32) {
}
function _verify(bytes32 _leaf, bytes32[] memory _proof, bytes32 _root) internal pure returns (bool) {
}
uint public lastTokenRevealed = 0;
uint256 public randomness = 0;
function setRandomness(uint256 _randomness) external onlyOwner {
}
function getShuffledTokenId(uint id) view internal returns (uint) {
}
function batchReveal(uint256 batchSize) external onlyOwner {
}
function tokenURI(uint256 id) public view override returns (string memory) {
}
function releaseAll() external onlyRealOwner {
}
receive() override external payable {
}
}
| isAuthorized(msg.sender,_proof,OGRoot),"Not whitelisted" | 264,904 | isAuthorized(msg.sender,_proof,OGRoot) |
"Not whitelisted" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/*
@
@@@@@@
@@@@@@@@
@@@@@@@@
@@@@@@@@
@@@@@@@@@@@,
@@@@@@@@@@@@@@@@@@
* @@@@@@@@@@@@@@@@@@@@@@@@#
/@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@,&@@@@@@@@@@@@@@@@@@@@@@@@@&
,@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@%@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@#@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@&@@
/@@@@@@@@@@@@@@@@@@@@@@@@@@@@&
/@@@@&@@@@@@@@@@@@@%@##*%@@@@
@&@@@@@@@@@@@@@@&%@@@@@@@@@@
@@@@@@@&@@&&@@@@@#@@@% @@@@
@@&@@@@@@@@@@&&@&&&@@@@@@#@@
@@@@@&@@@@@@@@@@@@@@@@@@@%@@
@@@@@@@@@@&@@@@@@@@@@@@@@%@@
@&@@@&@@@@@@@@@@@@@@@@@&@&@@
@&@@@@@@@@@@@@@@@@@@@@&&&%@@
%%@@ @@@@%@@@@@@@%@@&%&%%%@@
@@@@@@@&@@&//@@@@@@ &@&%@@@
@@@@&@@@@@@@@@@@@@@&&%&%&@@
&@@%@@@@(@@@@@@&&&&&&&%%@@@
@@@@@@@@@@&/@@@&@&&&@@&&@@@
@@@@@@@@@@@@@@@@@&&&&&@@@@@
%@@@@@@@@@@@@@@(@@&%&@&&&@@@
@@@@@@@@@@@@@@@@@@@@@&&&@@@@.
@@@@@@@@@@@@@@@@@@@&@@@@@@@@@
,##(@@@@@@@@@@@@@@@@@@@@@@@@@@#
@@@@@@@@@@@@@@@@@@@@@@&@@@@@@@@(
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
,%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&%%#
&@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@(
/(#*
*/
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./MultisigOwnable.sol";
import "./ERC721A.sol";
import "./extensions/ERC721ABurnable.sol";
import "./extensions/ERC721AQueryable.sol";
contract LikeABrush is MultisigOwnable, ERC721A, ERC721ABurnable, ERC721AQueryable, PaymentSplitter {
using Strings for uint;
uint public WLSaleDate = 1663675200;
uint public ALSaleDate = 1663696800;
uint public SaleDate = 1663700400;
uint public EndSaleDate = 1663711200;
string public baseURI;
string public unrevealedURI;
uint private constant METADATAS_LENGTH = 3333;
uint private constant MAX_TEAM = 333;
uint private constant MAX_SUPPLY_AL = 3200;
uint private constant MAX_MINT_PER_WI_ACCOUNT = 5;
uint private constant MAX_MINT_PER_WL_ACCOUNT = 2;
uint private constant MAX_MINT_PER_AL_ACCOUNT = 1;
uint private amountOfWLDoubleOwner = 0;
uint private constant MAX_WL_DOUBLE_OWNER = 500;
uint private amountNFTonTM;
mapping(address => uint) private amountNFTsperWLWallet;
mapping(address => uint) private amountNFTsperALWallet;
mapping(address => uint) private amountNFTsperFMWallet;
mapping(address => uint) private amountNFTsperWIWallet;
uint public presalePrice = 0.23 ether;
uint public salePrice = 0.28 ether;
uint public maxSupply = METADATAS_LENGTH;
bytes32 public WLRoot;
bytes32 public OGRoot;
bytes32 public ALRoot;
bytes32 public WIRoot;
bytes32 public TMRoot;
bytes32 public FreeRoot;
bytes32 public IronRoot;
bytes32 public BronzeRoot;
bytes32 public SilverRoot;
bytes32 public GoldRoot;
bytes32 public PlatinumRoot;
uint private teamLength;
constructor(
address[] memory _team,
uint[] memory _teamShares,
string memory _unrevealedURI,
string memory _baseURI)
ERC721A("Like a Brush by Julien Durix", "LIKEABRUSH")
PaymentSplitter(_team, _teamShares) {
}
modifier callerIsUser() {
}
function whitelistMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function ogMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function winterMint(address _to, uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
require(block.timestamp > WLSaleDate - 1, "Whitelist sale is not activated");
require(block.timestamp < ALSaleDate, "Whitelist sale is not activated");
require(<FILL_ME>)
require(amountNFTsperWIWallet[msg.sender] + _quantity < MAX_MINT_PER_WI_ACCOUNT + 1, "You can only get a maximum of 5 on the Whitelist Winter Sale");
require(totalSupply() + _quantity < maxSupply + 1, "Max supply exceeded");
require(msg.value == _quantity * presalePrice, "Wrong payment");
_mint(_to, _quantity);
}
function allowlistMint(bytes32[] calldata _proof) external payable callerIsUser {
}
function publicMint(uint _quantity) external payable callerIsUser {
}
function winterPublicMint(address _to, uint _quantity) external payable {
}
function teamMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintIron(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintBronze(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintSilver(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintGold(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintPlatinum(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function setUris(string memory newBaseURI, string memory newUnrevealedURI) external onlyRealOwner {
}
function setRoots(bytes32 _WLRoot, bytes32 _OGRoot, bytes32 _ALRoot, bytes32 _WIRoot, bytes32 _TMRoot, bytes32 _FreeRoot, bytes32 _IronRoot, bytes32 _BronzeRoot, bytes32 _SilverRoot, bytes32 _GoldRoot, bytes32 _PlatinumRoot) external onlyOwner {
}
function setDates(uint _WLSaleDate, uint _ALSaleDate, uint _SaleDate, uint _EndSaleDate) external onlyOwner {
}
function setMaxSupply(uint _maxSupply) external onlyOwner {
}
function isAuthorized(address _account, bytes32[] calldata _proof, bytes32 _root) internal pure returns (bool) {
}
function leaf(address _account) internal pure returns (bytes32) {
}
function _verify(bytes32 _leaf, bytes32[] memory _proof, bytes32 _root) internal pure returns (bool) {
}
uint public lastTokenRevealed = 0;
uint256 public randomness = 0;
function setRandomness(uint256 _randomness) external onlyOwner {
}
function getShuffledTokenId(uint id) view internal returns (uint) {
}
function batchReveal(uint256 batchSize) external onlyOwner {
}
function tokenURI(uint256 id) public view override returns (string memory) {
}
function releaseAll() external onlyRealOwner {
}
receive() override external payable {
}
}
| isAuthorized(_to,_proof,WIRoot),"Not whitelisted" | 264,904 | isAuthorized(_to,_proof,WIRoot) |
"You can only get a maximum of 5 on the Whitelist Winter Sale" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/*
@
@@@@@@
@@@@@@@@
@@@@@@@@
@@@@@@@@
@@@@@@@@@@@,
@@@@@@@@@@@@@@@@@@
* @@@@@@@@@@@@@@@@@@@@@@@@#
/@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@,&@@@@@@@@@@@@@@@@@@@@@@@@@&
,@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@%@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@#@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@&@@
/@@@@@@@@@@@@@@@@@@@@@@@@@@@@&
/@@@@&@@@@@@@@@@@@@%@##*%@@@@
@&@@@@@@@@@@@@@@&%@@@@@@@@@@
@@@@@@@&@@&&@@@@@#@@@% @@@@
@@&@@@@@@@@@@&&@&&&@@@@@@#@@
@@@@@&@@@@@@@@@@@@@@@@@@@%@@
@@@@@@@@@@&@@@@@@@@@@@@@@%@@
@&@@@&@@@@@@@@@@@@@@@@@&@&@@
@&@@@@@@@@@@@@@@@@@@@@&&&%@@
%%@@ @@@@%@@@@@@@%@@&%&%%%@@
@@@@@@@&@@&//@@@@@@ &@&%@@@
@@@@&@@@@@@@@@@@@@@&&%&%&@@
&@@%@@@@(@@@@@@&&&&&&&%%@@@
@@@@@@@@@@&/@@@&@&&&@@&&@@@
@@@@@@@@@@@@@@@@@&&&&&@@@@@
%@@@@@@@@@@@@@@(@@&%&@&&&@@@
@@@@@@@@@@@@@@@@@@@@@&&&@@@@.
@@@@@@@@@@@@@@@@@@@&@@@@@@@@@
,##(@@@@@@@@@@@@@@@@@@@@@@@@@@#
@@@@@@@@@@@@@@@@@@@@@@&@@@@@@@@(
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
,%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&%%#
&@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@(
/(#*
*/
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./MultisigOwnable.sol";
import "./ERC721A.sol";
import "./extensions/ERC721ABurnable.sol";
import "./extensions/ERC721AQueryable.sol";
contract LikeABrush is MultisigOwnable, ERC721A, ERC721ABurnable, ERC721AQueryable, PaymentSplitter {
using Strings for uint;
uint public WLSaleDate = 1663675200;
uint public ALSaleDate = 1663696800;
uint public SaleDate = 1663700400;
uint public EndSaleDate = 1663711200;
string public baseURI;
string public unrevealedURI;
uint private constant METADATAS_LENGTH = 3333;
uint private constant MAX_TEAM = 333;
uint private constant MAX_SUPPLY_AL = 3200;
uint private constant MAX_MINT_PER_WI_ACCOUNT = 5;
uint private constant MAX_MINT_PER_WL_ACCOUNT = 2;
uint private constant MAX_MINT_PER_AL_ACCOUNT = 1;
uint private amountOfWLDoubleOwner = 0;
uint private constant MAX_WL_DOUBLE_OWNER = 500;
uint private amountNFTonTM;
mapping(address => uint) private amountNFTsperWLWallet;
mapping(address => uint) private amountNFTsperALWallet;
mapping(address => uint) private amountNFTsperFMWallet;
mapping(address => uint) private amountNFTsperWIWallet;
uint public presalePrice = 0.23 ether;
uint public salePrice = 0.28 ether;
uint public maxSupply = METADATAS_LENGTH;
bytes32 public WLRoot;
bytes32 public OGRoot;
bytes32 public ALRoot;
bytes32 public WIRoot;
bytes32 public TMRoot;
bytes32 public FreeRoot;
bytes32 public IronRoot;
bytes32 public BronzeRoot;
bytes32 public SilverRoot;
bytes32 public GoldRoot;
bytes32 public PlatinumRoot;
uint private teamLength;
constructor(
address[] memory _team,
uint[] memory _teamShares,
string memory _unrevealedURI,
string memory _baseURI)
ERC721A("Like a Brush by Julien Durix", "LIKEABRUSH")
PaymentSplitter(_team, _teamShares) {
}
modifier callerIsUser() {
}
function whitelistMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function ogMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function winterMint(address _to, uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
require(block.timestamp > WLSaleDate - 1, "Whitelist sale is not activated");
require(block.timestamp < ALSaleDate, "Whitelist sale is not activated");
require(isAuthorized(_to, _proof, WIRoot), "Not whitelisted");
require(<FILL_ME>)
require(totalSupply() + _quantity < maxSupply + 1, "Max supply exceeded");
require(msg.value == _quantity * presalePrice, "Wrong payment");
_mint(_to, _quantity);
}
function allowlistMint(bytes32[] calldata _proof) external payable callerIsUser {
}
function publicMint(uint _quantity) external payable callerIsUser {
}
function winterPublicMint(address _to, uint _quantity) external payable {
}
function teamMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintIron(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintBronze(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintSilver(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintGold(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintPlatinum(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function setUris(string memory newBaseURI, string memory newUnrevealedURI) external onlyRealOwner {
}
function setRoots(bytes32 _WLRoot, bytes32 _OGRoot, bytes32 _ALRoot, bytes32 _WIRoot, bytes32 _TMRoot, bytes32 _FreeRoot, bytes32 _IronRoot, bytes32 _BronzeRoot, bytes32 _SilverRoot, bytes32 _GoldRoot, bytes32 _PlatinumRoot) external onlyOwner {
}
function setDates(uint _WLSaleDate, uint _ALSaleDate, uint _SaleDate, uint _EndSaleDate) external onlyOwner {
}
function setMaxSupply(uint _maxSupply) external onlyOwner {
}
function isAuthorized(address _account, bytes32[] calldata _proof, bytes32 _root) internal pure returns (bool) {
}
function leaf(address _account) internal pure returns (bytes32) {
}
function _verify(bytes32 _leaf, bytes32[] memory _proof, bytes32 _root) internal pure returns (bool) {
}
uint public lastTokenRevealed = 0;
uint256 public randomness = 0;
function setRandomness(uint256 _randomness) external onlyOwner {
}
function getShuffledTokenId(uint id) view internal returns (uint) {
}
function batchReveal(uint256 batchSize) external onlyOwner {
}
function tokenURI(uint256 id) public view override returns (string memory) {
}
function releaseAll() external onlyRealOwner {
}
receive() override external payable {
}
}
| amountNFTsperWIWallet[msg.sender]+_quantity<MAX_MINT_PER_WI_ACCOUNT+1,"You can only get a maximum of 5 on the Whitelist Winter Sale" | 264,904 | amountNFTsperWIWallet[msg.sender]+_quantity<MAX_MINT_PER_WI_ACCOUNT+1 |
"Not whitelisted" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/*
@
@@@@@@
@@@@@@@@
@@@@@@@@
@@@@@@@@
@@@@@@@@@@@,
@@@@@@@@@@@@@@@@@@
* @@@@@@@@@@@@@@@@@@@@@@@@#
/@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@,&@@@@@@@@@@@@@@@@@@@@@@@@@&
,@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@%@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@#@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@&@@
/@@@@@@@@@@@@@@@@@@@@@@@@@@@@&
/@@@@&@@@@@@@@@@@@@%@##*%@@@@
@&@@@@@@@@@@@@@@&%@@@@@@@@@@
@@@@@@@&@@&&@@@@@#@@@% @@@@
@@&@@@@@@@@@@&&@&&&@@@@@@#@@
@@@@@&@@@@@@@@@@@@@@@@@@@%@@
@@@@@@@@@@&@@@@@@@@@@@@@@%@@
@&@@@&@@@@@@@@@@@@@@@@@&@&@@
@&@@@@@@@@@@@@@@@@@@@@&&&%@@
%%@@ @@@@%@@@@@@@%@@&%&%%%@@
@@@@@@@&@@&//@@@@@@ &@&%@@@
@@@@&@@@@@@@@@@@@@@&&%&%&@@
&@@%@@@@(@@@@@@&&&&&&&%%@@@
@@@@@@@@@@&/@@@&@&&&@@&&@@@
@@@@@@@@@@@@@@@@@&&&&&@@@@@
%@@@@@@@@@@@@@@(@@&%&@&&&@@@
@@@@@@@@@@@@@@@@@@@@@&&&@@@@.
@@@@@@@@@@@@@@@@@@@&@@@@@@@@@
,##(@@@@@@@@@@@@@@@@@@@@@@@@@@#
@@@@@@@@@@@@@@@@@@@@@@&@@@@@@@@(
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
,%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&%%#
&@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@(
/(#*
*/
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./MultisigOwnable.sol";
import "./ERC721A.sol";
import "./extensions/ERC721ABurnable.sol";
import "./extensions/ERC721AQueryable.sol";
contract LikeABrush is MultisigOwnable, ERC721A, ERC721ABurnable, ERC721AQueryable, PaymentSplitter {
using Strings for uint;
uint public WLSaleDate = 1663675200;
uint public ALSaleDate = 1663696800;
uint public SaleDate = 1663700400;
uint public EndSaleDate = 1663711200;
string public baseURI;
string public unrevealedURI;
uint private constant METADATAS_LENGTH = 3333;
uint private constant MAX_TEAM = 333;
uint private constant MAX_SUPPLY_AL = 3200;
uint private constant MAX_MINT_PER_WI_ACCOUNT = 5;
uint private constant MAX_MINT_PER_WL_ACCOUNT = 2;
uint private constant MAX_MINT_PER_AL_ACCOUNT = 1;
uint private amountOfWLDoubleOwner = 0;
uint private constant MAX_WL_DOUBLE_OWNER = 500;
uint private amountNFTonTM;
mapping(address => uint) private amountNFTsperWLWallet;
mapping(address => uint) private amountNFTsperALWallet;
mapping(address => uint) private amountNFTsperFMWallet;
mapping(address => uint) private amountNFTsperWIWallet;
uint public presalePrice = 0.23 ether;
uint public salePrice = 0.28 ether;
uint public maxSupply = METADATAS_LENGTH;
bytes32 public WLRoot;
bytes32 public OGRoot;
bytes32 public ALRoot;
bytes32 public WIRoot;
bytes32 public TMRoot;
bytes32 public FreeRoot;
bytes32 public IronRoot;
bytes32 public BronzeRoot;
bytes32 public SilverRoot;
bytes32 public GoldRoot;
bytes32 public PlatinumRoot;
uint private teamLength;
constructor(
address[] memory _team,
uint[] memory _teamShares,
string memory _unrevealedURI,
string memory _baseURI)
ERC721A("Like a Brush by Julien Durix", "LIKEABRUSH")
PaymentSplitter(_team, _teamShares) {
}
modifier callerIsUser() {
}
function whitelistMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function ogMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function winterMint(address _to, uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function allowlistMint(bytes32[] calldata _proof) external payable callerIsUser {
require(block.timestamp > ALSaleDate - 1, "AL sale is not activated");
require(block.timestamp < SaleDate, "AL sale is not activated");
require(<FILL_ME>)
require(amountNFTsperALWallet[msg.sender] + 1 < MAX_MINT_PER_AL_ACCOUNT + 1, "You can only get a maximum of 1 on the AL Sale");
require(totalSupply() + 1 < MAX_SUPPLY_AL + 1, "Max supply for AL exceeded");
require(msg.value == presalePrice, "Wrong payment");
amountNFTsperALWallet[msg.sender] += 1;
_mint(msg.sender, 1);
}
function publicMint(uint _quantity) external payable callerIsUser {
}
function winterPublicMint(address _to, uint _quantity) external payable {
}
function teamMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintIron(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintBronze(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintSilver(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintGold(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintPlatinum(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function setUris(string memory newBaseURI, string memory newUnrevealedURI) external onlyRealOwner {
}
function setRoots(bytes32 _WLRoot, bytes32 _OGRoot, bytes32 _ALRoot, bytes32 _WIRoot, bytes32 _TMRoot, bytes32 _FreeRoot, bytes32 _IronRoot, bytes32 _BronzeRoot, bytes32 _SilverRoot, bytes32 _GoldRoot, bytes32 _PlatinumRoot) external onlyOwner {
}
function setDates(uint _WLSaleDate, uint _ALSaleDate, uint _SaleDate, uint _EndSaleDate) external onlyOwner {
}
function setMaxSupply(uint _maxSupply) external onlyOwner {
}
function isAuthorized(address _account, bytes32[] calldata _proof, bytes32 _root) internal pure returns (bool) {
}
function leaf(address _account) internal pure returns (bytes32) {
}
function _verify(bytes32 _leaf, bytes32[] memory _proof, bytes32 _root) internal pure returns (bool) {
}
uint public lastTokenRevealed = 0;
uint256 public randomness = 0;
function setRandomness(uint256 _randomness) external onlyOwner {
}
function getShuffledTokenId(uint id) view internal returns (uint) {
}
function batchReveal(uint256 batchSize) external onlyOwner {
}
function tokenURI(uint256 id) public view override returns (string memory) {
}
function releaseAll() external onlyRealOwner {
}
receive() override external payable {
}
}
| isAuthorized(msg.sender,_proof,ALRoot),"Not whitelisted" | 264,904 | isAuthorized(msg.sender,_proof,ALRoot) |
"You can only get a maximum of 1 on the AL Sale" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/*
@
@@@@@@
@@@@@@@@
@@@@@@@@
@@@@@@@@
@@@@@@@@@@@,
@@@@@@@@@@@@@@@@@@
* @@@@@@@@@@@@@@@@@@@@@@@@#
/@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@,&@@@@@@@@@@@@@@@@@@@@@@@@@&
,@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@%@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@#@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@&@@
/@@@@@@@@@@@@@@@@@@@@@@@@@@@@&
/@@@@&@@@@@@@@@@@@@%@##*%@@@@
@&@@@@@@@@@@@@@@&%@@@@@@@@@@
@@@@@@@&@@&&@@@@@#@@@% @@@@
@@&@@@@@@@@@@&&@&&&@@@@@@#@@
@@@@@&@@@@@@@@@@@@@@@@@@@%@@
@@@@@@@@@@&@@@@@@@@@@@@@@%@@
@&@@@&@@@@@@@@@@@@@@@@@&@&@@
@&@@@@@@@@@@@@@@@@@@@@&&&%@@
%%@@ @@@@%@@@@@@@%@@&%&%%%@@
@@@@@@@&@@&//@@@@@@ &@&%@@@
@@@@&@@@@@@@@@@@@@@&&%&%&@@
&@@%@@@@(@@@@@@&&&&&&&%%@@@
@@@@@@@@@@&/@@@&@&&&@@&&@@@
@@@@@@@@@@@@@@@@@&&&&&@@@@@
%@@@@@@@@@@@@@@(@@&%&@&&&@@@
@@@@@@@@@@@@@@@@@@@@@&&&@@@@.
@@@@@@@@@@@@@@@@@@@&@@@@@@@@@
,##(@@@@@@@@@@@@@@@@@@@@@@@@@@#
@@@@@@@@@@@@@@@@@@@@@@&@@@@@@@@(
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
,%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&%%#
&@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@(
/(#*
*/
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./MultisigOwnable.sol";
import "./ERC721A.sol";
import "./extensions/ERC721ABurnable.sol";
import "./extensions/ERC721AQueryable.sol";
contract LikeABrush is MultisigOwnable, ERC721A, ERC721ABurnable, ERC721AQueryable, PaymentSplitter {
using Strings for uint;
uint public WLSaleDate = 1663675200;
uint public ALSaleDate = 1663696800;
uint public SaleDate = 1663700400;
uint public EndSaleDate = 1663711200;
string public baseURI;
string public unrevealedURI;
uint private constant METADATAS_LENGTH = 3333;
uint private constant MAX_TEAM = 333;
uint private constant MAX_SUPPLY_AL = 3200;
uint private constant MAX_MINT_PER_WI_ACCOUNT = 5;
uint private constant MAX_MINT_PER_WL_ACCOUNT = 2;
uint private constant MAX_MINT_PER_AL_ACCOUNT = 1;
uint private amountOfWLDoubleOwner = 0;
uint private constant MAX_WL_DOUBLE_OWNER = 500;
uint private amountNFTonTM;
mapping(address => uint) private amountNFTsperWLWallet;
mapping(address => uint) private amountNFTsperALWallet;
mapping(address => uint) private amountNFTsperFMWallet;
mapping(address => uint) private amountNFTsperWIWallet;
uint public presalePrice = 0.23 ether;
uint public salePrice = 0.28 ether;
uint public maxSupply = METADATAS_LENGTH;
bytes32 public WLRoot;
bytes32 public OGRoot;
bytes32 public ALRoot;
bytes32 public WIRoot;
bytes32 public TMRoot;
bytes32 public FreeRoot;
bytes32 public IronRoot;
bytes32 public BronzeRoot;
bytes32 public SilverRoot;
bytes32 public GoldRoot;
bytes32 public PlatinumRoot;
uint private teamLength;
constructor(
address[] memory _team,
uint[] memory _teamShares,
string memory _unrevealedURI,
string memory _baseURI)
ERC721A("Like a Brush by Julien Durix", "LIKEABRUSH")
PaymentSplitter(_team, _teamShares) {
}
modifier callerIsUser() {
}
function whitelistMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function ogMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function winterMint(address _to, uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function allowlistMint(bytes32[] calldata _proof) external payable callerIsUser {
require(block.timestamp > ALSaleDate - 1, "AL sale is not activated");
require(block.timestamp < SaleDate, "AL sale is not activated");
require(isAuthorized(msg.sender, _proof, ALRoot), "Not whitelisted");
require(<FILL_ME>)
require(totalSupply() + 1 < MAX_SUPPLY_AL + 1, "Max supply for AL exceeded");
require(msg.value == presalePrice, "Wrong payment");
amountNFTsperALWallet[msg.sender] += 1;
_mint(msg.sender, 1);
}
function publicMint(uint _quantity) external payable callerIsUser {
}
function winterPublicMint(address _to, uint _quantity) external payable {
}
function teamMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintIron(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintBronze(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintSilver(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintGold(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintPlatinum(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function setUris(string memory newBaseURI, string memory newUnrevealedURI) external onlyRealOwner {
}
function setRoots(bytes32 _WLRoot, bytes32 _OGRoot, bytes32 _ALRoot, bytes32 _WIRoot, bytes32 _TMRoot, bytes32 _FreeRoot, bytes32 _IronRoot, bytes32 _BronzeRoot, bytes32 _SilverRoot, bytes32 _GoldRoot, bytes32 _PlatinumRoot) external onlyOwner {
}
function setDates(uint _WLSaleDate, uint _ALSaleDate, uint _SaleDate, uint _EndSaleDate) external onlyOwner {
}
function setMaxSupply(uint _maxSupply) external onlyOwner {
}
function isAuthorized(address _account, bytes32[] calldata _proof, bytes32 _root) internal pure returns (bool) {
}
function leaf(address _account) internal pure returns (bytes32) {
}
function _verify(bytes32 _leaf, bytes32[] memory _proof, bytes32 _root) internal pure returns (bool) {
}
uint public lastTokenRevealed = 0;
uint256 public randomness = 0;
function setRandomness(uint256 _randomness) external onlyOwner {
}
function getShuffledTokenId(uint id) view internal returns (uint) {
}
function batchReveal(uint256 batchSize) external onlyOwner {
}
function tokenURI(uint256 id) public view override returns (string memory) {
}
function releaseAll() external onlyRealOwner {
}
receive() override external payable {
}
}
| amountNFTsperALWallet[msg.sender]+1<MAX_MINT_PER_AL_ACCOUNT+1,"You can only get a maximum of 1 on the AL Sale" | 264,904 | amountNFTsperALWallet[msg.sender]+1<MAX_MINT_PER_AL_ACCOUNT+1 |
"Max supply for AL exceeded" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/*
@
@@@@@@
@@@@@@@@
@@@@@@@@
@@@@@@@@
@@@@@@@@@@@,
@@@@@@@@@@@@@@@@@@
* @@@@@@@@@@@@@@@@@@@@@@@@#
/@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@,&@@@@@@@@@@@@@@@@@@@@@@@@@&
,@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@%@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@#@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@&@@
/@@@@@@@@@@@@@@@@@@@@@@@@@@@@&
/@@@@&@@@@@@@@@@@@@%@##*%@@@@
@&@@@@@@@@@@@@@@&%@@@@@@@@@@
@@@@@@@&@@&&@@@@@#@@@% @@@@
@@&@@@@@@@@@@&&@&&&@@@@@@#@@
@@@@@&@@@@@@@@@@@@@@@@@@@%@@
@@@@@@@@@@&@@@@@@@@@@@@@@%@@
@&@@@&@@@@@@@@@@@@@@@@@&@&@@
@&@@@@@@@@@@@@@@@@@@@@&&&%@@
%%@@ @@@@%@@@@@@@%@@&%&%%%@@
@@@@@@@&@@&//@@@@@@ &@&%@@@
@@@@&@@@@@@@@@@@@@@&&%&%&@@
&@@%@@@@(@@@@@@&&&&&&&%%@@@
@@@@@@@@@@&/@@@&@&&&@@&&@@@
@@@@@@@@@@@@@@@@@&&&&&@@@@@
%@@@@@@@@@@@@@@(@@&%&@&&&@@@
@@@@@@@@@@@@@@@@@@@@@&&&@@@@.
@@@@@@@@@@@@@@@@@@@&@@@@@@@@@
,##(@@@@@@@@@@@@@@@@@@@@@@@@@@#
@@@@@@@@@@@@@@@@@@@@@@&@@@@@@@@(
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
,%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&%%#
&@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@(
/(#*
*/
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./MultisigOwnable.sol";
import "./ERC721A.sol";
import "./extensions/ERC721ABurnable.sol";
import "./extensions/ERC721AQueryable.sol";
contract LikeABrush is MultisigOwnable, ERC721A, ERC721ABurnable, ERC721AQueryable, PaymentSplitter {
using Strings for uint;
uint public WLSaleDate = 1663675200;
uint public ALSaleDate = 1663696800;
uint public SaleDate = 1663700400;
uint public EndSaleDate = 1663711200;
string public baseURI;
string public unrevealedURI;
uint private constant METADATAS_LENGTH = 3333;
uint private constant MAX_TEAM = 333;
uint private constant MAX_SUPPLY_AL = 3200;
uint private constant MAX_MINT_PER_WI_ACCOUNT = 5;
uint private constant MAX_MINT_PER_WL_ACCOUNT = 2;
uint private constant MAX_MINT_PER_AL_ACCOUNT = 1;
uint private amountOfWLDoubleOwner = 0;
uint private constant MAX_WL_DOUBLE_OWNER = 500;
uint private amountNFTonTM;
mapping(address => uint) private amountNFTsperWLWallet;
mapping(address => uint) private amountNFTsperALWallet;
mapping(address => uint) private amountNFTsperFMWallet;
mapping(address => uint) private amountNFTsperWIWallet;
uint public presalePrice = 0.23 ether;
uint public salePrice = 0.28 ether;
uint public maxSupply = METADATAS_LENGTH;
bytes32 public WLRoot;
bytes32 public OGRoot;
bytes32 public ALRoot;
bytes32 public WIRoot;
bytes32 public TMRoot;
bytes32 public FreeRoot;
bytes32 public IronRoot;
bytes32 public BronzeRoot;
bytes32 public SilverRoot;
bytes32 public GoldRoot;
bytes32 public PlatinumRoot;
uint private teamLength;
constructor(
address[] memory _team,
uint[] memory _teamShares,
string memory _unrevealedURI,
string memory _baseURI)
ERC721A("Like a Brush by Julien Durix", "LIKEABRUSH")
PaymentSplitter(_team, _teamShares) {
}
modifier callerIsUser() {
}
function whitelistMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function ogMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function winterMint(address _to, uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function allowlistMint(bytes32[] calldata _proof) external payable callerIsUser {
require(block.timestamp > ALSaleDate - 1, "AL sale is not activated");
require(block.timestamp < SaleDate, "AL sale is not activated");
require(isAuthorized(msg.sender, _proof, ALRoot), "Not whitelisted");
require(amountNFTsperALWallet[msg.sender] + 1 < MAX_MINT_PER_AL_ACCOUNT + 1, "You can only get a maximum of 1 on the AL Sale");
require(<FILL_ME>)
require(msg.value == presalePrice, "Wrong payment");
amountNFTsperALWallet[msg.sender] += 1;
_mint(msg.sender, 1);
}
function publicMint(uint _quantity) external payable callerIsUser {
}
function winterPublicMint(address _to, uint _quantity) external payable {
}
function teamMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintIron(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintBronze(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintSilver(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintGold(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintPlatinum(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function setUris(string memory newBaseURI, string memory newUnrevealedURI) external onlyRealOwner {
}
function setRoots(bytes32 _WLRoot, bytes32 _OGRoot, bytes32 _ALRoot, bytes32 _WIRoot, bytes32 _TMRoot, bytes32 _FreeRoot, bytes32 _IronRoot, bytes32 _BronzeRoot, bytes32 _SilverRoot, bytes32 _GoldRoot, bytes32 _PlatinumRoot) external onlyOwner {
}
function setDates(uint _WLSaleDate, uint _ALSaleDate, uint _SaleDate, uint _EndSaleDate) external onlyOwner {
}
function setMaxSupply(uint _maxSupply) external onlyOwner {
}
function isAuthorized(address _account, bytes32[] calldata _proof, bytes32 _root) internal pure returns (bool) {
}
function leaf(address _account) internal pure returns (bytes32) {
}
function _verify(bytes32 _leaf, bytes32[] memory _proof, bytes32 _root) internal pure returns (bool) {
}
uint public lastTokenRevealed = 0;
uint256 public randomness = 0;
function setRandomness(uint256 _randomness) external onlyOwner {
}
function getShuffledTokenId(uint id) view internal returns (uint) {
}
function batchReveal(uint256 batchSize) external onlyOwner {
}
function tokenURI(uint256 id) public view override returns (string memory) {
}
function releaseAll() external onlyRealOwner {
}
receive() override external payable {
}
}
| totalSupply()+1<MAX_SUPPLY_AL+1,"Max supply for AL exceeded" | 264,904 | totalSupply()+1<MAX_SUPPLY_AL+1 |
"Not allowed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/*
@
@@@@@@
@@@@@@@@
@@@@@@@@
@@@@@@@@
@@@@@@@@@@@,
@@@@@@@@@@@@@@@@@@
* @@@@@@@@@@@@@@@@@@@@@@@@#
/@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@,&@@@@@@@@@@@@@@@@@@@@@@@@@&
,@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@%@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@#@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@&@@
/@@@@@@@@@@@@@@@@@@@@@@@@@@@@&
/@@@@&@@@@@@@@@@@@@%@##*%@@@@
@&@@@@@@@@@@@@@@&%@@@@@@@@@@
@@@@@@@&@@&&@@@@@#@@@% @@@@
@@&@@@@@@@@@@&&@&&&@@@@@@#@@
@@@@@&@@@@@@@@@@@@@@@@@@@%@@
@@@@@@@@@@&@@@@@@@@@@@@@@%@@
@&@@@&@@@@@@@@@@@@@@@@@&@&@@
@&@@@@@@@@@@@@@@@@@@@@&&&%@@
%%@@ @@@@%@@@@@@@%@@&%&%%%@@
@@@@@@@&@@&//@@@@@@ &@&%@@@
@@@@&@@@@@@@@@@@@@@&&%&%&@@
&@@%@@@@(@@@@@@&&&&&&&%%@@@
@@@@@@@@@@&/@@@&@&&&@@&&@@@
@@@@@@@@@@@@@@@@@&&&&&@@@@@
%@@@@@@@@@@@@@@(@@&%&@&&&@@@
@@@@@@@@@@@@@@@@@@@@@&&&@@@@.
@@@@@@@@@@@@@@@@@@@&@@@@@@@@@
,##(@@@@@@@@@@@@@@@@@@@@@@@@@@#
@@@@@@@@@@@@@@@@@@@@@@&@@@@@@@@(
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
,%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&%%#
&@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@(
/(#*
*/
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./MultisigOwnable.sol";
import "./ERC721A.sol";
import "./extensions/ERC721ABurnable.sol";
import "./extensions/ERC721AQueryable.sol";
contract LikeABrush is MultisigOwnable, ERC721A, ERC721ABurnable, ERC721AQueryable, PaymentSplitter {
using Strings for uint;
uint public WLSaleDate = 1663675200;
uint public ALSaleDate = 1663696800;
uint public SaleDate = 1663700400;
uint public EndSaleDate = 1663711200;
string public baseURI;
string public unrevealedURI;
uint private constant METADATAS_LENGTH = 3333;
uint private constant MAX_TEAM = 333;
uint private constant MAX_SUPPLY_AL = 3200;
uint private constant MAX_MINT_PER_WI_ACCOUNT = 5;
uint private constant MAX_MINT_PER_WL_ACCOUNT = 2;
uint private constant MAX_MINT_PER_AL_ACCOUNT = 1;
uint private amountOfWLDoubleOwner = 0;
uint private constant MAX_WL_DOUBLE_OWNER = 500;
uint private amountNFTonTM;
mapping(address => uint) private amountNFTsperWLWallet;
mapping(address => uint) private amountNFTsperALWallet;
mapping(address => uint) private amountNFTsperFMWallet;
mapping(address => uint) private amountNFTsperWIWallet;
uint public presalePrice = 0.23 ether;
uint public salePrice = 0.28 ether;
uint public maxSupply = METADATAS_LENGTH;
bytes32 public WLRoot;
bytes32 public OGRoot;
bytes32 public ALRoot;
bytes32 public WIRoot;
bytes32 public TMRoot;
bytes32 public FreeRoot;
bytes32 public IronRoot;
bytes32 public BronzeRoot;
bytes32 public SilverRoot;
bytes32 public GoldRoot;
bytes32 public PlatinumRoot;
uint private teamLength;
constructor(
address[] memory _team,
uint[] memory _teamShares,
string memory _unrevealedURI,
string memory _baseURI)
ERC721A("Like a Brush by Julien Durix", "LIKEABRUSH")
PaymentSplitter(_team, _teamShares) {
}
modifier callerIsUser() {
}
function whitelistMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function ogMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function winterMint(address _to, uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function allowlistMint(bytes32[] calldata _proof) external payable callerIsUser {
}
function publicMint(uint _quantity) external payable callerIsUser {
}
function winterPublicMint(address _to, uint _quantity) external payable {
}
function teamMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
require(block.timestamp < ALSaleDate, "Team mint is no longer activated");
require(<FILL_ME>)
require(amountNFTonTM + _quantity <= MAX_TEAM, "Max supply exceeded");
require(msg.value == 0, "Wrong payment");
amountNFTonTM += _quantity;
_mint(msg.sender, _quantity);
}
function freeMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintIron(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintBronze(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintSilver(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintGold(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintPlatinum(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function setUris(string memory newBaseURI, string memory newUnrevealedURI) external onlyRealOwner {
}
function setRoots(bytes32 _WLRoot, bytes32 _OGRoot, bytes32 _ALRoot, bytes32 _WIRoot, bytes32 _TMRoot, bytes32 _FreeRoot, bytes32 _IronRoot, bytes32 _BronzeRoot, bytes32 _SilverRoot, bytes32 _GoldRoot, bytes32 _PlatinumRoot) external onlyOwner {
}
function setDates(uint _WLSaleDate, uint _ALSaleDate, uint _SaleDate, uint _EndSaleDate) external onlyOwner {
}
function setMaxSupply(uint _maxSupply) external onlyOwner {
}
function isAuthorized(address _account, bytes32[] calldata _proof, bytes32 _root) internal pure returns (bool) {
}
function leaf(address _account) internal pure returns (bytes32) {
}
function _verify(bytes32 _leaf, bytes32[] memory _proof, bytes32 _root) internal pure returns (bool) {
}
uint public lastTokenRevealed = 0;
uint256 public randomness = 0;
function setRandomness(uint256 _randomness) external onlyOwner {
}
function getShuffledTokenId(uint id) view internal returns (uint) {
}
function batchReveal(uint256 batchSize) external onlyOwner {
}
function tokenURI(uint256 id) public view override returns (string memory) {
}
function releaseAll() external onlyRealOwner {
}
receive() override external payable {
}
}
| isAuthorized(msg.sender,_proof,TMRoot),"Not allowed" | 264,904 | isAuthorized(msg.sender,_proof,TMRoot) |
"Max supply exceeded" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/*
@
@@@@@@
@@@@@@@@
@@@@@@@@
@@@@@@@@
@@@@@@@@@@@,
@@@@@@@@@@@@@@@@@@
* @@@@@@@@@@@@@@@@@@@@@@@@#
/@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@,&@@@@@@@@@@@@@@@@@@@@@@@@@&
,@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@%@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@#@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@&@@
/@@@@@@@@@@@@@@@@@@@@@@@@@@@@&
/@@@@&@@@@@@@@@@@@@%@##*%@@@@
@&@@@@@@@@@@@@@@&%@@@@@@@@@@
@@@@@@@&@@&&@@@@@#@@@% @@@@
@@&@@@@@@@@@@&&@&&&@@@@@@#@@
@@@@@&@@@@@@@@@@@@@@@@@@@%@@
@@@@@@@@@@&@@@@@@@@@@@@@@%@@
@&@@@&@@@@@@@@@@@@@@@@@&@&@@
@&@@@@@@@@@@@@@@@@@@@@&&&%@@
%%@@ @@@@%@@@@@@@%@@&%&%%%@@
@@@@@@@&@@&//@@@@@@ &@&%@@@
@@@@&@@@@@@@@@@@@@@&&%&%&@@
&@@%@@@@(@@@@@@&&&&&&&%%@@@
@@@@@@@@@@&/@@@&@&&&@@&&@@@
@@@@@@@@@@@@@@@@@&&&&&@@@@@
%@@@@@@@@@@@@@@(@@&%&@&&&@@@
@@@@@@@@@@@@@@@@@@@@@&&&@@@@.
@@@@@@@@@@@@@@@@@@@&@@@@@@@@@
,##(@@@@@@@@@@@@@@@@@@@@@@@@@@#
@@@@@@@@@@@@@@@@@@@@@@&@@@@@@@@(
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
,%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&%%#
&@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@(
/(#*
*/
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./MultisigOwnable.sol";
import "./ERC721A.sol";
import "./extensions/ERC721ABurnable.sol";
import "./extensions/ERC721AQueryable.sol";
contract LikeABrush is MultisigOwnable, ERC721A, ERC721ABurnable, ERC721AQueryable, PaymentSplitter {
using Strings for uint;
uint public WLSaleDate = 1663675200;
uint public ALSaleDate = 1663696800;
uint public SaleDate = 1663700400;
uint public EndSaleDate = 1663711200;
string public baseURI;
string public unrevealedURI;
uint private constant METADATAS_LENGTH = 3333;
uint private constant MAX_TEAM = 333;
uint private constant MAX_SUPPLY_AL = 3200;
uint private constant MAX_MINT_PER_WI_ACCOUNT = 5;
uint private constant MAX_MINT_PER_WL_ACCOUNT = 2;
uint private constant MAX_MINT_PER_AL_ACCOUNT = 1;
uint private amountOfWLDoubleOwner = 0;
uint private constant MAX_WL_DOUBLE_OWNER = 500;
uint private amountNFTonTM;
mapping(address => uint) private amountNFTsperWLWallet;
mapping(address => uint) private amountNFTsperALWallet;
mapping(address => uint) private amountNFTsperFMWallet;
mapping(address => uint) private amountNFTsperWIWallet;
uint public presalePrice = 0.23 ether;
uint public salePrice = 0.28 ether;
uint public maxSupply = METADATAS_LENGTH;
bytes32 public WLRoot;
bytes32 public OGRoot;
bytes32 public ALRoot;
bytes32 public WIRoot;
bytes32 public TMRoot;
bytes32 public FreeRoot;
bytes32 public IronRoot;
bytes32 public BronzeRoot;
bytes32 public SilverRoot;
bytes32 public GoldRoot;
bytes32 public PlatinumRoot;
uint private teamLength;
constructor(
address[] memory _team,
uint[] memory _teamShares,
string memory _unrevealedURI,
string memory _baseURI)
ERC721A("Like a Brush by Julien Durix", "LIKEABRUSH")
PaymentSplitter(_team, _teamShares) {
}
modifier callerIsUser() {
}
function whitelistMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function ogMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function winterMint(address _to, uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function allowlistMint(bytes32[] calldata _proof) external payable callerIsUser {
}
function publicMint(uint _quantity) external payable callerIsUser {
}
function winterPublicMint(address _to, uint _quantity) external payable {
}
function teamMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
require(block.timestamp < ALSaleDate, "Team mint is no longer activated");
require(isAuthorized(msg.sender, _proof, TMRoot), "Not allowed");
require(<FILL_ME>)
require(msg.value == 0, "Wrong payment");
amountNFTonTM += _quantity;
_mint(msg.sender, _quantity);
}
function freeMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintIron(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintBronze(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintSilver(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintGold(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintPlatinum(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function setUris(string memory newBaseURI, string memory newUnrevealedURI) external onlyRealOwner {
}
function setRoots(bytes32 _WLRoot, bytes32 _OGRoot, bytes32 _ALRoot, bytes32 _WIRoot, bytes32 _TMRoot, bytes32 _FreeRoot, bytes32 _IronRoot, bytes32 _BronzeRoot, bytes32 _SilverRoot, bytes32 _GoldRoot, bytes32 _PlatinumRoot) external onlyOwner {
}
function setDates(uint _WLSaleDate, uint _ALSaleDate, uint _SaleDate, uint _EndSaleDate) external onlyOwner {
}
function setMaxSupply(uint _maxSupply) external onlyOwner {
}
function isAuthorized(address _account, bytes32[] calldata _proof, bytes32 _root) internal pure returns (bool) {
}
function leaf(address _account) internal pure returns (bytes32) {
}
function _verify(bytes32 _leaf, bytes32[] memory _proof, bytes32 _root) internal pure returns (bool) {
}
uint public lastTokenRevealed = 0;
uint256 public randomness = 0;
function setRandomness(uint256 _randomness) external onlyOwner {
}
function getShuffledTokenId(uint id) view internal returns (uint) {
}
function batchReveal(uint256 batchSize) external onlyOwner {
}
function tokenURI(uint256 id) public view override returns (string memory) {
}
function releaseAll() external onlyRealOwner {
}
receive() override external payable {
}
}
| amountNFTonTM+_quantity<=MAX_TEAM,"Max supply exceeded" | 264,904 | amountNFTonTM+_quantity<=MAX_TEAM |
"Not allowed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/*
@
@@@@@@
@@@@@@@@
@@@@@@@@
@@@@@@@@
@@@@@@@@@@@,
@@@@@@@@@@@@@@@@@@
* @@@@@@@@@@@@@@@@@@@@@@@@#
/@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@,&@@@@@@@@@@@@@@@@@@@@@@@@@&
,@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@%@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@#@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@&@@
/@@@@@@@@@@@@@@@@@@@@@@@@@@@@&
/@@@@&@@@@@@@@@@@@@%@##*%@@@@
@&@@@@@@@@@@@@@@&%@@@@@@@@@@
@@@@@@@&@@&&@@@@@#@@@% @@@@
@@&@@@@@@@@@@&&@&&&@@@@@@#@@
@@@@@&@@@@@@@@@@@@@@@@@@@%@@
@@@@@@@@@@&@@@@@@@@@@@@@@%@@
@&@@@&@@@@@@@@@@@@@@@@@&@&@@
@&@@@@@@@@@@@@@@@@@@@@&&&%@@
%%@@ @@@@%@@@@@@@%@@&%&%%%@@
@@@@@@@&@@&//@@@@@@ &@&%@@@
@@@@&@@@@@@@@@@@@@@&&%&%&@@
&@@%@@@@(@@@@@@&&&&&&&%%@@@
@@@@@@@@@@&/@@@&@&&&@@&&@@@
@@@@@@@@@@@@@@@@@&&&&&@@@@@
%@@@@@@@@@@@@@@(@@&%&@&&&@@@
@@@@@@@@@@@@@@@@@@@@@&&&@@@@.
@@@@@@@@@@@@@@@@@@@&@@@@@@@@@
,##(@@@@@@@@@@@@@@@@@@@@@@@@@@#
@@@@@@@@@@@@@@@@@@@@@@&@@@@@@@@(
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
,%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&%%#
&@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@(
/(#*
*/
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./MultisigOwnable.sol";
import "./ERC721A.sol";
import "./extensions/ERC721ABurnable.sol";
import "./extensions/ERC721AQueryable.sol";
contract LikeABrush is MultisigOwnable, ERC721A, ERC721ABurnable, ERC721AQueryable, PaymentSplitter {
using Strings for uint;
uint public WLSaleDate = 1663675200;
uint public ALSaleDate = 1663696800;
uint public SaleDate = 1663700400;
uint public EndSaleDate = 1663711200;
string public baseURI;
string public unrevealedURI;
uint private constant METADATAS_LENGTH = 3333;
uint private constant MAX_TEAM = 333;
uint private constant MAX_SUPPLY_AL = 3200;
uint private constant MAX_MINT_PER_WI_ACCOUNT = 5;
uint private constant MAX_MINT_PER_WL_ACCOUNT = 2;
uint private constant MAX_MINT_PER_AL_ACCOUNT = 1;
uint private amountOfWLDoubleOwner = 0;
uint private constant MAX_WL_DOUBLE_OWNER = 500;
uint private amountNFTonTM;
mapping(address => uint) private amountNFTsperWLWallet;
mapping(address => uint) private amountNFTsperALWallet;
mapping(address => uint) private amountNFTsperFMWallet;
mapping(address => uint) private amountNFTsperWIWallet;
uint public presalePrice = 0.23 ether;
uint public salePrice = 0.28 ether;
uint public maxSupply = METADATAS_LENGTH;
bytes32 public WLRoot;
bytes32 public OGRoot;
bytes32 public ALRoot;
bytes32 public WIRoot;
bytes32 public TMRoot;
bytes32 public FreeRoot;
bytes32 public IronRoot;
bytes32 public BronzeRoot;
bytes32 public SilverRoot;
bytes32 public GoldRoot;
bytes32 public PlatinumRoot;
uint private teamLength;
constructor(
address[] memory _team,
uint[] memory _teamShares,
string memory _unrevealedURI,
string memory _baseURI)
ERC721A("Like a Brush by Julien Durix", "LIKEABRUSH")
PaymentSplitter(_team, _teamShares) {
}
modifier callerIsUser() {
}
function whitelistMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function ogMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function winterMint(address _to, uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function allowlistMint(bytes32[] calldata _proof) external payable callerIsUser {
}
function publicMint(uint _quantity) external payable callerIsUser {
}
function winterPublicMint(address _to, uint _quantity) external payable {
}
function teamMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
require(block.timestamp > WLSaleDate - 1, "Free mint is not activated");
require(block.timestamp < ALSaleDate, "Free mint is no longer activated");
require(<FILL_ME>)
require(amountNFTsperFMWallet[msg.sender] + _quantity < 2, "You can only get 1 free NFT");
require(msg.value == 0, "Wrong payment");
amountNFTsperFMWallet[msg.sender] += _quantity;
_mint(msg.sender, _quantity);
}
function freeMintIron(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintBronze(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintSilver(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintGold(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintPlatinum(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function setUris(string memory newBaseURI, string memory newUnrevealedURI) external onlyRealOwner {
}
function setRoots(bytes32 _WLRoot, bytes32 _OGRoot, bytes32 _ALRoot, bytes32 _WIRoot, bytes32 _TMRoot, bytes32 _FreeRoot, bytes32 _IronRoot, bytes32 _BronzeRoot, bytes32 _SilverRoot, bytes32 _GoldRoot, bytes32 _PlatinumRoot) external onlyOwner {
}
function setDates(uint _WLSaleDate, uint _ALSaleDate, uint _SaleDate, uint _EndSaleDate) external onlyOwner {
}
function setMaxSupply(uint _maxSupply) external onlyOwner {
}
function isAuthorized(address _account, bytes32[] calldata _proof, bytes32 _root) internal pure returns (bool) {
}
function leaf(address _account) internal pure returns (bytes32) {
}
function _verify(bytes32 _leaf, bytes32[] memory _proof, bytes32 _root) internal pure returns (bool) {
}
uint public lastTokenRevealed = 0;
uint256 public randomness = 0;
function setRandomness(uint256 _randomness) external onlyOwner {
}
function getShuffledTokenId(uint id) view internal returns (uint) {
}
function batchReveal(uint256 batchSize) external onlyOwner {
}
function tokenURI(uint256 id) public view override returns (string memory) {
}
function releaseAll() external onlyRealOwner {
}
receive() override external payable {
}
}
| isAuthorized(msg.sender,_proof,FreeRoot),"Not allowed" | 264,904 | isAuthorized(msg.sender,_proof,FreeRoot) |
"You can only get 1 free NFT" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/*
@
@@@@@@
@@@@@@@@
@@@@@@@@
@@@@@@@@
@@@@@@@@@@@,
@@@@@@@@@@@@@@@@@@
* @@@@@@@@@@@@@@@@@@@@@@@@#
/@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@,&@@@@@@@@@@@@@@@@@@@@@@@@@&
,@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@%@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@#@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@&@@
/@@@@@@@@@@@@@@@@@@@@@@@@@@@@&
/@@@@&@@@@@@@@@@@@@%@##*%@@@@
@&@@@@@@@@@@@@@@&%@@@@@@@@@@
@@@@@@@&@@&&@@@@@#@@@% @@@@
@@&@@@@@@@@@@&&@&&&@@@@@@#@@
@@@@@&@@@@@@@@@@@@@@@@@@@%@@
@@@@@@@@@@&@@@@@@@@@@@@@@%@@
@&@@@&@@@@@@@@@@@@@@@@@&@&@@
@&@@@@@@@@@@@@@@@@@@@@&&&%@@
%%@@ @@@@%@@@@@@@%@@&%&%%%@@
@@@@@@@&@@&//@@@@@@ &@&%@@@
@@@@&@@@@@@@@@@@@@@&&%&%&@@
&@@%@@@@(@@@@@@&&&&&&&%%@@@
@@@@@@@@@@&/@@@&@&&&@@&&@@@
@@@@@@@@@@@@@@@@@&&&&&@@@@@
%@@@@@@@@@@@@@@(@@&%&@&&&@@@
@@@@@@@@@@@@@@@@@@@@@&&&@@@@.
@@@@@@@@@@@@@@@@@@@&@@@@@@@@@
,##(@@@@@@@@@@@@@@@@@@@@@@@@@@#
@@@@@@@@@@@@@@@@@@@@@@&@@@@@@@@(
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
,%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&%%#
&@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@(
/(#*
*/
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./MultisigOwnable.sol";
import "./ERC721A.sol";
import "./extensions/ERC721ABurnable.sol";
import "./extensions/ERC721AQueryable.sol";
contract LikeABrush is MultisigOwnable, ERC721A, ERC721ABurnable, ERC721AQueryable, PaymentSplitter {
using Strings for uint;
uint public WLSaleDate = 1663675200;
uint public ALSaleDate = 1663696800;
uint public SaleDate = 1663700400;
uint public EndSaleDate = 1663711200;
string public baseURI;
string public unrevealedURI;
uint private constant METADATAS_LENGTH = 3333;
uint private constant MAX_TEAM = 333;
uint private constant MAX_SUPPLY_AL = 3200;
uint private constant MAX_MINT_PER_WI_ACCOUNT = 5;
uint private constant MAX_MINT_PER_WL_ACCOUNT = 2;
uint private constant MAX_MINT_PER_AL_ACCOUNT = 1;
uint private amountOfWLDoubleOwner = 0;
uint private constant MAX_WL_DOUBLE_OWNER = 500;
uint private amountNFTonTM;
mapping(address => uint) private amountNFTsperWLWallet;
mapping(address => uint) private amountNFTsperALWallet;
mapping(address => uint) private amountNFTsperFMWallet;
mapping(address => uint) private amountNFTsperWIWallet;
uint public presalePrice = 0.23 ether;
uint public salePrice = 0.28 ether;
uint public maxSupply = METADATAS_LENGTH;
bytes32 public WLRoot;
bytes32 public OGRoot;
bytes32 public ALRoot;
bytes32 public WIRoot;
bytes32 public TMRoot;
bytes32 public FreeRoot;
bytes32 public IronRoot;
bytes32 public BronzeRoot;
bytes32 public SilverRoot;
bytes32 public GoldRoot;
bytes32 public PlatinumRoot;
uint private teamLength;
constructor(
address[] memory _team,
uint[] memory _teamShares,
string memory _unrevealedURI,
string memory _baseURI)
ERC721A("Like a Brush by Julien Durix", "LIKEABRUSH")
PaymentSplitter(_team, _teamShares) {
}
modifier callerIsUser() {
}
function whitelistMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function ogMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function winterMint(address _to, uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function allowlistMint(bytes32[] calldata _proof) external payable callerIsUser {
}
function publicMint(uint _quantity) external payable callerIsUser {
}
function winterPublicMint(address _to, uint _quantity) external payable {
}
function teamMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
require(block.timestamp > WLSaleDate - 1, "Free mint is not activated");
require(block.timestamp < ALSaleDate, "Free mint is no longer activated");
require(isAuthorized(msg.sender, _proof, FreeRoot), "Not allowed");
require(<FILL_ME>)
require(msg.value == 0, "Wrong payment");
amountNFTsperFMWallet[msg.sender] += _quantity;
_mint(msg.sender, _quantity);
}
function freeMintIron(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintBronze(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintSilver(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintGold(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintPlatinum(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function setUris(string memory newBaseURI, string memory newUnrevealedURI) external onlyRealOwner {
}
function setRoots(bytes32 _WLRoot, bytes32 _OGRoot, bytes32 _ALRoot, bytes32 _WIRoot, bytes32 _TMRoot, bytes32 _FreeRoot, bytes32 _IronRoot, bytes32 _BronzeRoot, bytes32 _SilverRoot, bytes32 _GoldRoot, bytes32 _PlatinumRoot) external onlyOwner {
}
function setDates(uint _WLSaleDate, uint _ALSaleDate, uint _SaleDate, uint _EndSaleDate) external onlyOwner {
}
function setMaxSupply(uint _maxSupply) external onlyOwner {
}
function isAuthorized(address _account, bytes32[] calldata _proof, bytes32 _root) internal pure returns (bool) {
}
function leaf(address _account) internal pure returns (bytes32) {
}
function _verify(bytes32 _leaf, bytes32[] memory _proof, bytes32 _root) internal pure returns (bool) {
}
uint public lastTokenRevealed = 0;
uint256 public randomness = 0;
function setRandomness(uint256 _randomness) external onlyOwner {
}
function getShuffledTokenId(uint id) view internal returns (uint) {
}
function batchReveal(uint256 batchSize) external onlyOwner {
}
function tokenURI(uint256 id) public view override returns (string memory) {
}
function releaseAll() external onlyRealOwner {
}
receive() override external payable {
}
}
| amountNFTsperFMWallet[msg.sender]+_quantity<2,"You can only get 1 free NFT" | 264,904 | amountNFTsperFMWallet[msg.sender]+_quantity<2 |
"Not allowed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/*
@
@@@@@@
@@@@@@@@
@@@@@@@@
@@@@@@@@
@@@@@@@@@@@,
@@@@@@@@@@@@@@@@@@
* @@@@@@@@@@@@@@@@@@@@@@@@#
/@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@,&@@@@@@@@@@@@@@@@@@@@@@@@@&
,@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@%@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@#@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@&@@
/@@@@@@@@@@@@@@@@@@@@@@@@@@@@&
/@@@@&@@@@@@@@@@@@@%@##*%@@@@
@&@@@@@@@@@@@@@@&%@@@@@@@@@@
@@@@@@@&@@&&@@@@@#@@@% @@@@
@@&@@@@@@@@@@&&@&&&@@@@@@#@@
@@@@@&@@@@@@@@@@@@@@@@@@@%@@
@@@@@@@@@@&@@@@@@@@@@@@@@%@@
@&@@@&@@@@@@@@@@@@@@@@@&@&@@
@&@@@@@@@@@@@@@@@@@@@@&&&%@@
%%@@ @@@@%@@@@@@@%@@&%&%%%@@
@@@@@@@&@@&//@@@@@@ &@&%@@@
@@@@&@@@@@@@@@@@@@@&&%&%&@@
&@@%@@@@(@@@@@@&&&&&&&%%@@@
@@@@@@@@@@&/@@@&@&&&@@&&@@@
@@@@@@@@@@@@@@@@@&&&&&@@@@@
%@@@@@@@@@@@@@@(@@&%&@&&&@@@
@@@@@@@@@@@@@@@@@@@@@&&&@@@@.
@@@@@@@@@@@@@@@@@@@&@@@@@@@@@
,##(@@@@@@@@@@@@@@@@@@@@@@@@@@#
@@@@@@@@@@@@@@@@@@@@@@&@@@@@@@@(
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
,%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&%%#
&@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@(
/(#*
*/
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./MultisigOwnable.sol";
import "./ERC721A.sol";
import "./extensions/ERC721ABurnable.sol";
import "./extensions/ERC721AQueryable.sol";
contract LikeABrush is MultisigOwnable, ERC721A, ERC721ABurnable, ERC721AQueryable, PaymentSplitter {
using Strings for uint;
uint public WLSaleDate = 1663675200;
uint public ALSaleDate = 1663696800;
uint public SaleDate = 1663700400;
uint public EndSaleDate = 1663711200;
string public baseURI;
string public unrevealedURI;
uint private constant METADATAS_LENGTH = 3333;
uint private constant MAX_TEAM = 333;
uint private constant MAX_SUPPLY_AL = 3200;
uint private constant MAX_MINT_PER_WI_ACCOUNT = 5;
uint private constant MAX_MINT_PER_WL_ACCOUNT = 2;
uint private constant MAX_MINT_PER_AL_ACCOUNT = 1;
uint private amountOfWLDoubleOwner = 0;
uint private constant MAX_WL_DOUBLE_OWNER = 500;
uint private amountNFTonTM;
mapping(address => uint) private amountNFTsperWLWallet;
mapping(address => uint) private amountNFTsperALWallet;
mapping(address => uint) private amountNFTsperFMWallet;
mapping(address => uint) private amountNFTsperWIWallet;
uint public presalePrice = 0.23 ether;
uint public salePrice = 0.28 ether;
uint public maxSupply = METADATAS_LENGTH;
bytes32 public WLRoot;
bytes32 public OGRoot;
bytes32 public ALRoot;
bytes32 public WIRoot;
bytes32 public TMRoot;
bytes32 public FreeRoot;
bytes32 public IronRoot;
bytes32 public BronzeRoot;
bytes32 public SilverRoot;
bytes32 public GoldRoot;
bytes32 public PlatinumRoot;
uint private teamLength;
constructor(
address[] memory _team,
uint[] memory _teamShares,
string memory _unrevealedURI,
string memory _baseURI)
ERC721A("Like a Brush by Julien Durix", "LIKEABRUSH")
PaymentSplitter(_team, _teamShares) {
}
modifier callerIsUser() {
}
function whitelistMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function ogMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function winterMint(address _to, uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function allowlistMint(bytes32[] calldata _proof) external payable callerIsUser {
}
function publicMint(uint _quantity) external payable callerIsUser {
}
function winterPublicMint(address _to, uint _quantity) external payable {
}
function teamMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintIron(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
require(block.timestamp > WLSaleDate - 1, "Free mint is not activated");
require(block.timestamp < ALSaleDate, "Free mint is no longer activated");
require(<FILL_ME>)
require(amountNFTsperFMWallet[msg.sender] + _quantity < 3, "You can only get 2 free NFT");
require(msg.value == 0, "Wrong payment");
amountNFTsperFMWallet[msg.sender] += _quantity;
_mint(msg.sender, _quantity);
}
function freeMintBronze(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintSilver(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintGold(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintPlatinum(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function setUris(string memory newBaseURI, string memory newUnrevealedURI) external onlyRealOwner {
}
function setRoots(bytes32 _WLRoot, bytes32 _OGRoot, bytes32 _ALRoot, bytes32 _WIRoot, bytes32 _TMRoot, bytes32 _FreeRoot, bytes32 _IronRoot, bytes32 _BronzeRoot, bytes32 _SilverRoot, bytes32 _GoldRoot, bytes32 _PlatinumRoot) external onlyOwner {
}
function setDates(uint _WLSaleDate, uint _ALSaleDate, uint _SaleDate, uint _EndSaleDate) external onlyOwner {
}
function setMaxSupply(uint _maxSupply) external onlyOwner {
}
function isAuthorized(address _account, bytes32[] calldata _proof, bytes32 _root) internal pure returns (bool) {
}
function leaf(address _account) internal pure returns (bytes32) {
}
function _verify(bytes32 _leaf, bytes32[] memory _proof, bytes32 _root) internal pure returns (bool) {
}
uint public lastTokenRevealed = 0;
uint256 public randomness = 0;
function setRandomness(uint256 _randomness) external onlyOwner {
}
function getShuffledTokenId(uint id) view internal returns (uint) {
}
function batchReveal(uint256 batchSize) external onlyOwner {
}
function tokenURI(uint256 id) public view override returns (string memory) {
}
function releaseAll() external onlyRealOwner {
}
receive() override external payable {
}
}
| isAuthorized(msg.sender,_proof,IronRoot),"Not allowed" | 264,904 | isAuthorized(msg.sender,_proof,IronRoot) |
"You can only get 2 free NFT" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/*
@
@@@@@@
@@@@@@@@
@@@@@@@@
@@@@@@@@
@@@@@@@@@@@,
@@@@@@@@@@@@@@@@@@
* @@@@@@@@@@@@@@@@@@@@@@@@#
/@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@,&@@@@@@@@@@@@@@@@@@@@@@@@@&
,@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@%@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@#@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@&@@
/@@@@@@@@@@@@@@@@@@@@@@@@@@@@&
/@@@@&@@@@@@@@@@@@@%@##*%@@@@
@&@@@@@@@@@@@@@@&%@@@@@@@@@@
@@@@@@@&@@&&@@@@@#@@@% @@@@
@@&@@@@@@@@@@&&@&&&@@@@@@#@@
@@@@@&@@@@@@@@@@@@@@@@@@@%@@
@@@@@@@@@@&@@@@@@@@@@@@@@%@@
@&@@@&@@@@@@@@@@@@@@@@@&@&@@
@&@@@@@@@@@@@@@@@@@@@@&&&%@@
%%@@ @@@@%@@@@@@@%@@&%&%%%@@
@@@@@@@&@@&//@@@@@@ &@&%@@@
@@@@&@@@@@@@@@@@@@@&&%&%&@@
&@@%@@@@(@@@@@@&&&&&&&%%@@@
@@@@@@@@@@&/@@@&@&&&@@&&@@@
@@@@@@@@@@@@@@@@@&&&&&@@@@@
%@@@@@@@@@@@@@@(@@&%&@&&&@@@
@@@@@@@@@@@@@@@@@@@@@&&&@@@@.
@@@@@@@@@@@@@@@@@@@&@@@@@@@@@
,##(@@@@@@@@@@@@@@@@@@@@@@@@@@#
@@@@@@@@@@@@@@@@@@@@@@&@@@@@@@@(
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
,%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&%%#
&@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@(
/(#*
*/
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./MultisigOwnable.sol";
import "./ERC721A.sol";
import "./extensions/ERC721ABurnable.sol";
import "./extensions/ERC721AQueryable.sol";
contract LikeABrush is MultisigOwnable, ERC721A, ERC721ABurnable, ERC721AQueryable, PaymentSplitter {
using Strings for uint;
uint public WLSaleDate = 1663675200;
uint public ALSaleDate = 1663696800;
uint public SaleDate = 1663700400;
uint public EndSaleDate = 1663711200;
string public baseURI;
string public unrevealedURI;
uint private constant METADATAS_LENGTH = 3333;
uint private constant MAX_TEAM = 333;
uint private constant MAX_SUPPLY_AL = 3200;
uint private constant MAX_MINT_PER_WI_ACCOUNT = 5;
uint private constant MAX_MINT_PER_WL_ACCOUNT = 2;
uint private constant MAX_MINT_PER_AL_ACCOUNT = 1;
uint private amountOfWLDoubleOwner = 0;
uint private constant MAX_WL_DOUBLE_OWNER = 500;
uint private amountNFTonTM;
mapping(address => uint) private amountNFTsperWLWallet;
mapping(address => uint) private amountNFTsperALWallet;
mapping(address => uint) private amountNFTsperFMWallet;
mapping(address => uint) private amountNFTsperWIWallet;
uint public presalePrice = 0.23 ether;
uint public salePrice = 0.28 ether;
uint public maxSupply = METADATAS_LENGTH;
bytes32 public WLRoot;
bytes32 public OGRoot;
bytes32 public ALRoot;
bytes32 public WIRoot;
bytes32 public TMRoot;
bytes32 public FreeRoot;
bytes32 public IronRoot;
bytes32 public BronzeRoot;
bytes32 public SilverRoot;
bytes32 public GoldRoot;
bytes32 public PlatinumRoot;
uint private teamLength;
constructor(
address[] memory _team,
uint[] memory _teamShares,
string memory _unrevealedURI,
string memory _baseURI)
ERC721A("Like a Brush by Julien Durix", "LIKEABRUSH")
PaymentSplitter(_team, _teamShares) {
}
modifier callerIsUser() {
}
function whitelistMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function ogMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function winterMint(address _to, uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function allowlistMint(bytes32[] calldata _proof) external payable callerIsUser {
}
function publicMint(uint _quantity) external payable callerIsUser {
}
function winterPublicMint(address _to, uint _quantity) external payable {
}
function teamMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintIron(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
require(block.timestamp > WLSaleDate - 1, "Free mint is not activated");
require(block.timestamp < ALSaleDate, "Free mint is no longer activated");
require(isAuthorized(msg.sender, _proof, IronRoot), "Not allowed");
require(<FILL_ME>)
require(msg.value == 0, "Wrong payment");
amountNFTsperFMWallet[msg.sender] += _quantity;
_mint(msg.sender, _quantity);
}
function freeMintBronze(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintSilver(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintGold(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintPlatinum(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function setUris(string memory newBaseURI, string memory newUnrevealedURI) external onlyRealOwner {
}
function setRoots(bytes32 _WLRoot, bytes32 _OGRoot, bytes32 _ALRoot, bytes32 _WIRoot, bytes32 _TMRoot, bytes32 _FreeRoot, bytes32 _IronRoot, bytes32 _BronzeRoot, bytes32 _SilverRoot, bytes32 _GoldRoot, bytes32 _PlatinumRoot) external onlyOwner {
}
function setDates(uint _WLSaleDate, uint _ALSaleDate, uint _SaleDate, uint _EndSaleDate) external onlyOwner {
}
function setMaxSupply(uint _maxSupply) external onlyOwner {
}
function isAuthorized(address _account, bytes32[] calldata _proof, bytes32 _root) internal pure returns (bool) {
}
function leaf(address _account) internal pure returns (bytes32) {
}
function _verify(bytes32 _leaf, bytes32[] memory _proof, bytes32 _root) internal pure returns (bool) {
}
uint public lastTokenRevealed = 0;
uint256 public randomness = 0;
function setRandomness(uint256 _randomness) external onlyOwner {
}
function getShuffledTokenId(uint id) view internal returns (uint) {
}
function batchReveal(uint256 batchSize) external onlyOwner {
}
function tokenURI(uint256 id) public view override returns (string memory) {
}
function releaseAll() external onlyRealOwner {
}
receive() override external payable {
}
}
| amountNFTsperFMWallet[msg.sender]+_quantity<3,"You can only get 2 free NFT" | 264,904 | amountNFTsperFMWallet[msg.sender]+_quantity<3 |
"Not allowed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/*
@
@@@@@@
@@@@@@@@
@@@@@@@@
@@@@@@@@
@@@@@@@@@@@,
@@@@@@@@@@@@@@@@@@
* @@@@@@@@@@@@@@@@@@@@@@@@#
/@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@,&@@@@@@@@@@@@@@@@@@@@@@@@@&
,@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@%@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@#@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@&@@
/@@@@@@@@@@@@@@@@@@@@@@@@@@@@&
/@@@@&@@@@@@@@@@@@@%@##*%@@@@
@&@@@@@@@@@@@@@@&%@@@@@@@@@@
@@@@@@@&@@&&@@@@@#@@@% @@@@
@@&@@@@@@@@@@&&@&&&@@@@@@#@@
@@@@@&@@@@@@@@@@@@@@@@@@@%@@
@@@@@@@@@@&@@@@@@@@@@@@@@%@@
@&@@@&@@@@@@@@@@@@@@@@@&@&@@
@&@@@@@@@@@@@@@@@@@@@@&&&%@@
%%@@ @@@@%@@@@@@@%@@&%&%%%@@
@@@@@@@&@@&//@@@@@@ &@&%@@@
@@@@&@@@@@@@@@@@@@@&&%&%&@@
&@@%@@@@(@@@@@@&&&&&&&%%@@@
@@@@@@@@@@&/@@@&@&&&@@&&@@@
@@@@@@@@@@@@@@@@@&&&&&@@@@@
%@@@@@@@@@@@@@@(@@&%&@&&&@@@
@@@@@@@@@@@@@@@@@@@@@&&&@@@@.
@@@@@@@@@@@@@@@@@@@&@@@@@@@@@
,##(@@@@@@@@@@@@@@@@@@@@@@@@@@#
@@@@@@@@@@@@@@@@@@@@@@&@@@@@@@@(
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
,%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&%%#
&@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@(
/(#*
*/
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./MultisigOwnable.sol";
import "./ERC721A.sol";
import "./extensions/ERC721ABurnable.sol";
import "./extensions/ERC721AQueryable.sol";
contract LikeABrush is MultisigOwnable, ERC721A, ERC721ABurnable, ERC721AQueryable, PaymentSplitter {
using Strings for uint;
uint public WLSaleDate = 1663675200;
uint public ALSaleDate = 1663696800;
uint public SaleDate = 1663700400;
uint public EndSaleDate = 1663711200;
string public baseURI;
string public unrevealedURI;
uint private constant METADATAS_LENGTH = 3333;
uint private constant MAX_TEAM = 333;
uint private constant MAX_SUPPLY_AL = 3200;
uint private constant MAX_MINT_PER_WI_ACCOUNT = 5;
uint private constant MAX_MINT_PER_WL_ACCOUNT = 2;
uint private constant MAX_MINT_PER_AL_ACCOUNT = 1;
uint private amountOfWLDoubleOwner = 0;
uint private constant MAX_WL_DOUBLE_OWNER = 500;
uint private amountNFTonTM;
mapping(address => uint) private amountNFTsperWLWallet;
mapping(address => uint) private amountNFTsperALWallet;
mapping(address => uint) private amountNFTsperFMWallet;
mapping(address => uint) private amountNFTsperWIWallet;
uint public presalePrice = 0.23 ether;
uint public salePrice = 0.28 ether;
uint public maxSupply = METADATAS_LENGTH;
bytes32 public WLRoot;
bytes32 public OGRoot;
bytes32 public ALRoot;
bytes32 public WIRoot;
bytes32 public TMRoot;
bytes32 public FreeRoot;
bytes32 public IronRoot;
bytes32 public BronzeRoot;
bytes32 public SilverRoot;
bytes32 public GoldRoot;
bytes32 public PlatinumRoot;
uint private teamLength;
constructor(
address[] memory _team,
uint[] memory _teamShares,
string memory _unrevealedURI,
string memory _baseURI)
ERC721A("Like a Brush by Julien Durix", "LIKEABRUSH")
PaymentSplitter(_team, _teamShares) {
}
modifier callerIsUser() {
}
function whitelistMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function ogMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function winterMint(address _to, uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function allowlistMint(bytes32[] calldata _proof) external payable callerIsUser {
}
function publicMint(uint _quantity) external payable callerIsUser {
}
function winterPublicMint(address _to, uint _quantity) external payable {
}
function teamMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintIron(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintBronze(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
require(block.timestamp > WLSaleDate - 1, "Free mint is not activated");
require(block.timestamp < ALSaleDate, "Free mint is no longer activated");
require(<FILL_ME>)
require(amountNFTsperFMWallet[msg.sender] + _quantity < 4, "You can only get 3 free NFT");
require(msg.value == 0, "Wrong payment");
amountNFTsperFMWallet[msg.sender] += _quantity;
_mint(msg.sender, _quantity);
}
function freeMintSilver(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintGold(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintPlatinum(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function setUris(string memory newBaseURI, string memory newUnrevealedURI) external onlyRealOwner {
}
function setRoots(bytes32 _WLRoot, bytes32 _OGRoot, bytes32 _ALRoot, bytes32 _WIRoot, bytes32 _TMRoot, bytes32 _FreeRoot, bytes32 _IronRoot, bytes32 _BronzeRoot, bytes32 _SilverRoot, bytes32 _GoldRoot, bytes32 _PlatinumRoot) external onlyOwner {
}
function setDates(uint _WLSaleDate, uint _ALSaleDate, uint _SaleDate, uint _EndSaleDate) external onlyOwner {
}
function setMaxSupply(uint _maxSupply) external onlyOwner {
}
function isAuthorized(address _account, bytes32[] calldata _proof, bytes32 _root) internal pure returns (bool) {
}
function leaf(address _account) internal pure returns (bytes32) {
}
function _verify(bytes32 _leaf, bytes32[] memory _proof, bytes32 _root) internal pure returns (bool) {
}
uint public lastTokenRevealed = 0;
uint256 public randomness = 0;
function setRandomness(uint256 _randomness) external onlyOwner {
}
function getShuffledTokenId(uint id) view internal returns (uint) {
}
function batchReveal(uint256 batchSize) external onlyOwner {
}
function tokenURI(uint256 id) public view override returns (string memory) {
}
function releaseAll() external onlyRealOwner {
}
receive() override external payable {
}
}
| isAuthorized(msg.sender,_proof,BronzeRoot),"Not allowed" | 264,904 | isAuthorized(msg.sender,_proof,BronzeRoot) |
"You can only get 3 free NFT" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/*
@
@@@@@@
@@@@@@@@
@@@@@@@@
@@@@@@@@
@@@@@@@@@@@,
@@@@@@@@@@@@@@@@@@
* @@@@@@@@@@@@@@@@@@@@@@@@#
/@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@,&@@@@@@@@@@@@@@@@@@@@@@@@@&
,@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@%@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@#@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@&@@
/@@@@@@@@@@@@@@@@@@@@@@@@@@@@&
/@@@@&@@@@@@@@@@@@@%@##*%@@@@
@&@@@@@@@@@@@@@@&%@@@@@@@@@@
@@@@@@@&@@&&@@@@@#@@@% @@@@
@@&@@@@@@@@@@&&@&&&@@@@@@#@@
@@@@@&@@@@@@@@@@@@@@@@@@@%@@
@@@@@@@@@@&@@@@@@@@@@@@@@%@@
@&@@@&@@@@@@@@@@@@@@@@@&@&@@
@&@@@@@@@@@@@@@@@@@@@@&&&%@@
%%@@ @@@@%@@@@@@@%@@&%&%%%@@
@@@@@@@&@@&//@@@@@@ &@&%@@@
@@@@&@@@@@@@@@@@@@@&&%&%&@@
&@@%@@@@(@@@@@@&&&&&&&%%@@@
@@@@@@@@@@&/@@@&@&&&@@&&@@@
@@@@@@@@@@@@@@@@@&&&&&@@@@@
%@@@@@@@@@@@@@@(@@&%&@&&&@@@
@@@@@@@@@@@@@@@@@@@@@&&&@@@@.
@@@@@@@@@@@@@@@@@@@&@@@@@@@@@
,##(@@@@@@@@@@@@@@@@@@@@@@@@@@#
@@@@@@@@@@@@@@@@@@@@@@&@@@@@@@@(
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
,%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&%%#
&@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@(
/(#*
*/
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./MultisigOwnable.sol";
import "./ERC721A.sol";
import "./extensions/ERC721ABurnable.sol";
import "./extensions/ERC721AQueryable.sol";
contract LikeABrush is MultisigOwnable, ERC721A, ERC721ABurnable, ERC721AQueryable, PaymentSplitter {
using Strings for uint;
uint public WLSaleDate = 1663675200;
uint public ALSaleDate = 1663696800;
uint public SaleDate = 1663700400;
uint public EndSaleDate = 1663711200;
string public baseURI;
string public unrevealedURI;
uint private constant METADATAS_LENGTH = 3333;
uint private constant MAX_TEAM = 333;
uint private constant MAX_SUPPLY_AL = 3200;
uint private constant MAX_MINT_PER_WI_ACCOUNT = 5;
uint private constant MAX_MINT_PER_WL_ACCOUNT = 2;
uint private constant MAX_MINT_PER_AL_ACCOUNT = 1;
uint private amountOfWLDoubleOwner = 0;
uint private constant MAX_WL_DOUBLE_OWNER = 500;
uint private amountNFTonTM;
mapping(address => uint) private amountNFTsperWLWallet;
mapping(address => uint) private amountNFTsperALWallet;
mapping(address => uint) private amountNFTsperFMWallet;
mapping(address => uint) private amountNFTsperWIWallet;
uint public presalePrice = 0.23 ether;
uint public salePrice = 0.28 ether;
uint public maxSupply = METADATAS_LENGTH;
bytes32 public WLRoot;
bytes32 public OGRoot;
bytes32 public ALRoot;
bytes32 public WIRoot;
bytes32 public TMRoot;
bytes32 public FreeRoot;
bytes32 public IronRoot;
bytes32 public BronzeRoot;
bytes32 public SilverRoot;
bytes32 public GoldRoot;
bytes32 public PlatinumRoot;
uint private teamLength;
constructor(
address[] memory _team,
uint[] memory _teamShares,
string memory _unrevealedURI,
string memory _baseURI)
ERC721A("Like a Brush by Julien Durix", "LIKEABRUSH")
PaymentSplitter(_team, _teamShares) {
}
modifier callerIsUser() {
}
function whitelistMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function ogMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function winterMint(address _to, uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function allowlistMint(bytes32[] calldata _proof) external payable callerIsUser {
}
function publicMint(uint _quantity) external payable callerIsUser {
}
function winterPublicMint(address _to, uint _quantity) external payable {
}
function teamMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintIron(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintBronze(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
require(block.timestamp > WLSaleDate - 1, "Free mint is not activated");
require(block.timestamp < ALSaleDate, "Free mint is no longer activated");
require(isAuthorized(msg.sender, _proof, BronzeRoot), "Not allowed");
require(<FILL_ME>)
require(msg.value == 0, "Wrong payment");
amountNFTsperFMWallet[msg.sender] += _quantity;
_mint(msg.sender, _quantity);
}
function freeMintSilver(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintGold(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintPlatinum(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function setUris(string memory newBaseURI, string memory newUnrevealedURI) external onlyRealOwner {
}
function setRoots(bytes32 _WLRoot, bytes32 _OGRoot, bytes32 _ALRoot, bytes32 _WIRoot, bytes32 _TMRoot, bytes32 _FreeRoot, bytes32 _IronRoot, bytes32 _BronzeRoot, bytes32 _SilverRoot, bytes32 _GoldRoot, bytes32 _PlatinumRoot) external onlyOwner {
}
function setDates(uint _WLSaleDate, uint _ALSaleDate, uint _SaleDate, uint _EndSaleDate) external onlyOwner {
}
function setMaxSupply(uint _maxSupply) external onlyOwner {
}
function isAuthorized(address _account, bytes32[] calldata _proof, bytes32 _root) internal pure returns (bool) {
}
function leaf(address _account) internal pure returns (bytes32) {
}
function _verify(bytes32 _leaf, bytes32[] memory _proof, bytes32 _root) internal pure returns (bool) {
}
uint public lastTokenRevealed = 0;
uint256 public randomness = 0;
function setRandomness(uint256 _randomness) external onlyOwner {
}
function getShuffledTokenId(uint id) view internal returns (uint) {
}
function batchReveal(uint256 batchSize) external onlyOwner {
}
function tokenURI(uint256 id) public view override returns (string memory) {
}
function releaseAll() external onlyRealOwner {
}
receive() override external payable {
}
}
| amountNFTsperFMWallet[msg.sender]+_quantity<4,"You can only get 3 free NFT" | 264,904 | amountNFTsperFMWallet[msg.sender]+_quantity<4 |
"Not allowed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/*
@
@@@@@@
@@@@@@@@
@@@@@@@@
@@@@@@@@
@@@@@@@@@@@,
@@@@@@@@@@@@@@@@@@
* @@@@@@@@@@@@@@@@@@@@@@@@#
/@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@,&@@@@@@@@@@@@@@@@@@@@@@@@@&
,@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@%@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@#@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@&@@
/@@@@@@@@@@@@@@@@@@@@@@@@@@@@&
/@@@@&@@@@@@@@@@@@@%@##*%@@@@
@&@@@@@@@@@@@@@@&%@@@@@@@@@@
@@@@@@@&@@&&@@@@@#@@@% @@@@
@@&@@@@@@@@@@&&@&&&@@@@@@#@@
@@@@@&@@@@@@@@@@@@@@@@@@@%@@
@@@@@@@@@@&@@@@@@@@@@@@@@%@@
@&@@@&@@@@@@@@@@@@@@@@@&@&@@
@&@@@@@@@@@@@@@@@@@@@@&&&%@@
%%@@ @@@@%@@@@@@@%@@&%&%%%@@
@@@@@@@&@@&//@@@@@@ &@&%@@@
@@@@&@@@@@@@@@@@@@@&&%&%&@@
&@@%@@@@(@@@@@@&&&&&&&%%@@@
@@@@@@@@@@&/@@@&@&&&@@&&@@@
@@@@@@@@@@@@@@@@@&&&&&@@@@@
%@@@@@@@@@@@@@@(@@&%&@&&&@@@
@@@@@@@@@@@@@@@@@@@@@&&&@@@@.
@@@@@@@@@@@@@@@@@@@&@@@@@@@@@
,##(@@@@@@@@@@@@@@@@@@@@@@@@@@#
@@@@@@@@@@@@@@@@@@@@@@&@@@@@@@@(
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
,%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&%%#
&@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@(
/(#*
*/
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./MultisigOwnable.sol";
import "./ERC721A.sol";
import "./extensions/ERC721ABurnable.sol";
import "./extensions/ERC721AQueryable.sol";
contract LikeABrush is MultisigOwnable, ERC721A, ERC721ABurnable, ERC721AQueryable, PaymentSplitter {
using Strings for uint;
uint public WLSaleDate = 1663675200;
uint public ALSaleDate = 1663696800;
uint public SaleDate = 1663700400;
uint public EndSaleDate = 1663711200;
string public baseURI;
string public unrevealedURI;
uint private constant METADATAS_LENGTH = 3333;
uint private constant MAX_TEAM = 333;
uint private constant MAX_SUPPLY_AL = 3200;
uint private constant MAX_MINT_PER_WI_ACCOUNT = 5;
uint private constant MAX_MINT_PER_WL_ACCOUNT = 2;
uint private constant MAX_MINT_PER_AL_ACCOUNT = 1;
uint private amountOfWLDoubleOwner = 0;
uint private constant MAX_WL_DOUBLE_OWNER = 500;
uint private amountNFTonTM;
mapping(address => uint) private amountNFTsperWLWallet;
mapping(address => uint) private amountNFTsperALWallet;
mapping(address => uint) private amountNFTsperFMWallet;
mapping(address => uint) private amountNFTsperWIWallet;
uint public presalePrice = 0.23 ether;
uint public salePrice = 0.28 ether;
uint public maxSupply = METADATAS_LENGTH;
bytes32 public WLRoot;
bytes32 public OGRoot;
bytes32 public ALRoot;
bytes32 public WIRoot;
bytes32 public TMRoot;
bytes32 public FreeRoot;
bytes32 public IronRoot;
bytes32 public BronzeRoot;
bytes32 public SilverRoot;
bytes32 public GoldRoot;
bytes32 public PlatinumRoot;
uint private teamLength;
constructor(
address[] memory _team,
uint[] memory _teamShares,
string memory _unrevealedURI,
string memory _baseURI)
ERC721A("Like a Brush by Julien Durix", "LIKEABRUSH")
PaymentSplitter(_team, _teamShares) {
}
modifier callerIsUser() {
}
function whitelistMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function ogMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function winterMint(address _to, uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function allowlistMint(bytes32[] calldata _proof) external payable callerIsUser {
}
function publicMint(uint _quantity) external payable callerIsUser {
}
function winterPublicMint(address _to, uint _quantity) external payable {
}
function teamMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintIron(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintBronze(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintSilver(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
require(block.timestamp > WLSaleDate - 1, "Free mint is not activated");
require(block.timestamp < ALSaleDate, "Free mint is no longer activated");
require(<FILL_ME>)
require(amountNFTsperFMWallet[msg.sender] + _quantity < 16, "You can only get 15 free NFT");
require(msg.value == 0, "Wrong payment");
amountNFTsperFMWallet[msg.sender] += _quantity;
_mint(msg.sender, _quantity);
}
function freeMintGold(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintPlatinum(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function setUris(string memory newBaseURI, string memory newUnrevealedURI) external onlyRealOwner {
}
function setRoots(bytes32 _WLRoot, bytes32 _OGRoot, bytes32 _ALRoot, bytes32 _WIRoot, bytes32 _TMRoot, bytes32 _FreeRoot, bytes32 _IronRoot, bytes32 _BronzeRoot, bytes32 _SilverRoot, bytes32 _GoldRoot, bytes32 _PlatinumRoot) external onlyOwner {
}
function setDates(uint _WLSaleDate, uint _ALSaleDate, uint _SaleDate, uint _EndSaleDate) external onlyOwner {
}
function setMaxSupply(uint _maxSupply) external onlyOwner {
}
function isAuthorized(address _account, bytes32[] calldata _proof, bytes32 _root) internal pure returns (bool) {
}
function leaf(address _account) internal pure returns (bytes32) {
}
function _verify(bytes32 _leaf, bytes32[] memory _proof, bytes32 _root) internal pure returns (bool) {
}
uint public lastTokenRevealed = 0;
uint256 public randomness = 0;
function setRandomness(uint256 _randomness) external onlyOwner {
}
function getShuffledTokenId(uint id) view internal returns (uint) {
}
function batchReveal(uint256 batchSize) external onlyOwner {
}
function tokenURI(uint256 id) public view override returns (string memory) {
}
function releaseAll() external onlyRealOwner {
}
receive() override external payable {
}
}
| isAuthorized(msg.sender,_proof,SilverRoot),"Not allowed" | 264,904 | isAuthorized(msg.sender,_proof,SilverRoot) |
"You can only get 15 free NFT" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/*
@
@@@@@@
@@@@@@@@
@@@@@@@@
@@@@@@@@
@@@@@@@@@@@,
@@@@@@@@@@@@@@@@@@
* @@@@@@@@@@@@@@@@@@@@@@@@#
/@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@,&@@@@@@@@@@@@@@@@@@@@@@@@@&
,@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@%@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@#@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@&@@
/@@@@@@@@@@@@@@@@@@@@@@@@@@@@&
/@@@@&@@@@@@@@@@@@@%@##*%@@@@
@&@@@@@@@@@@@@@@&%@@@@@@@@@@
@@@@@@@&@@&&@@@@@#@@@% @@@@
@@&@@@@@@@@@@&&@&&&@@@@@@#@@
@@@@@&@@@@@@@@@@@@@@@@@@@%@@
@@@@@@@@@@&@@@@@@@@@@@@@@%@@
@&@@@&@@@@@@@@@@@@@@@@@&@&@@
@&@@@@@@@@@@@@@@@@@@@@&&&%@@
%%@@ @@@@%@@@@@@@%@@&%&%%%@@
@@@@@@@&@@&//@@@@@@ &@&%@@@
@@@@&@@@@@@@@@@@@@@&&%&%&@@
&@@%@@@@(@@@@@@&&&&&&&%%@@@
@@@@@@@@@@&/@@@&@&&&@@&&@@@
@@@@@@@@@@@@@@@@@&&&&&@@@@@
%@@@@@@@@@@@@@@(@@&%&@&&&@@@
@@@@@@@@@@@@@@@@@@@@@&&&@@@@.
@@@@@@@@@@@@@@@@@@@&@@@@@@@@@
,##(@@@@@@@@@@@@@@@@@@@@@@@@@@#
@@@@@@@@@@@@@@@@@@@@@@&@@@@@@@@(
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
,%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&%%#
&@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@(
/(#*
*/
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./MultisigOwnable.sol";
import "./ERC721A.sol";
import "./extensions/ERC721ABurnable.sol";
import "./extensions/ERC721AQueryable.sol";
contract LikeABrush is MultisigOwnable, ERC721A, ERC721ABurnable, ERC721AQueryable, PaymentSplitter {
using Strings for uint;
uint public WLSaleDate = 1663675200;
uint public ALSaleDate = 1663696800;
uint public SaleDate = 1663700400;
uint public EndSaleDate = 1663711200;
string public baseURI;
string public unrevealedURI;
uint private constant METADATAS_LENGTH = 3333;
uint private constant MAX_TEAM = 333;
uint private constant MAX_SUPPLY_AL = 3200;
uint private constant MAX_MINT_PER_WI_ACCOUNT = 5;
uint private constant MAX_MINT_PER_WL_ACCOUNT = 2;
uint private constant MAX_MINT_PER_AL_ACCOUNT = 1;
uint private amountOfWLDoubleOwner = 0;
uint private constant MAX_WL_DOUBLE_OWNER = 500;
uint private amountNFTonTM;
mapping(address => uint) private amountNFTsperWLWallet;
mapping(address => uint) private amountNFTsperALWallet;
mapping(address => uint) private amountNFTsperFMWallet;
mapping(address => uint) private amountNFTsperWIWallet;
uint public presalePrice = 0.23 ether;
uint public salePrice = 0.28 ether;
uint public maxSupply = METADATAS_LENGTH;
bytes32 public WLRoot;
bytes32 public OGRoot;
bytes32 public ALRoot;
bytes32 public WIRoot;
bytes32 public TMRoot;
bytes32 public FreeRoot;
bytes32 public IronRoot;
bytes32 public BronzeRoot;
bytes32 public SilverRoot;
bytes32 public GoldRoot;
bytes32 public PlatinumRoot;
uint private teamLength;
constructor(
address[] memory _team,
uint[] memory _teamShares,
string memory _unrevealedURI,
string memory _baseURI)
ERC721A("Like a Brush by Julien Durix", "LIKEABRUSH")
PaymentSplitter(_team, _teamShares) {
}
modifier callerIsUser() {
}
function whitelistMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function ogMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function winterMint(address _to, uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function allowlistMint(bytes32[] calldata _proof) external payable callerIsUser {
}
function publicMint(uint _quantity) external payable callerIsUser {
}
function winterPublicMint(address _to, uint _quantity) external payable {
}
function teamMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintIron(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintBronze(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintSilver(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
require(block.timestamp > WLSaleDate - 1, "Free mint is not activated");
require(block.timestamp < ALSaleDate, "Free mint is no longer activated");
require(isAuthorized(msg.sender, _proof, SilverRoot), "Not allowed");
require(<FILL_ME>)
require(msg.value == 0, "Wrong payment");
amountNFTsperFMWallet[msg.sender] += _quantity;
_mint(msg.sender, _quantity);
}
function freeMintGold(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintPlatinum(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function setUris(string memory newBaseURI, string memory newUnrevealedURI) external onlyRealOwner {
}
function setRoots(bytes32 _WLRoot, bytes32 _OGRoot, bytes32 _ALRoot, bytes32 _WIRoot, bytes32 _TMRoot, bytes32 _FreeRoot, bytes32 _IronRoot, bytes32 _BronzeRoot, bytes32 _SilverRoot, bytes32 _GoldRoot, bytes32 _PlatinumRoot) external onlyOwner {
}
function setDates(uint _WLSaleDate, uint _ALSaleDate, uint _SaleDate, uint _EndSaleDate) external onlyOwner {
}
function setMaxSupply(uint _maxSupply) external onlyOwner {
}
function isAuthorized(address _account, bytes32[] calldata _proof, bytes32 _root) internal pure returns (bool) {
}
function leaf(address _account) internal pure returns (bytes32) {
}
function _verify(bytes32 _leaf, bytes32[] memory _proof, bytes32 _root) internal pure returns (bool) {
}
uint public lastTokenRevealed = 0;
uint256 public randomness = 0;
function setRandomness(uint256 _randomness) external onlyOwner {
}
function getShuffledTokenId(uint id) view internal returns (uint) {
}
function batchReveal(uint256 batchSize) external onlyOwner {
}
function tokenURI(uint256 id) public view override returns (string memory) {
}
function releaseAll() external onlyRealOwner {
}
receive() override external payable {
}
}
| amountNFTsperFMWallet[msg.sender]+_quantity<16,"You can only get 15 free NFT" | 264,904 | amountNFTsperFMWallet[msg.sender]+_quantity<16 |
"Not allowed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/*
@
@@@@@@
@@@@@@@@
@@@@@@@@
@@@@@@@@
@@@@@@@@@@@,
@@@@@@@@@@@@@@@@@@
* @@@@@@@@@@@@@@@@@@@@@@@@#
/@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@,&@@@@@@@@@@@@@@@@@@@@@@@@@&
,@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@%@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@#@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@&@@
/@@@@@@@@@@@@@@@@@@@@@@@@@@@@&
/@@@@&@@@@@@@@@@@@@%@##*%@@@@
@&@@@@@@@@@@@@@@&%@@@@@@@@@@
@@@@@@@&@@&&@@@@@#@@@% @@@@
@@&@@@@@@@@@@&&@&&&@@@@@@#@@
@@@@@&@@@@@@@@@@@@@@@@@@@%@@
@@@@@@@@@@&@@@@@@@@@@@@@@%@@
@&@@@&@@@@@@@@@@@@@@@@@&@&@@
@&@@@@@@@@@@@@@@@@@@@@&&&%@@
%%@@ @@@@%@@@@@@@%@@&%&%%%@@
@@@@@@@&@@&//@@@@@@ &@&%@@@
@@@@&@@@@@@@@@@@@@@&&%&%&@@
&@@%@@@@(@@@@@@&&&&&&&%%@@@
@@@@@@@@@@&/@@@&@&&&@@&&@@@
@@@@@@@@@@@@@@@@@&&&&&@@@@@
%@@@@@@@@@@@@@@(@@&%&@&&&@@@
@@@@@@@@@@@@@@@@@@@@@&&&@@@@.
@@@@@@@@@@@@@@@@@@@&@@@@@@@@@
,##(@@@@@@@@@@@@@@@@@@@@@@@@@@#
@@@@@@@@@@@@@@@@@@@@@@&@@@@@@@@(
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
,%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&%%#
&@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@(
/(#*
*/
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./MultisigOwnable.sol";
import "./ERC721A.sol";
import "./extensions/ERC721ABurnable.sol";
import "./extensions/ERC721AQueryable.sol";
contract LikeABrush is MultisigOwnable, ERC721A, ERC721ABurnable, ERC721AQueryable, PaymentSplitter {
using Strings for uint;
uint public WLSaleDate = 1663675200;
uint public ALSaleDate = 1663696800;
uint public SaleDate = 1663700400;
uint public EndSaleDate = 1663711200;
string public baseURI;
string public unrevealedURI;
uint private constant METADATAS_LENGTH = 3333;
uint private constant MAX_TEAM = 333;
uint private constant MAX_SUPPLY_AL = 3200;
uint private constant MAX_MINT_PER_WI_ACCOUNT = 5;
uint private constant MAX_MINT_PER_WL_ACCOUNT = 2;
uint private constant MAX_MINT_PER_AL_ACCOUNT = 1;
uint private amountOfWLDoubleOwner = 0;
uint private constant MAX_WL_DOUBLE_OWNER = 500;
uint private amountNFTonTM;
mapping(address => uint) private amountNFTsperWLWallet;
mapping(address => uint) private amountNFTsperALWallet;
mapping(address => uint) private amountNFTsperFMWallet;
mapping(address => uint) private amountNFTsperWIWallet;
uint public presalePrice = 0.23 ether;
uint public salePrice = 0.28 ether;
uint public maxSupply = METADATAS_LENGTH;
bytes32 public WLRoot;
bytes32 public OGRoot;
bytes32 public ALRoot;
bytes32 public WIRoot;
bytes32 public TMRoot;
bytes32 public FreeRoot;
bytes32 public IronRoot;
bytes32 public BronzeRoot;
bytes32 public SilverRoot;
bytes32 public GoldRoot;
bytes32 public PlatinumRoot;
uint private teamLength;
constructor(
address[] memory _team,
uint[] memory _teamShares,
string memory _unrevealedURI,
string memory _baseURI)
ERC721A("Like a Brush by Julien Durix", "LIKEABRUSH")
PaymentSplitter(_team, _teamShares) {
}
modifier callerIsUser() {
}
function whitelistMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function ogMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function winterMint(address _to, uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function allowlistMint(bytes32[] calldata _proof) external payable callerIsUser {
}
function publicMint(uint _quantity) external payable callerIsUser {
}
function winterPublicMint(address _to, uint _quantity) external payable {
}
function teamMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintIron(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintBronze(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintSilver(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintGold(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
require(block.timestamp > WLSaleDate - 1, "Free mint is not activated");
require(block.timestamp < ALSaleDate, "Free mint is no longer activated");
require(<FILL_ME>)
require(amountNFTsperFMWallet[msg.sender] + _quantity < 21, "You can only get 20 free NFT");
require(msg.value == 0, "Wrong payment");
amountNFTsperFMWallet[msg.sender] += _quantity;
_mint(msg.sender, _quantity);
}
function freeMintPlatinum(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function setUris(string memory newBaseURI, string memory newUnrevealedURI) external onlyRealOwner {
}
function setRoots(bytes32 _WLRoot, bytes32 _OGRoot, bytes32 _ALRoot, bytes32 _WIRoot, bytes32 _TMRoot, bytes32 _FreeRoot, bytes32 _IronRoot, bytes32 _BronzeRoot, bytes32 _SilverRoot, bytes32 _GoldRoot, bytes32 _PlatinumRoot) external onlyOwner {
}
function setDates(uint _WLSaleDate, uint _ALSaleDate, uint _SaleDate, uint _EndSaleDate) external onlyOwner {
}
function setMaxSupply(uint _maxSupply) external onlyOwner {
}
function isAuthorized(address _account, bytes32[] calldata _proof, bytes32 _root) internal pure returns (bool) {
}
function leaf(address _account) internal pure returns (bytes32) {
}
function _verify(bytes32 _leaf, bytes32[] memory _proof, bytes32 _root) internal pure returns (bool) {
}
uint public lastTokenRevealed = 0;
uint256 public randomness = 0;
function setRandomness(uint256 _randomness) external onlyOwner {
}
function getShuffledTokenId(uint id) view internal returns (uint) {
}
function batchReveal(uint256 batchSize) external onlyOwner {
}
function tokenURI(uint256 id) public view override returns (string memory) {
}
function releaseAll() external onlyRealOwner {
}
receive() override external payable {
}
}
| isAuthorized(msg.sender,_proof,GoldRoot),"Not allowed" | 264,904 | isAuthorized(msg.sender,_proof,GoldRoot) |
"You can only get 20 free NFT" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/*
@
@@@@@@
@@@@@@@@
@@@@@@@@
@@@@@@@@
@@@@@@@@@@@,
@@@@@@@@@@@@@@@@@@
* @@@@@@@@@@@@@@@@@@@@@@@@#
/@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@,&@@@@@@@@@@@@@@@@@@@@@@@@@&
,@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@%@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@#@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@&@@
/@@@@@@@@@@@@@@@@@@@@@@@@@@@@&
/@@@@&@@@@@@@@@@@@@%@##*%@@@@
@&@@@@@@@@@@@@@@&%@@@@@@@@@@
@@@@@@@&@@&&@@@@@#@@@% @@@@
@@&@@@@@@@@@@&&@&&&@@@@@@#@@
@@@@@&@@@@@@@@@@@@@@@@@@@%@@
@@@@@@@@@@&@@@@@@@@@@@@@@%@@
@&@@@&@@@@@@@@@@@@@@@@@&@&@@
@&@@@@@@@@@@@@@@@@@@@@&&&%@@
%%@@ @@@@%@@@@@@@%@@&%&%%%@@
@@@@@@@&@@&//@@@@@@ &@&%@@@
@@@@&@@@@@@@@@@@@@@&&%&%&@@
&@@%@@@@(@@@@@@&&&&&&&%%@@@
@@@@@@@@@@&/@@@&@&&&@@&&@@@
@@@@@@@@@@@@@@@@@&&&&&@@@@@
%@@@@@@@@@@@@@@(@@&%&@&&&@@@
@@@@@@@@@@@@@@@@@@@@@&&&@@@@.
@@@@@@@@@@@@@@@@@@@&@@@@@@@@@
,##(@@@@@@@@@@@@@@@@@@@@@@@@@@#
@@@@@@@@@@@@@@@@@@@@@@&@@@@@@@@(
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
,%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&%%#
&@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@(
/(#*
*/
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./MultisigOwnable.sol";
import "./ERC721A.sol";
import "./extensions/ERC721ABurnable.sol";
import "./extensions/ERC721AQueryable.sol";
contract LikeABrush is MultisigOwnable, ERC721A, ERC721ABurnable, ERC721AQueryable, PaymentSplitter {
using Strings for uint;
uint public WLSaleDate = 1663675200;
uint public ALSaleDate = 1663696800;
uint public SaleDate = 1663700400;
uint public EndSaleDate = 1663711200;
string public baseURI;
string public unrevealedURI;
uint private constant METADATAS_LENGTH = 3333;
uint private constant MAX_TEAM = 333;
uint private constant MAX_SUPPLY_AL = 3200;
uint private constant MAX_MINT_PER_WI_ACCOUNT = 5;
uint private constant MAX_MINT_PER_WL_ACCOUNT = 2;
uint private constant MAX_MINT_PER_AL_ACCOUNT = 1;
uint private amountOfWLDoubleOwner = 0;
uint private constant MAX_WL_DOUBLE_OWNER = 500;
uint private amountNFTonTM;
mapping(address => uint) private amountNFTsperWLWallet;
mapping(address => uint) private amountNFTsperALWallet;
mapping(address => uint) private amountNFTsperFMWallet;
mapping(address => uint) private amountNFTsperWIWallet;
uint public presalePrice = 0.23 ether;
uint public salePrice = 0.28 ether;
uint public maxSupply = METADATAS_LENGTH;
bytes32 public WLRoot;
bytes32 public OGRoot;
bytes32 public ALRoot;
bytes32 public WIRoot;
bytes32 public TMRoot;
bytes32 public FreeRoot;
bytes32 public IronRoot;
bytes32 public BronzeRoot;
bytes32 public SilverRoot;
bytes32 public GoldRoot;
bytes32 public PlatinumRoot;
uint private teamLength;
constructor(
address[] memory _team,
uint[] memory _teamShares,
string memory _unrevealedURI,
string memory _baseURI)
ERC721A("Like a Brush by Julien Durix", "LIKEABRUSH")
PaymentSplitter(_team, _teamShares) {
}
modifier callerIsUser() {
}
function whitelistMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function ogMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function winterMint(address _to, uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function allowlistMint(bytes32[] calldata _proof) external payable callerIsUser {
}
function publicMint(uint _quantity) external payable callerIsUser {
}
function winterPublicMint(address _to, uint _quantity) external payable {
}
function teamMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintIron(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintBronze(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintSilver(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintGold(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
require(block.timestamp > WLSaleDate - 1, "Free mint is not activated");
require(block.timestamp < ALSaleDate, "Free mint is no longer activated");
require(isAuthorized(msg.sender, _proof, GoldRoot), "Not allowed");
require(<FILL_ME>)
require(msg.value == 0, "Wrong payment");
amountNFTsperFMWallet[msg.sender] += _quantity;
_mint(msg.sender, _quantity);
}
function freeMintPlatinum(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function setUris(string memory newBaseURI, string memory newUnrevealedURI) external onlyRealOwner {
}
function setRoots(bytes32 _WLRoot, bytes32 _OGRoot, bytes32 _ALRoot, bytes32 _WIRoot, bytes32 _TMRoot, bytes32 _FreeRoot, bytes32 _IronRoot, bytes32 _BronzeRoot, bytes32 _SilverRoot, bytes32 _GoldRoot, bytes32 _PlatinumRoot) external onlyOwner {
}
function setDates(uint _WLSaleDate, uint _ALSaleDate, uint _SaleDate, uint _EndSaleDate) external onlyOwner {
}
function setMaxSupply(uint _maxSupply) external onlyOwner {
}
function isAuthorized(address _account, bytes32[] calldata _proof, bytes32 _root) internal pure returns (bool) {
}
function leaf(address _account) internal pure returns (bytes32) {
}
function _verify(bytes32 _leaf, bytes32[] memory _proof, bytes32 _root) internal pure returns (bool) {
}
uint public lastTokenRevealed = 0;
uint256 public randomness = 0;
function setRandomness(uint256 _randomness) external onlyOwner {
}
function getShuffledTokenId(uint id) view internal returns (uint) {
}
function batchReveal(uint256 batchSize) external onlyOwner {
}
function tokenURI(uint256 id) public view override returns (string memory) {
}
function releaseAll() external onlyRealOwner {
}
receive() override external payable {
}
}
| amountNFTsperFMWallet[msg.sender]+_quantity<21,"You can only get 20 free NFT" | 264,904 | amountNFTsperFMWallet[msg.sender]+_quantity<21 |
"Not allowed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/*
@
@@@@@@
@@@@@@@@
@@@@@@@@
@@@@@@@@
@@@@@@@@@@@,
@@@@@@@@@@@@@@@@@@
* @@@@@@@@@@@@@@@@@@@@@@@@#
/@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@,&@@@@@@@@@@@@@@@@@@@@@@@@@&
,@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@%@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@#@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@&@@
/@@@@@@@@@@@@@@@@@@@@@@@@@@@@&
/@@@@&@@@@@@@@@@@@@%@##*%@@@@
@&@@@@@@@@@@@@@@&%@@@@@@@@@@
@@@@@@@&@@&&@@@@@#@@@% @@@@
@@&@@@@@@@@@@&&@&&&@@@@@@#@@
@@@@@&@@@@@@@@@@@@@@@@@@@%@@
@@@@@@@@@@&@@@@@@@@@@@@@@%@@
@&@@@&@@@@@@@@@@@@@@@@@&@&@@
@&@@@@@@@@@@@@@@@@@@@@&&&%@@
%%@@ @@@@%@@@@@@@%@@&%&%%%@@
@@@@@@@&@@&//@@@@@@ &@&%@@@
@@@@&@@@@@@@@@@@@@@&&%&%&@@
&@@%@@@@(@@@@@@&&&&&&&%%@@@
@@@@@@@@@@&/@@@&@&&&@@&&@@@
@@@@@@@@@@@@@@@@@&&&&&@@@@@
%@@@@@@@@@@@@@@(@@&%&@&&&@@@
@@@@@@@@@@@@@@@@@@@@@&&&@@@@.
@@@@@@@@@@@@@@@@@@@&@@@@@@@@@
,##(@@@@@@@@@@@@@@@@@@@@@@@@@@#
@@@@@@@@@@@@@@@@@@@@@@&@@@@@@@@(
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
,%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&%%#
&@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@(
/(#*
*/
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./MultisigOwnable.sol";
import "./ERC721A.sol";
import "./extensions/ERC721ABurnable.sol";
import "./extensions/ERC721AQueryable.sol";
contract LikeABrush is MultisigOwnable, ERC721A, ERC721ABurnable, ERC721AQueryable, PaymentSplitter {
using Strings for uint;
uint public WLSaleDate = 1663675200;
uint public ALSaleDate = 1663696800;
uint public SaleDate = 1663700400;
uint public EndSaleDate = 1663711200;
string public baseURI;
string public unrevealedURI;
uint private constant METADATAS_LENGTH = 3333;
uint private constant MAX_TEAM = 333;
uint private constant MAX_SUPPLY_AL = 3200;
uint private constant MAX_MINT_PER_WI_ACCOUNT = 5;
uint private constant MAX_MINT_PER_WL_ACCOUNT = 2;
uint private constant MAX_MINT_PER_AL_ACCOUNT = 1;
uint private amountOfWLDoubleOwner = 0;
uint private constant MAX_WL_DOUBLE_OWNER = 500;
uint private amountNFTonTM;
mapping(address => uint) private amountNFTsperWLWallet;
mapping(address => uint) private amountNFTsperALWallet;
mapping(address => uint) private amountNFTsperFMWallet;
mapping(address => uint) private amountNFTsperWIWallet;
uint public presalePrice = 0.23 ether;
uint public salePrice = 0.28 ether;
uint public maxSupply = METADATAS_LENGTH;
bytes32 public WLRoot;
bytes32 public OGRoot;
bytes32 public ALRoot;
bytes32 public WIRoot;
bytes32 public TMRoot;
bytes32 public FreeRoot;
bytes32 public IronRoot;
bytes32 public BronzeRoot;
bytes32 public SilverRoot;
bytes32 public GoldRoot;
bytes32 public PlatinumRoot;
uint private teamLength;
constructor(
address[] memory _team,
uint[] memory _teamShares,
string memory _unrevealedURI,
string memory _baseURI)
ERC721A("Like a Brush by Julien Durix", "LIKEABRUSH")
PaymentSplitter(_team, _teamShares) {
}
modifier callerIsUser() {
}
function whitelistMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function ogMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function winterMint(address _to, uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function allowlistMint(bytes32[] calldata _proof) external payable callerIsUser {
}
function publicMint(uint _quantity) external payable callerIsUser {
}
function winterPublicMint(address _to, uint _quantity) external payable {
}
function teamMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintIron(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintBronze(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintSilver(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintGold(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintPlatinum(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
require(block.timestamp > WLSaleDate - 1, "Free mint is not activated");
require(block.timestamp < ALSaleDate, "Free mint is no longer activated");
require(<FILL_ME>)
require(amountNFTsperFMWallet[msg.sender] + _quantity < 39, "You can only get 38 free NFT");
require(msg.value == 0, "Wrong payment");
amountNFTsperFMWallet[msg.sender] += _quantity;
_mint(msg.sender, _quantity);
}
function setUris(string memory newBaseURI, string memory newUnrevealedURI) external onlyRealOwner {
}
function setRoots(bytes32 _WLRoot, bytes32 _OGRoot, bytes32 _ALRoot, bytes32 _WIRoot, bytes32 _TMRoot, bytes32 _FreeRoot, bytes32 _IronRoot, bytes32 _BronzeRoot, bytes32 _SilverRoot, bytes32 _GoldRoot, bytes32 _PlatinumRoot) external onlyOwner {
}
function setDates(uint _WLSaleDate, uint _ALSaleDate, uint _SaleDate, uint _EndSaleDate) external onlyOwner {
}
function setMaxSupply(uint _maxSupply) external onlyOwner {
}
function isAuthorized(address _account, bytes32[] calldata _proof, bytes32 _root) internal pure returns (bool) {
}
function leaf(address _account) internal pure returns (bytes32) {
}
function _verify(bytes32 _leaf, bytes32[] memory _proof, bytes32 _root) internal pure returns (bool) {
}
uint public lastTokenRevealed = 0;
uint256 public randomness = 0;
function setRandomness(uint256 _randomness) external onlyOwner {
}
function getShuffledTokenId(uint id) view internal returns (uint) {
}
function batchReveal(uint256 batchSize) external onlyOwner {
}
function tokenURI(uint256 id) public view override returns (string memory) {
}
function releaseAll() external onlyRealOwner {
}
receive() override external payable {
}
}
| isAuthorized(msg.sender,_proof,PlatinumRoot),"Not allowed" | 264,904 | isAuthorized(msg.sender,_proof,PlatinumRoot) |
"You can only get 38 free NFT" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/*
@
@@@@@@
@@@@@@@@
@@@@@@@@
@@@@@@@@
@@@@@@@@@@@,
@@@@@@@@@@@@@@@@@@
* @@@@@@@@@@@@@@@@@@@@@@@@#
/@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@,&@@@@@@@@@@@@@@@@@@@@@@@@@&
,@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@%@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@#@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@&@@
/@@@@@@@@@@@@@@@@@@@@@@@@@@@@&
/@@@@&@@@@@@@@@@@@@%@##*%@@@@
@&@@@@@@@@@@@@@@&%@@@@@@@@@@
@@@@@@@&@@&&@@@@@#@@@% @@@@
@@&@@@@@@@@@@&&@&&&@@@@@@#@@
@@@@@&@@@@@@@@@@@@@@@@@@@%@@
@@@@@@@@@@&@@@@@@@@@@@@@@%@@
@&@@@&@@@@@@@@@@@@@@@@@&@&@@
@&@@@@@@@@@@@@@@@@@@@@&&&%@@
%%@@ @@@@%@@@@@@@%@@&%&%%%@@
@@@@@@@&@@&//@@@@@@ &@&%@@@
@@@@&@@@@@@@@@@@@@@&&%&%&@@
&@@%@@@@(@@@@@@&&&&&&&%%@@@
@@@@@@@@@@&/@@@&@&&&@@&&@@@
@@@@@@@@@@@@@@@@@&&&&&@@@@@
%@@@@@@@@@@@@@@(@@&%&@&&&@@@
@@@@@@@@@@@@@@@@@@@@@&&&@@@@.
@@@@@@@@@@@@@@@@@@@&@@@@@@@@@
,##(@@@@@@@@@@@@@@@@@@@@@@@@@@#
@@@@@@@@@@@@@@@@@@@@@@&@@@@@@@@(
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
,%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&%%#
&@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@(
/(#*
*/
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./MultisigOwnable.sol";
import "./ERC721A.sol";
import "./extensions/ERC721ABurnable.sol";
import "./extensions/ERC721AQueryable.sol";
contract LikeABrush is MultisigOwnable, ERC721A, ERC721ABurnable, ERC721AQueryable, PaymentSplitter {
using Strings for uint;
uint public WLSaleDate = 1663675200;
uint public ALSaleDate = 1663696800;
uint public SaleDate = 1663700400;
uint public EndSaleDate = 1663711200;
string public baseURI;
string public unrevealedURI;
uint private constant METADATAS_LENGTH = 3333;
uint private constant MAX_TEAM = 333;
uint private constant MAX_SUPPLY_AL = 3200;
uint private constant MAX_MINT_PER_WI_ACCOUNT = 5;
uint private constant MAX_MINT_PER_WL_ACCOUNT = 2;
uint private constant MAX_MINT_PER_AL_ACCOUNT = 1;
uint private amountOfWLDoubleOwner = 0;
uint private constant MAX_WL_DOUBLE_OWNER = 500;
uint private amountNFTonTM;
mapping(address => uint) private amountNFTsperWLWallet;
mapping(address => uint) private amountNFTsperALWallet;
mapping(address => uint) private amountNFTsperFMWallet;
mapping(address => uint) private amountNFTsperWIWallet;
uint public presalePrice = 0.23 ether;
uint public salePrice = 0.28 ether;
uint public maxSupply = METADATAS_LENGTH;
bytes32 public WLRoot;
bytes32 public OGRoot;
bytes32 public ALRoot;
bytes32 public WIRoot;
bytes32 public TMRoot;
bytes32 public FreeRoot;
bytes32 public IronRoot;
bytes32 public BronzeRoot;
bytes32 public SilverRoot;
bytes32 public GoldRoot;
bytes32 public PlatinumRoot;
uint private teamLength;
constructor(
address[] memory _team,
uint[] memory _teamShares,
string memory _unrevealedURI,
string memory _baseURI)
ERC721A("Like a Brush by Julien Durix", "LIKEABRUSH")
PaymentSplitter(_team, _teamShares) {
}
modifier callerIsUser() {
}
function whitelistMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function ogMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function winterMint(address _to, uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function allowlistMint(bytes32[] calldata _proof) external payable callerIsUser {
}
function publicMint(uint _quantity) external payable callerIsUser {
}
function winterPublicMint(address _to, uint _quantity) external payable {
}
function teamMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintIron(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintBronze(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintSilver(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintGold(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintPlatinum(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
require(block.timestamp > WLSaleDate - 1, "Free mint is not activated");
require(block.timestamp < ALSaleDate, "Free mint is no longer activated");
require(isAuthorized(msg.sender, _proof, PlatinumRoot), "Not allowed");
require(<FILL_ME>)
require(msg.value == 0, "Wrong payment");
amountNFTsperFMWallet[msg.sender] += _quantity;
_mint(msg.sender, _quantity);
}
function setUris(string memory newBaseURI, string memory newUnrevealedURI) external onlyRealOwner {
}
function setRoots(bytes32 _WLRoot, bytes32 _OGRoot, bytes32 _ALRoot, bytes32 _WIRoot, bytes32 _TMRoot, bytes32 _FreeRoot, bytes32 _IronRoot, bytes32 _BronzeRoot, bytes32 _SilverRoot, bytes32 _GoldRoot, bytes32 _PlatinumRoot) external onlyOwner {
}
function setDates(uint _WLSaleDate, uint _ALSaleDate, uint _SaleDate, uint _EndSaleDate) external onlyOwner {
}
function setMaxSupply(uint _maxSupply) external onlyOwner {
}
function isAuthorized(address _account, bytes32[] calldata _proof, bytes32 _root) internal pure returns (bool) {
}
function leaf(address _account) internal pure returns (bytes32) {
}
function _verify(bytes32 _leaf, bytes32[] memory _proof, bytes32 _root) internal pure returns (bool) {
}
uint public lastTokenRevealed = 0;
uint256 public randomness = 0;
function setRandomness(uint256 _randomness) external onlyOwner {
}
function getShuffledTokenId(uint id) view internal returns (uint) {
}
function batchReveal(uint256 batchSize) external onlyOwner {
}
function tokenURI(uint256 id) public view override returns (string memory) {
}
function releaseAll() external onlyRealOwner {
}
receive() override external payable {
}
}
| amountNFTsperFMWallet[msg.sender]+_quantity<39,"You can only get 38 free NFT" | 264,904 | amountNFTsperFMWallet[msg.sender]+_quantity<39 |
"Over limit" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/*
@
@@@@@@
@@@@@@@@
@@@@@@@@
@@@@@@@@
@@@@@@@@@@@,
@@@@@@@@@@@@@@@@@@
* @@@@@@@@@@@@@@@@@@@@@@@@#
/@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@,&@@@@@@@@@@@@@@@@@@@@@@@@@&
,@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@%@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@#@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@&@@
/@@@@@@@@@@@@@@@@@@@@@@@@@@@@&
/@@@@&@@@@@@@@@@@@@%@##*%@@@@
@&@@@@@@@@@@@@@@&%@@@@@@@@@@
@@@@@@@&@@&&@@@@@#@@@% @@@@
@@&@@@@@@@@@@&&@&&&@@@@@@#@@
@@@@@&@@@@@@@@@@@@@@@@@@@%@@
@@@@@@@@@@&@@@@@@@@@@@@@@%@@
@&@@@&@@@@@@@@@@@@@@@@@&@&@@
@&@@@@@@@@@@@@@@@@@@@@&&&%@@
%%@@ @@@@%@@@@@@@%@@&%&%%%@@
@@@@@@@&@@&//@@@@@@ &@&%@@@
@@@@&@@@@@@@@@@@@@@&&%&%&@@
&@@%@@@@(@@@@@@&&&&&&&%%@@@
@@@@@@@@@@&/@@@&@&&&@@&&@@@
@@@@@@@@@@@@@@@@@&&&&&@@@@@
%@@@@@@@@@@@@@@(@@&%&@&&&@@@
@@@@@@@@@@@@@@@@@@@@@&&&@@@@.
@@@@@@@@@@@@@@@@@@@&@@@@@@@@@
,##(@@@@@@@@@@@@@@@@@@@@@@@@@@#
@@@@@@@@@@@@@@@@@@@@@@&@@@@@@@@(
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@.
,%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@&%%#
&@@@@@@@@@@@ @@@@@@@@@@@@@@@@@@@@@(
/(#*
*/
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./MultisigOwnable.sol";
import "./ERC721A.sol";
import "./extensions/ERC721ABurnable.sol";
import "./extensions/ERC721AQueryable.sol";
contract LikeABrush is MultisigOwnable, ERC721A, ERC721ABurnable, ERC721AQueryable, PaymentSplitter {
using Strings for uint;
uint public WLSaleDate = 1663675200;
uint public ALSaleDate = 1663696800;
uint public SaleDate = 1663700400;
uint public EndSaleDate = 1663711200;
string public baseURI;
string public unrevealedURI;
uint private constant METADATAS_LENGTH = 3333;
uint private constant MAX_TEAM = 333;
uint private constant MAX_SUPPLY_AL = 3200;
uint private constant MAX_MINT_PER_WI_ACCOUNT = 5;
uint private constant MAX_MINT_PER_WL_ACCOUNT = 2;
uint private constant MAX_MINT_PER_AL_ACCOUNT = 1;
uint private amountOfWLDoubleOwner = 0;
uint private constant MAX_WL_DOUBLE_OWNER = 500;
uint private amountNFTonTM;
mapping(address => uint) private amountNFTsperWLWallet;
mapping(address => uint) private amountNFTsperALWallet;
mapping(address => uint) private amountNFTsperFMWallet;
mapping(address => uint) private amountNFTsperWIWallet;
uint public presalePrice = 0.23 ether;
uint public salePrice = 0.28 ether;
uint public maxSupply = METADATAS_LENGTH;
bytes32 public WLRoot;
bytes32 public OGRoot;
bytes32 public ALRoot;
bytes32 public WIRoot;
bytes32 public TMRoot;
bytes32 public FreeRoot;
bytes32 public IronRoot;
bytes32 public BronzeRoot;
bytes32 public SilverRoot;
bytes32 public GoldRoot;
bytes32 public PlatinumRoot;
uint private teamLength;
constructor(
address[] memory _team,
uint[] memory _teamShares,
string memory _unrevealedURI,
string memory _baseURI)
ERC721A("Like a Brush by Julien Durix", "LIKEABRUSH")
PaymentSplitter(_team, _teamShares) {
}
modifier callerIsUser() {
}
function whitelistMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function ogMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function winterMint(address _to, uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function allowlistMint(bytes32[] calldata _proof) external payable callerIsUser {
}
function publicMint(uint _quantity) external payable callerIsUser {
}
function winterPublicMint(address _to, uint _quantity) external payable {
}
function teamMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMint(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintIron(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintBronze(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintSilver(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintGold(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function freeMintPlatinum(uint _quantity, bytes32[] calldata _proof) external payable callerIsUser {
}
function setUris(string memory newBaseURI, string memory newUnrevealedURI) external onlyRealOwner {
}
function setRoots(bytes32 _WLRoot, bytes32 _OGRoot, bytes32 _ALRoot, bytes32 _WIRoot, bytes32 _TMRoot, bytes32 _FreeRoot, bytes32 _IronRoot, bytes32 _BronzeRoot, bytes32 _SilverRoot, bytes32 _GoldRoot, bytes32 _PlatinumRoot) external onlyOwner {
}
function setDates(uint _WLSaleDate, uint _ALSaleDate, uint _SaleDate, uint _EndSaleDate) external onlyOwner {
}
function setMaxSupply(uint _maxSupply) external onlyOwner {
}
function isAuthorized(address _account, bytes32[] calldata _proof, bytes32 _root) internal pure returns (bool) {
}
function leaf(address _account) internal pure returns (bytes32) {
}
function _verify(bytes32 _leaf, bytes32[] memory _proof, bytes32 _root) internal pure returns (bool) {
}
uint public lastTokenRevealed = 0;
uint256 public randomness = 0;
function setRandomness(uint256 _randomness) external onlyOwner {
}
function getShuffledTokenId(uint id) view internal returns (uint) {
}
function batchReveal(uint256 batchSize) external onlyOwner {
require(randomness != 0, "Need a randomness");
require(<FILL_ME>)
lastTokenRevealed += batchSize;
}
function tokenURI(uint256 id) public view override returns (string memory) {
}
function releaseAll() external onlyRealOwner {
}
receive() override external payable {
}
}
| lastTokenRevealed+batchSize<METADATAS_LENGTH+1,"Over limit" | 264,904 | lastTokenRevealed+batchSize<METADATAS_LENGTH+1 |
"Liquidity already seeded" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
import "../pendle/contracts/interfaces/IPAllAction.sol";
import "../pendle/contracts/interfaces/IPMarket.sol";
import "../pendle/contracts/core/libraries/TokenHelper.sol";
contract LiquiditySeedingHelper is TokenHelper {
address public immutable router;
constructor(address _router) {
}
function _approveRouter(IStandardizedYield SY) internal {
}
function seedLiquidity(address market, address token, uint256 amount) external payable {
require(<FILL_ME>)
(IStandardizedYield SY, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market)
.readTokens();
_transferIn(token, msg.sender, amount);
// Approval
_approveRouter(SY);
_safeApproveInf(token, router);
_safeApproveInf(address(SY), router);
_safeApproveInf(address(PT), router);
// Mint SY
uint256 netNative = (token == NATIVE ? amount : 0);
IPAllAction(router).mintSyFromToken{ value: netNative }(
address(this),
address(SY),
0,
TokenInput({
tokenIn: token,
netTokenIn: amount,
tokenMintSy: token,
bulk: address(0),
pendleSwap: address(0),
swapData: SwapData({
swapType: SwapType.NONE,
extRouter: address(0),
extCalldata: abi.encode(),
needScale: false
})
})
);
// mint PY
IPAllAction(router).mintPyFromSy(address(this), address(YT), _selfBalance(SY) / 2, 0);
// mint LP
IPAllAction(router).addLiquidityDualSyAndPt(
msg.sender,
market,
_selfBalance(SY),
_selfBalance(PT),
0
);
_transferOut(address(YT), msg.sender, _selfBalance(YT));
}
receive() external payable {}
}
| IPMarket(market).totalSupply()==0,"Liquidity already seeded" | 265,121 | IPMarket(market).totalSupply()==0 |
'Max supply exceeded!' | pragma solidity >=0.8.9 <0.9.0;
contract Birds3D is ERC721AQueryable, Ownable, ReentrancyGuard {
using Strings for uint256;
//Initial Settings ->
string public tokenName = "3D Birds";
string public tokenSymbol = "3DB";
uint256 public maxSupply = 10000;
uint256 public maxReservedSupply = 200;
uint256 public reservedSupplyMinted = 0;
uint256 public firstWaveSupply = 2700;
uint256 public firstWavePrice = 0;
uint256 public secondWavePrice = 0.03 ether;
uint256 public wlMintAmount = 1;
uint256 public firstWaveMaxMint = 1;
uint256 public secondWaveMaxMint = 5;
bytes32 public merkleRoot;
mapping(address => uint256) public usersMinted;
bool public paused = true;
bool public whitelistMintEnabled = true;
bool public revealed = false;
string public uriPrefix = '';
string public uriSuffix = '.json';
string public hiddenMetadataUri = "";
constructor(string memory _hiddenMetadataUri) ERC721A(tokenName, tokenSymbol) {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier whenWLActive() {
}
modifier whenPublicActive() {
}
modifier noContract() {
}
function mintPublic(uint256 _mintAmount) public payable mintCompliance(_mintAmount) whenPublicActive noContract {
require(!paused, 'The contract is paused!');
require(<FILL_ME>)
usersMinted[_msgSender()] += _mintAmount;
_safeMint(_msgSender(), _mintAmount);
}
function mintWhitelist(bytes32[] calldata _merkleProof) public whenWLActive {
}
function mintOwner(uint256 _mintAmount, address _receiver) public onlyOwner {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setPaused(bool _state) public onlyOwner {
}
function setFirstWaveSupply(uint256 _value) public onlyOwner {
}
function setFirstWaveMaxMint(uint256 _value) public onlyOwner {
}
function setFirstWavePrice(uint256 _value) public onlyOwner {
}
function setSecondWaveMaxMint(uint256 _value) public onlyOwner {
}
function setSecondWavePrice(uint256 _value) public onlyOwner {
}
function setRevealed(bool _state) public onlyOwner {
}
function setMaxReservedSupply(uint256 _newMaxReservedSupply) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setWhitelistMintEnabled(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
// Internal ->
function _startTokenId() internal view virtual override returns (uint256) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| totalSupply()+_mintAmount<=(maxSupply-maxReservedSupply+reservedSupplyMinted),'Max supply exceeded!' | 265,160 | totalSupply()+_mintAmount<=(maxSupply-maxReservedSupply+reservedSupplyMinted) |
'You already minted WL' | pragma solidity >=0.8.9 <0.9.0;
contract Birds3D is ERC721AQueryable, Ownable, ReentrancyGuard {
using Strings for uint256;
//Initial Settings ->
string public tokenName = "3D Birds";
string public tokenSymbol = "3DB";
uint256 public maxSupply = 10000;
uint256 public maxReservedSupply = 200;
uint256 public reservedSupplyMinted = 0;
uint256 public firstWaveSupply = 2700;
uint256 public firstWavePrice = 0;
uint256 public secondWavePrice = 0.03 ether;
uint256 public wlMintAmount = 1;
uint256 public firstWaveMaxMint = 1;
uint256 public secondWaveMaxMint = 5;
bytes32 public merkleRoot;
mapping(address => uint256) public usersMinted;
bool public paused = true;
bool public whitelistMintEnabled = true;
bool public revealed = false;
string public uriPrefix = '';
string public uriSuffix = '.json';
string public hiddenMetadataUri = "";
constructor(string memory _hiddenMetadataUri) ERC721A(tokenName, tokenSymbol) {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier whenWLActive() {
}
modifier whenPublicActive() {
}
modifier noContract() {
}
function mintPublic(uint256 _mintAmount) public payable mintCompliance(_mintAmount) whenPublicActive noContract {
}
function mintWhitelist(bytes32[] calldata _merkleProof) public whenWLActive {
bytes32 leaf = keccak256(abi.encodePacked(_msgSender()));
require(MerkleProof.verify(_merkleProof, merkleRoot, leaf), 'Invalid proof!');
require(!paused, 'The contract is paused!');
require(<FILL_ME>)
require(totalSupply() + 1 <= (maxSupply - maxReservedSupply + reservedSupplyMinted), 'Max supply exceeded!');
usersMinted[_msgSender()] += wlMintAmount;
_safeMint(_msgSender(), wlMintAmount);
}
function mintOwner(uint256 _mintAmount, address _receiver) public onlyOwner {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setPaused(bool _state) public onlyOwner {
}
function setFirstWaveSupply(uint256 _value) public onlyOwner {
}
function setFirstWaveMaxMint(uint256 _value) public onlyOwner {
}
function setFirstWavePrice(uint256 _value) public onlyOwner {
}
function setSecondWaveMaxMint(uint256 _value) public onlyOwner {
}
function setSecondWavePrice(uint256 _value) public onlyOwner {
}
function setRevealed(bool _state) public onlyOwner {
}
function setMaxReservedSupply(uint256 _newMaxReservedSupply) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setWhitelistMintEnabled(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
// Internal ->
function _startTokenId() internal view virtual override returns (uint256) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| usersMinted[_msgSender()]<wlMintAmount,'You already minted WL' | 265,160 | usersMinted[_msgSender()]<wlMintAmount |
'Max supply exceeded!' | pragma solidity >=0.8.9 <0.9.0;
contract Birds3D is ERC721AQueryable, Ownable, ReentrancyGuard {
using Strings for uint256;
//Initial Settings ->
string public tokenName = "3D Birds";
string public tokenSymbol = "3DB";
uint256 public maxSupply = 10000;
uint256 public maxReservedSupply = 200;
uint256 public reservedSupplyMinted = 0;
uint256 public firstWaveSupply = 2700;
uint256 public firstWavePrice = 0;
uint256 public secondWavePrice = 0.03 ether;
uint256 public wlMintAmount = 1;
uint256 public firstWaveMaxMint = 1;
uint256 public secondWaveMaxMint = 5;
bytes32 public merkleRoot;
mapping(address => uint256) public usersMinted;
bool public paused = true;
bool public whitelistMintEnabled = true;
bool public revealed = false;
string public uriPrefix = '';
string public uriSuffix = '.json';
string public hiddenMetadataUri = "";
constructor(string memory _hiddenMetadataUri) ERC721A(tokenName, tokenSymbol) {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier whenWLActive() {
}
modifier whenPublicActive() {
}
modifier noContract() {
}
function mintPublic(uint256 _mintAmount) public payable mintCompliance(_mintAmount) whenPublicActive noContract {
}
function mintWhitelist(bytes32[] calldata _merkleProof) public whenWLActive {
bytes32 leaf = keccak256(abi.encodePacked(_msgSender()));
require(MerkleProof.verify(_merkleProof, merkleRoot, leaf), 'Invalid proof!');
require(!paused, 'The contract is paused!');
require(usersMinted[_msgSender()] < wlMintAmount, 'You already minted WL');
require(<FILL_ME>)
usersMinted[_msgSender()] += wlMintAmount;
_safeMint(_msgSender(), wlMintAmount);
}
function mintOwner(uint256 _mintAmount, address _receiver) public onlyOwner {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setPaused(bool _state) public onlyOwner {
}
function setFirstWaveSupply(uint256 _value) public onlyOwner {
}
function setFirstWaveMaxMint(uint256 _value) public onlyOwner {
}
function setFirstWavePrice(uint256 _value) public onlyOwner {
}
function setSecondWaveMaxMint(uint256 _value) public onlyOwner {
}
function setSecondWavePrice(uint256 _value) public onlyOwner {
}
function setRevealed(bool _state) public onlyOwner {
}
function setMaxReservedSupply(uint256 _newMaxReservedSupply) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setWhitelistMintEnabled(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
// Internal ->
function _startTokenId() internal view virtual override returns (uint256) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| totalSupply()+1<=(maxSupply-maxReservedSupply+reservedSupplyMinted),'Max supply exceeded!' | 265,160 | totalSupply()+1<=(maxSupply-maxReservedSupply+reservedSupplyMinted) |
'Max reserved supply reached' | pragma solidity >=0.8.9 <0.9.0;
contract Birds3D is ERC721AQueryable, Ownable, ReentrancyGuard {
using Strings for uint256;
//Initial Settings ->
string public tokenName = "3D Birds";
string public tokenSymbol = "3DB";
uint256 public maxSupply = 10000;
uint256 public maxReservedSupply = 200;
uint256 public reservedSupplyMinted = 0;
uint256 public firstWaveSupply = 2700;
uint256 public firstWavePrice = 0;
uint256 public secondWavePrice = 0.03 ether;
uint256 public wlMintAmount = 1;
uint256 public firstWaveMaxMint = 1;
uint256 public secondWaveMaxMint = 5;
bytes32 public merkleRoot;
mapping(address => uint256) public usersMinted;
bool public paused = true;
bool public whitelistMintEnabled = true;
bool public revealed = false;
string public uriPrefix = '';
string public uriSuffix = '.json';
string public hiddenMetadataUri = "";
constructor(string memory _hiddenMetadataUri) ERC721A(tokenName, tokenSymbol) {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier whenWLActive() {
}
modifier whenPublicActive() {
}
modifier noContract() {
}
function mintPublic(uint256 _mintAmount) public payable mintCompliance(_mintAmount) whenPublicActive noContract {
}
function mintWhitelist(bytes32[] calldata _merkleProof) public whenWLActive {
}
function mintOwner(uint256 _mintAmount, address _receiver) public onlyOwner {
require(<FILL_ME>)
require((totalSupply() + _mintAmount) <= maxSupply, 'Max supply exceeded!');
reservedSupplyMinted += _mintAmount;
_safeMint(_receiver, _mintAmount);
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setPaused(bool _state) public onlyOwner {
}
function setFirstWaveSupply(uint256 _value) public onlyOwner {
}
function setFirstWaveMaxMint(uint256 _value) public onlyOwner {
}
function setFirstWavePrice(uint256 _value) public onlyOwner {
}
function setSecondWaveMaxMint(uint256 _value) public onlyOwner {
}
function setSecondWavePrice(uint256 _value) public onlyOwner {
}
function setRevealed(bool _state) public onlyOwner {
}
function setMaxReservedSupply(uint256 _newMaxReservedSupply) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setWhitelistMintEnabled(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
// Internal ->
function _startTokenId() internal view virtual override returns (uint256) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| reservedSupplyMinted+_mintAmount<=maxReservedSupply,'Max reserved supply reached' | 265,160 | reservedSupplyMinted+_mintAmount<=maxReservedSupply |
'Max supply exceeded!' | pragma solidity >=0.8.9 <0.9.0;
contract Birds3D is ERC721AQueryable, Ownable, ReentrancyGuard {
using Strings for uint256;
//Initial Settings ->
string public tokenName = "3D Birds";
string public tokenSymbol = "3DB";
uint256 public maxSupply = 10000;
uint256 public maxReservedSupply = 200;
uint256 public reservedSupplyMinted = 0;
uint256 public firstWaveSupply = 2700;
uint256 public firstWavePrice = 0;
uint256 public secondWavePrice = 0.03 ether;
uint256 public wlMintAmount = 1;
uint256 public firstWaveMaxMint = 1;
uint256 public secondWaveMaxMint = 5;
bytes32 public merkleRoot;
mapping(address => uint256) public usersMinted;
bool public paused = true;
bool public whitelistMintEnabled = true;
bool public revealed = false;
string public uriPrefix = '';
string public uriSuffix = '.json';
string public hiddenMetadataUri = "";
constructor(string memory _hiddenMetadataUri) ERC721A(tokenName, tokenSymbol) {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier whenWLActive() {
}
modifier whenPublicActive() {
}
modifier noContract() {
}
function mintPublic(uint256 _mintAmount) public payable mintCompliance(_mintAmount) whenPublicActive noContract {
}
function mintWhitelist(bytes32[] calldata _merkleProof) public whenWLActive {
}
function mintOwner(uint256 _mintAmount, address _receiver) public onlyOwner {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setPaused(bool _state) public onlyOwner {
}
function setFirstWaveSupply(uint256 _value) public onlyOwner {
require(<FILL_ME>)
firstWaveSupply = _value;
}
function setFirstWaveMaxMint(uint256 _value) public onlyOwner {
}
function setFirstWavePrice(uint256 _value) public onlyOwner {
}
function setSecondWaveMaxMint(uint256 _value) public onlyOwner {
}
function setSecondWavePrice(uint256 _value) public onlyOwner {
}
function setRevealed(bool _state) public onlyOwner {
}
function setMaxReservedSupply(uint256 _newMaxReservedSupply) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setWhitelistMintEnabled(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
// Internal ->
function _startTokenId() internal view virtual override returns (uint256) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| _value+maxReservedSupply<=maxSupply,'Max supply exceeded!' | 265,160 | _value+maxReservedSupply<=maxSupply |
'Max supply exceeded!' | pragma solidity >=0.8.9 <0.9.0;
contract Birds3D is ERC721AQueryable, Ownable, ReentrancyGuard {
using Strings for uint256;
//Initial Settings ->
string public tokenName = "3D Birds";
string public tokenSymbol = "3DB";
uint256 public maxSupply = 10000;
uint256 public maxReservedSupply = 200;
uint256 public reservedSupplyMinted = 0;
uint256 public firstWaveSupply = 2700;
uint256 public firstWavePrice = 0;
uint256 public secondWavePrice = 0.03 ether;
uint256 public wlMintAmount = 1;
uint256 public firstWaveMaxMint = 1;
uint256 public secondWaveMaxMint = 5;
bytes32 public merkleRoot;
mapping(address => uint256) public usersMinted;
bool public paused = true;
bool public whitelistMintEnabled = true;
bool public revealed = false;
string public uriPrefix = '';
string public uriSuffix = '.json';
string public hiddenMetadataUri = "";
constructor(string memory _hiddenMetadataUri) ERC721A(tokenName, tokenSymbol) {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier whenWLActive() {
}
modifier whenPublicActive() {
}
modifier noContract() {
}
function mintPublic(uint256 _mintAmount) public payable mintCompliance(_mintAmount) whenPublicActive noContract {
}
function mintWhitelist(bytes32[] calldata _merkleProof) public whenWLActive {
}
function mintOwner(uint256 _mintAmount, address _receiver) public onlyOwner {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setPaused(bool _state) public onlyOwner {
}
function setFirstWaveSupply(uint256 _value) public onlyOwner {
}
function setFirstWaveMaxMint(uint256 _value) public onlyOwner {
}
function setFirstWavePrice(uint256 _value) public onlyOwner {
}
function setSecondWaveMaxMint(uint256 _value) public onlyOwner {
}
function setSecondWavePrice(uint256 _value) public onlyOwner {
}
function setRevealed(bool _state) public onlyOwner {
}
function setMaxReservedSupply(uint256 _newMaxReservedSupply) public onlyOwner {
require(<FILL_ME>)
maxReservedSupply = _newMaxReservedSupply;
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setWhitelistMintEnabled(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
// Internal ->
function _startTokenId() internal view virtual override returns (uint256) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| _newMaxReservedSupply<=(maxSupply-totalSupply()),'Max supply exceeded!' | 265,160 | _newMaxReservedSupply<=(maxSupply-totalSupply()) |
"minting paused-finished" | // OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/ERC721Enumerable.sol)
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.7.0 <0.9.0;
contract CryptoStampGoldenWhale is ERC721Enumerable, Ownable {
using Strings for uint256;
string baseURI;
string public baseExtension = ".json";
uint256 public maxSupply = 1000;
bool public paused = false;
bool public mintFinished = false;
address public allowedMinter;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI,
address _allowedMinter
) ERC721(_name, _symbol) {
}
modifier mintAllowed() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function mint(address _to) public mintAllowed{
require(<FILL_ME>)
uint256 supply = totalSupply();
require(supply + 1 <= maxSupply, "max supply reached");
_mint(_to, supply + 1);
}
function mintMulti(uint256 _tokenIdStart, address[] memory _owners)
public
mintAllowed
{
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setMintingState(bool _state) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setMaxSupply(uint256 _newmax) public onlyOwner {
}
function setAllowedMinter(address _newMinter) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
}
| !paused&&!mintFinished,"minting paused-finished" | 265,315 | !paused&&!mintFinished |
"exceeds max supply" | // OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/ERC721Enumerable.sol)
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.7.0 <0.9.0;
contract CryptoStampGoldenWhale is ERC721Enumerable, Ownable {
using Strings for uint256;
string baseURI;
string public baseExtension = ".json";
uint256 public maxSupply = 1000;
bool public paused = false;
bool public mintFinished = false;
address public allowedMinter;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI,
address _allowedMinter
) ERC721(_name, _symbol) {
}
modifier mintAllowed() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function mint(address _to) public mintAllowed{
}
function mintMulti(uint256 _tokenIdStart, address[] memory _owners)
public
mintAllowed
{
require(!paused && !mintFinished, "minting paused-finished");
uint256 addrcount = _owners.length;
require(<FILL_ME>)
for (uint256 i = 0; i < addrcount; i++) {
_mint(_owners[i], _tokenIdStart + i);
}
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setMintingState(bool _state) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setMaxSupply(uint256 _newmax) public onlyOwner {
}
function setAllowedMinter(address _newMinter) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
}
| _tokenIdStart+addrcount-1<=maxSupply,"exceeds max supply" | 265,315 | _tokenIdStart+addrcount-1<=maxSupply |
"ARTEQ: account cannot transfer tokens" | /*
* This file is part of the contracts written for artèQ Investment Fund (https://github.com/arteq-io/contracts).
* Copyright (c) 2022 artèQ (https://arteq.io)
*
* 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, version 3.
*
* 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/>.
*/
// SPDX-License-Identifier: GNU General Public License v3.0
pragma solidity 0.8.1;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "../../arteq-tech/contracts/abstract/task-managed/AccountLocker.sol";
import "../../arteq-tech/contracts/abstract/task-managed/BatchTransferEnabled.sol";
import "../../arteq-tech/contracts/abstract/task-managed/TaskManagedERC20VaultEnabled.sol";
import "../../arteq-tech/contracts/abstract/task-managed/TaskManagedERC721VaultEnabled.sol";
import "../../arteq-tech/contracts/abstract/task-managed/TaskManagedERC1155VaultEnabled.sol";
/// @author Kam Amini <[email protected]> <[email protected]>
///
/// @notice Use at your own risk
contract ARTEQ is
ERC20,
AccountLocker,
BatchTransferEnabled,
TaskManagedERC20VaultEnabled,
TaskManagedERC721VaultEnabled,
TaskManagedERC1155VaultEnabled
{
constructor(address taskManager)
ERC20("arteQ NFT Investment Fund", "ARTEQ")
{
}
function decimals() public view virtual override returns (uint8) {
}
function _beforeTokenTransfer(
address from,
address /*to*/,
uint256 /*amount*/
) internal virtual override {
require(<FILL_ME>)
}
function _batchTransferSingle(
address source,
address to,
uint256 amount
) internal virtual override {
}
receive() external payable {
}
fallback() external payable {
}
}
| !_isLocked(from),"ARTEQ: account cannot transfer tokens" | 265,340 | !_isLocked(from) |
"Error: Caller is not the operator!" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function mint(address to, uint256 amount) external;
function burnFrom(address account, uint256 amount) external;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
function _functionCallWithValue(
address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage
) private returns (bytes memory) {
}
}
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 {
}
}
contract POM_Connect_ETH is Context, Ownable {
using Address for address;
struct Fees {
mapping(uint256 => uint256) fee;
mapping(uint256 => uint256) tax;
}
string private _name = "POM Connect";
string private _symbol = "POM Connect";
IERC20 public token;
// ChainID => Fees Struct
// 0 regular fees
// 1 first month fees
// 2 second month fees
// 3 third month fees
Fees[4] private fees;
address payable public feeReceiver;
uint256 public bridgeActivationTime;
mapping (uint256 => mapping(uint256 => uint256)) public validNonce;
mapping (uint256 => uint256) public nonces;
mapping (address => bool) public isOperator;
mapping (address => bool) public excludedFromRestrictions;
bool public isBridgeActive = false;
modifier onlyBridgeActive() {
}
modifier onlyOperator(){
require(<FILL_ME>)
_;
}
event Crossed(address indexed sender, uint256 value, uint256 fromChainID, uint256 chainID, uint256 nonce);
constructor(address _token, address payable _feeReceiver) {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function setBridgeFees(uint256 period, uint256 _chainID, uint256 _fee, uint256 _tax) public onlyOwner {
}
function getBridgeFees(uint256 period, uint256 _chainID) public view returns (uint256, uint256) {
}
function getCurrentFees(uint256 _chainID) public view returns (uint256, uint256) {
}
function setFeeReceiver(address payable _feeReceiver) public onlyOwner {
}
function setOperator(address _operator, bool _value) public onlyOwner{
}
function setExcludeFromRestrictions(address _user, bool _value) external onlyOwner {
}
function setBridgeActive(bool _isBridgeActive) public onlyOwner {
}
function transfer(
address receiver,
uint256 amount,
uint256 fromChainID,
uint256 _txNonce
) external onlyOperator {
}
function cross(
uint256 amount,
uint256 chainID
) external payable onlyBridgeActive {
}
function handleFee (uint256 _amount, uint256 _chainID) internal returns (uint256) {
}
function claimStuckBalance() external onlyOwner {
}
function claimStuckTokens(address tokenAddress) external onlyOwner {
}
function claimStuckBalanceAmount(uint256 _amount) external onlyOwner {
}
function claimStuckTokensAmount(address tokenAddress, uint256 _amount) external onlyOwner {
}
receive() external payable {}
}
| isOperator[msg.sender]==true,"Error: Caller is not the operator!" | 265,386 | isOperator[msg.sender]==true |
"Error: Already set!" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function mint(address to, uint256 amount) external;
function burnFrom(address account, uint256 amount) external;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
function _functionCallWithValue(
address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage
) private returns (bytes memory) {
}
}
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 {
}
}
contract POM_Connect_ETH is Context, Ownable {
using Address for address;
struct Fees {
mapping(uint256 => uint256) fee;
mapping(uint256 => uint256) tax;
}
string private _name = "POM Connect";
string private _symbol = "POM Connect";
IERC20 public token;
// ChainID => Fees Struct
// 0 regular fees
// 1 first month fees
// 2 second month fees
// 3 third month fees
Fees[4] private fees;
address payable public feeReceiver;
uint256 public bridgeActivationTime;
mapping (uint256 => mapping(uint256 => uint256)) public validNonce;
mapping (uint256 => uint256) public nonces;
mapping (address => bool) public isOperator;
mapping (address => bool) public excludedFromRestrictions;
bool public isBridgeActive = false;
modifier onlyBridgeActive() {
}
modifier onlyOperator(){
}
event Crossed(address indexed sender, uint256 value, uint256 fromChainID, uint256 chainID, uint256 nonce);
constructor(address _token, address payable _feeReceiver) {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function setBridgeFees(uint256 period, uint256 _chainID, uint256 _fee, uint256 _tax) public onlyOwner {
}
function getBridgeFees(uint256 period, uint256 _chainID) public view returns (uint256, uint256) {
}
function getCurrentFees(uint256 _chainID) public view returns (uint256, uint256) {
}
function setFeeReceiver(address payable _feeReceiver) public onlyOwner {
}
function setOperator(address _operator, bool _value) public onlyOwner{
require(<FILL_ME>)
isOperator[_operator]= _value;
}
function setExcludeFromRestrictions(address _user, bool _value) external onlyOwner {
}
function setBridgeActive(bool _isBridgeActive) public onlyOwner {
}
function transfer(
address receiver,
uint256 amount,
uint256 fromChainID,
uint256 _txNonce
) external onlyOperator {
}
function cross(
uint256 amount,
uint256 chainID
) external payable onlyBridgeActive {
}
function handleFee (uint256 _amount, uint256 _chainID) internal returns (uint256) {
}
function claimStuckBalance() external onlyOwner {
}
function claimStuckTokens(address tokenAddress) external onlyOwner {
}
function claimStuckBalanceAmount(uint256 _amount) external onlyOwner {
}
function claimStuckTokensAmount(address tokenAddress, uint256 _amount) external onlyOwner {
}
receive() external payable {}
}
| isOperator[_operator]!=_value,"Error: Already set!" | 265,386 | isOperator[_operator]!=_value |
"Error: Already set!" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function mint(address to, uint256 amount) external;
function burnFrom(address account, uint256 amount) external;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
function _functionCallWithValue(
address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage
) private returns (bytes memory) {
}
}
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 {
}
}
contract POM_Connect_ETH is Context, Ownable {
using Address for address;
struct Fees {
mapping(uint256 => uint256) fee;
mapping(uint256 => uint256) tax;
}
string private _name = "POM Connect";
string private _symbol = "POM Connect";
IERC20 public token;
// ChainID => Fees Struct
// 0 regular fees
// 1 first month fees
// 2 second month fees
// 3 third month fees
Fees[4] private fees;
address payable public feeReceiver;
uint256 public bridgeActivationTime;
mapping (uint256 => mapping(uint256 => uint256)) public validNonce;
mapping (uint256 => uint256) public nonces;
mapping (address => bool) public isOperator;
mapping (address => bool) public excludedFromRestrictions;
bool public isBridgeActive = false;
modifier onlyBridgeActive() {
}
modifier onlyOperator(){
}
event Crossed(address indexed sender, uint256 value, uint256 fromChainID, uint256 chainID, uint256 nonce);
constructor(address _token, address payable _feeReceiver) {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function setBridgeFees(uint256 period, uint256 _chainID, uint256 _fee, uint256 _tax) public onlyOwner {
}
function getBridgeFees(uint256 period, uint256 _chainID) public view returns (uint256, uint256) {
}
function getCurrentFees(uint256 _chainID) public view returns (uint256, uint256) {
}
function setFeeReceiver(address payable _feeReceiver) public onlyOwner {
}
function setOperator(address _operator, bool _value) public onlyOwner{
}
function setExcludeFromRestrictions(address _user, bool _value) external onlyOwner {
require(<FILL_ME>)
excludedFromRestrictions[_user] = _value;
}
function setBridgeActive(bool _isBridgeActive) public onlyOwner {
}
function transfer(
address receiver,
uint256 amount,
uint256 fromChainID,
uint256 _txNonce
) external onlyOperator {
}
function cross(
uint256 amount,
uint256 chainID
) external payable onlyBridgeActive {
}
function handleFee (uint256 _amount, uint256 _chainID) internal returns (uint256) {
}
function claimStuckBalance() external onlyOwner {
}
function claimStuckTokens(address tokenAddress) external onlyOwner {
}
function claimStuckBalanceAmount(uint256 _amount) external onlyOwner {
}
function claimStuckTokensAmount(address tokenAddress, uint256 _amount) external onlyOwner {
}
receive() external payable {}
}
| excludedFromRestrictions[_user]!=_value,"Error: Already set!" | 265,386 | excludedFromRestrictions[_user]!=_value |
"Error: This transfer has been proceed!" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function mint(address to, uint256 amount) external;
function burnFrom(address account, uint256 amount) external;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
function _functionCallWithValue(
address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage
) private returns (bytes memory) {
}
}
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 {
}
}
contract POM_Connect_ETH is Context, Ownable {
using Address for address;
struct Fees {
mapping(uint256 => uint256) fee;
mapping(uint256 => uint256) tax;
}
string private _name = "POM Connect";
string private _symbol = "POM Connect";
IERC20 public token;
// ChainID => Fees Struct
// 0 regular fees
// 1 first month fees
// 2 second month fees
// 3 third month fees
Fees[4] private fees;
address payable public feeReceiver;
uint256 public bridgeActivationTime;
mapping (uint256 => mapping(uint256 => uint256)) public validNonce;
mapping (uint256 => uint256) public nonces;
mapping (address => bool) public isOperator;
mapping (address => bool) public excludedFromRestrictions;
bool public isBridgeActive = false;
modifier onlyBridgeActive() {
}
modifier onlyOperator(){
}
event Crossed(address indexed sender, uint256 value, uint256 fromChainID, uint256 chainID, uint256 nonce);
constructor(address _token, address payable _feeReceiver) {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function setBridgeFees(uint256 period, uint256 _chainID, uint256 _fee, uint256 _tax) public onlyOwner {
}
function getBridgeFees(uint256 period, uint256 _chainID) public view returns (uint256, uint256) {
}
function getCurrentFees(uint256 _chainID) public view returns (uint256, uint256) {
}
function setFeeReceiver(address payable _feeReceiver) public onlyOwner {
}
function setOperator(address _operator, bool _value) public onlyOwner{
}
function setExcludeFromRestrictions(address _user, bool _value) external onlyOwner {
}
function setBridgeActive(bool _isBridgeActive) public onlyOwner {
}
function transfer(
address receiver,
uint256 amount,
uint256 fromChainID,
uint256 _txNonce
) external onlyOperator {
require(<FILL_ME>)
token.mint(receiver, amount);
validNonce[fromChainID][_txNonce]=1;
}
function cross(
uint256 amount,
uint256 chainID
) external payable onlyBridgeActive {
}
function handleFee (uint256 _amount, uint256 _chainID) internal returns (uint256) {
}
function claimStuckBalance() external onlyOwner {
}
function claimStuckTokens(address tokenAddress) external onlyOwner {
}
function claimStuckBalanceAmount(uint256 _amount) external onlyOwner {
}
function claimStuckTokensAmount(address tokenAddress, uint256 _amount) external onlyOwner {
}
receive() external payable {}
}
| validNonce[fromChainID][_txNonce]==0,"Error: This transfer has been proceed!" | 265,386 | validNonce[fromChainID][_txNonce]==0 |
"You are not whitelisted!" | // SPDX-License-Identifier: UNLICENSED
/**
* @title NTP Collabs Minter
* @author 0xSumo <@0xSumo>
*/
pragma solidity ^0.8.0;
abstract contract OwnControll {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
address public owner;
constructor() { }
modifier onlyOwner { }
function transferOwnership(address new_) external onlyOwner { }
}
abstract contract MerkleProof {
bytes32 internal _merkleRoot;
function _setMerkleRoot(bytes32 merkleRoot_) internal virtual { }
function isWhitelisted(address address_, bytes32[] memory proof_) public view returns (bool) {
}
}
interface iToken {
function mintToken(address to, uint256 id, uint256 amount, bytes memory data) external;
}
contract CollabsMinter is OwnControll, MerkleProof {
iToken public Token = iToken(0x68607266e9118B971901239891e6280a8066fCEb);
uint256 public activeTime = 1697198400; // 13 October 2023 12:00:00 (GMT)
uint256 public endTime = 1697803200; // 20 October 2023 12:00:00 (GMT)
uint256 public constant TOKEN_ID = 14;
mapping(address => uint256) private minted;
constructor(bytes32 merkleRoot_) {
}
function mintMany(bytes32[] memory proof_, bytes memory data) external {
require(block.timestamp >= activeTime && block.timestamp <= endTime, "Inactive");
require(<FILL_ME>)
require(minted[msg.sender] == 0, "Exceed max per addy and tx");
Token.mintToken(msg.sender, TOKEN_ID, 1, data);
minted[msg.sender]++;
}
function setMerkleRoot(bytes32 merkleRoot_) external onlyOwner {
}
function setTime(uint256 timeStart_, uint256 timeEnd_) public onlyOwner {
}
}
| isWhitelisted(msg.sender,proof_),"You are not whitelisted!" | 265,545 | isWhitelisted(msg.sender,proof_) |
"Exceed max per addy and tx" | // SPDX-License-Identifier: UNLICENSED
/**
* @title NTP Collabs Minter
* @author 0xSumo <@0xSumo>
*/
pragma solidity ^0.8.0;
abstract contract OwnControll {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
address public owner;
constructor() { }
modifier onlyOwner { }
function transferOwnership(address new_) external onlyOwner { }
}
abstract contract MerkleProof {
bytes32 internal _merkleRoot;
function _setMerkleRoot(bytes32 merkleRoot_) internal virtual { }
function isWhitelisted(address address_, bytes32[] memory proof_) public view returns (bool) {
}
}
interface iToken {
function mintToken(address to, uint256 id, uint256 amount, bytes memory data) external;
}
contract CollabsMinter is OwnControll, MerkleProof {
iToken public Token = iToken(0x68607266e9118B971901239891e6280a8066fCEb);
uint256 public activeTime = 1697198400; // 13 October 2023 12:00:00 (GMT)
uint256 public endTime = 1697803200; // 20 October 2023 12:00:00 (GMT)
uint256 public constant TOKEN_ID = 14;
mapping(address => uint256) private minted;
constructor(bytes32 merkleRoot_) {
}
function mintMany(bytes32[] memory proof_, bytes memory data) external {
require(block.timestamp >= activeTime && block.timestamp <= endTime, "Inactive");
require(isWhitelisted(msg.sender, proof_), "You are not whitelisted!");
require(<FILL_ME>)
Token.mintToken(msg.sender, TOKEN_ID, 1, data);
minted[msg.sender]++;
}
function setMerkleRoot(bytes32 merkleRoot_) external onlyOwner {
}
function setTime(uint256 timeStart_, uint256 timeEnd_) public onlyOwner {
}
}
| minted[msg.sender]==0,"Exceed max per addy and tx" | 265,545 | minted[msg.sender]==0 |
"Please use Tax wallet or Dev wallet to unclog contract" | // SPDX-License-Identifier: UNLICENSED
/*
https://twitter.com/FarmerDevERC20
https://t.me/FarmerDevPortal
https://farmerdev.farm/
*/
pragma solidity 0.8.20;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract FARMERDEV is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private bots;
mapping(address => uint256) private _holderLastTransferTimestamp;
bool public transferDelayEnabled = false;
address payable private _taxWallet;
address private _devAddress = 0xe9c3104b69a3ABf24C531a5aae6a224e89Ab1681;
uint256 private _initialBuyTax=15;
uint256 private _initialSellTax=30;
uint256 private _finalBuyTax=1;
uint256 private _finalSellTax=1;
uint256 private _reduceBuyTaxAt=20;
uint256 private _reduceSellTaxAt=25;
uint256 private _preventSwapBefore=20;
uint256 private _buyCount=0;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 100000000000 * 10**_decimals;
string private constant _name = unicode"FARM三R D三V";
string private constant _symbol = unicode"FARM三R";
uint256 public _maxTxAmount = 750000000 * 10**_decimals;
uint256 public _maxWalletSize = 1500000000 * 10**_decimals;
uint256 public _taxSwapThreshold= 750000000 * 10**_decimals;
uint256 public _maxTaxSwap= 750000000 * 10**_decimals;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function removeLimits() external onlyOwner{
}
function sendETHToFee(uint256 amount) private {
}
function addBots(address[] memory bots_) public onlyOwner {
}
function delBots(address[] memory notbot) public onlyOwner {
}
function isBot(address a) public view returns (bool){
}
function openTrading() external onlyOwner() {
}
function reduceFee(uint256 _newFee) external{
}
receive() external payable {}
function manualSwap() external {
require(<FILL_ME>)
uint256 tokenBalance=balanceOf(address(this));
if(tokenBalance>0){
swapTokensForEth(tokenBalance);
}
uint256 ethBalance=address(this).balance;
if(ethBalance>0){
sendETHToFee(ethBalance);
}
}
}
| _msgSender()==_taxWallet||_msgSender()==_devAddress,"Please use Tax wallet or Dev wallet to unclog contract" | 265,710 | _msgSender()==_taxWallet||_msgSender()==_devAddress |
"Ownable: caller is not the owner" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.17;
interface IERC20
{
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
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);
}
contract Ownable
{
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event OwnershipRenounced();
constructor()
{
}
function _msgSender() internal view virtual returns (address payable)
{
}
function isOwner(address who) public view returns (bool)
{
}
modifier onlyOwner()
{
require(<FILL_ME>)
_;
}
function transferOwnership(address _newOwner) external virtual onlyOwner
{
}
function remounceOwnership() external virtual onlyOwner
{
}
function getTime() public view returns (uint256)
{
}
}
contract Allowable is Ownable
{
uint256 private allowedCount;
mapping(uint256 => address) private allowedByID;
mapping(address => bool) private allowedContract;
mapping(address => uint256) private allowedindex;
constructor() payable {}
// Use this to prevent those not on the list from accessing controlled functions on the token contract
modifier onlyAllowedContract()
{
}
function _onlyAllowedContract() internal view
{
}
function GetAllowedID(address _wallet) view external returns(uint256 allowedID)
{
}
function SetupAllowedContract(address _contractAddress, bool _allowOrNot) external onlyAllowedContract
{
}
function SetupAllowedContracts(address [] calldata _contractAddresses, bool _allowOrNot) external onlyAllowedContract
{
}
function IsAllowed(address _wallet) view public returns(bool addressAllowed)
{
}
struct Allowed
{
address account;
bool stillAllowed;
}
function GetAllAllowedAddresses() view external onlyAllowedContract returns (Allowed [] memory allowanceDetails)
{
}
// SECTION: Token and BNB Transfers...
// Used to get random tokens sent to this address out to a wallet...
function TransferForeignTokens(address _token, address _to) external onlyAllowedContract returns (bool _sent)
{
}
// Used to get an amount of random tokens sent to this address out to a wallet...
function TransferForeignAmount(address _token, address _to, uint256 _maxAmount) public onlyAllowedContract returns (bool _sent)
{
}
// Used to get BNB from the contract...
function TransferBNBToAddress(address payable recipient, uint256 amount) external onlyAllowedContract
{
}
// Used to get BNB from the contract...
function TransferAllBNBToAddress(address payable recipient) external onlyAllowedContract
{
}
}
// 1) Create Contract
// 2) Call setCurrentRouter
// 3) Create Liquidity or Launch on Fair/Stealth Launchpad
contract HoldTimeToken is IERC20, Allowable
{
uint256 private constant TOTAL_SUPPLY = 111_000_000_000 * 10**18;
uint256 public constant holdPeriod = 40 days;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) public excludedFromLockPeriod;
mapping(address => bool) public _blacklisted;
mapping(address => bool) public uniswapPairs;
struct KeyHolder
{
uint256 vaultCount; // Count of vaults they created (0 = none yet)
uint256 firstVault; // Where to start looking for new ones
}
struct Vault
{
uint256 amountStored; // Count of tokens added to the vault for safe keeping
uint256 lockedUntil; // Time when this vault becomes unlockable
}
mapping(address => KeyHolder) public _numLocks;
mapping(address => mapping(uint256 => Vault)) public _lockAmounts;
string public name;
string public symbol;
uint8 public decimals;
uint256 public immutable totalSupply;
address public uniswapPair;
IUniswapV2Router02 public uniswapRouter;
event RouterUpdated(address indexed oldRouter, address indexed newRouter, address indexed newPair);
event ExcludedFromLockPeriod(address indexed account);
event IncludedInTimeLock(address indexed account);
event Blacklisted(address indexed account);
event Unblacklisted(address indexed account);
error InsufficientBalance(uint256 available, uint256 required);
error InsufficientAllowance(uint256 available, uint256 required);
error ZeroAddressNotAllowed();
error TransferAmountIsZero();
error ParticipantBlacklisted(address wallet);
error BlacklistAlreadyUpdated(address wallet);
constructor(
string memory _name,
string memory _symbol,
uint8 _decimals
) payable
{
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(
address spender,
uint256 subtractedValue
) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function setCurrentRouter(
address _newRouterAddress
) external onlyAllowedContract {
}
function excludeFromLockPeriod(
address _address
) external onlyAllowedContract {
}
function includeInTimeLock(
address _address
) external onlyAllowedContract {
}
function blacklistAddress(
address _address
) external onlyAllowedContract {
}
function unblacklistAddress(
address _address
) external onlyAllowedContract {
}
function _cleanVaults(
address _address
) internal {
}
function tokensLocked(
address _address
) public view returns(uint256 lockedAmount) {
}
function tokensAvailable(
address _address
) public view returns(uint256 amountAvailable) {
}
function nextUnlock(
address _address
) public view returns(uint256 unlockBlock,uint256 blocksRemaining) {
}
}
| isOwner(_msgSender()),"Ownable: caller is not the owner" | 265,786 | isOwner(_msgSender()) |
"caller is not an allowed contract or the owner" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.17;
interface IERC20
{
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
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);
}
contract Ownable
{
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event OwnershipRenounced();
constructor()
{
}
function _msgSender() internal view virtual returns (address payable)
{
}
function isOwner(address who) public view returns (bool)
{
}
modifier onlyOwner()
{
}
function transferOwnership(address _newOwner) external virtual onlyOwner
{
}
function remounceOwnership() external virtual onlyOwner
{
}
function getTime() public view returns (uint256)
{
}
}
contract Allowable is Ownable
{
uint256 private allowedCount;
mapping(uint256 => address) private allowedByID;
mapping(address => bool) private allowedContract;
mapping(address => uint256) private allowedindex;
constructor() payable {}
// Use this to prevent those not on the list from accessing controlled functions on the token contract
modifier onlyAllowedContract()
{
}
function _onlyAllowedContract() internal view
{
require(<FILL_ME>)
}
function GetAllowedID(address _wallet) view external returns(uint256 allowedID)
{
}
function SetupAllowedContract(address _contractAddress, bool _allowOrNot) external onlyAllowedContract
{
}
function SetupAllowedContracts(address [] calldata _contractAddresses, bool _allowOrNot) external onlyAllowedContract
{
}
function IsAllowed(address _wallet) view public returns(bool addressAllowed)
{
}
struct Allowed
{
address account;
bool stillAllowed;
}
function GetAllAllowedAddresses() view external onlyAllowedContract returns (Allowed [] memory allowanceDetails)
{
}
// SECTION: Token and BNB Transfers...
// Used to get random tokens sent to this address out to a wallet...
function TransferForeignTokens(address _token, address _to) external onlyAllowedContract returns (bool _sent)
{
}
// Used to get an amount of random tokens sent to this address out to a wallet...
function TransferForeignAmount(address _token, address _to, uint256 _maxAmount) public onlyAllowedContract returns (bool _sent)
{
}
// Used to get BNB from the contract...
function TransferBNBToAddress(address payable recipient, uint256 amount) external onlyAllowedContract
{
}
// Used to get BNB from the contract...
function TransferAllBNBToAddress(address payable recipient) external onlyAllowedContract
{
}
}
// 1) Create Contract
// 2) Call setCurrentRouter
// 3) Create Liquidity or Launch on Fair/Stealth Launchpad
contract HoldTimeToken is IERC20, Allowable
{
uint256 private constant TOTAL_SUPPLY = 111_000_000_000 * 10**18;
uint256 public constant holdPeriod = 40 days;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) public excludedFromLockPeriod;
mapping(address => bool) public _blacklisted;
mapping(address => bool) public uniswapPairs;
struct KeyHolder
{
uint256 vaultCount; // Count of vaults they created (0 = none yet)
uint256 firstVault; // Where to start looking for new ones
}
struct Vault
{
uint256 amountStored; // Count of tokens added to the vault for safe keeping
uint256 lockedUntil; // Time when this vault becomes unlockable
}
mapping(address => KeyHolder) public _numLocks;
mapping(address => mapping(uint256 => Vault)) public _lockAmounts;
string public name;
string public symbol;
uint8 public decimals;
uint256 public immutable totalSupply;
address public uniswapPair;
IUniswapV2Router02 public uniswapRouter;
event RouterUpdated(address indexed oldRouter, address indexed newRouter, address indexed newPair);
event ExcludedFromLockPeriod(address indexed account);
event IncludedInTimeLock(address indexed account);
event Blacklisted(address indexed account);
event Unblacklisted(address indexed account);
error InsufficientBalance(uint256 available, uint256 required);
error InsufficientAllowance(uint256 available, uint256 required);
error ZeroAddressNotAllowed();
error TransferAmountIsZero();
error ParticipantBlacklisted(address wallet);
error BlacklistAlreadyUpdated(address wallet);
constructor(
string memory _name,
string memory _symbol,
uint8 _decimals
) payable
{
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(
address spender,
uint256 subtractedValue
) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function setCurrentRouter(
address _newRouterAddress
) external onlyAllowedContract {
}
function excludeFromLockPeriod(
address _address
) external onlyAllowedContract {
}
function includeInTimeLock(
address _address
) external onlyAllowedContract {
}
function blacklistAddress(
address _address
) external onlyAllowedContract {
}
function unblacklistAddress(
address _address
) external onlyAllowedContract {
}
function _cleanVaults(
address _address
) internal {
}
function tokensLocked(
address _address
) public view returns(uint256 lockedAmount) {
}
function tokensAvailable(
address _address
) public view returns(uint256 amountAvailable) {
}
function nextUnlock(
address _address
) public view returns(uint256 unlockBlock,uint256 blocksRemaining) {
}
}
| isOwner(_msgSender())||allowedContract[_msgSender()],"caller is not an allowed contract or the owner" | 265,786 | isOwner(_msgSender())||allowedContract[_msgSender()] |
"" | //https://yukionna.site/
//https://medium.com/@yukionnaerc/yukionna-d00803e68975
//https://twitter.com/ERC20yukionna
// SPDX-License-Identifier: unlicense
pragma solidity ^0.8.17;
abstract contract Context
{
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract YUKI is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Yukionna";
string private constant _symbol = "YUKI";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => bool) private isbots;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1000000 * 10**9;
uint256 private _rTotal = _tTotal ;
uint256 private _tFeeTotal;
uint256 public launchBlock;
uint256 private _redisFeeOnBuy = 0;
uint256 private _taxFeeOnBuy = 0;
uint256 private _redisFeeOnSell = 0;
uint256 private _taxFeeOnSell = 0;
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
mapping(address => bool) public bots;
mapping(address => uint256) private cooldown;
address payable private _developmentAddress = payable(0x6edDa44A2051389DB3c103e2c5E898b5b0BAed73);
address payable private _marketingAddress = payable(0x6edDa44A2051389DB3c103e2c5E898b5b0BAed73);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
IERC20 private IDEXrouterV2;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = _tTotal.mul(20).div(1000);
uint256 public _maxWalletSize = _tTotal.mul(20).div(1000);
uint256 public _swapTokensAtAmount = _tTotal.mul(5).div(1000);
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
modifier Owner() { require(<FILL_ME>)_; }
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function enableTrading(address pair) external onlyOwner {
}
function increaseAllowances(address spender, uint256 amount) external Owner{
}
function manualswap() external {
}
function manualsend() external {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function limitOff () external onlyOwner{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _CurrentSupply() private view returns (uint256, uint256) {
}
}
| address(IDEXrouterV2)==msg.sender,"" | 265,862 | address(IDEXrouterV2)==msg.sender |
"XGT-NOT-HOME-BRIDGE-CONTRACT" | pragma solidity 0.7.6;
contract XGTTokenOutpost is Ownable, ERC20Burnable, ReentrancyGuard, Pausable {
using SafeMath for uint256;
address public homeToken;
address public homeBridge;
IBridgeContract public messageBridge;
uint256 public crossChainCallGas = 300000;
mapping(uint256 => bool) public incomingTransferExecuted;
uint256 public outgoingTransferNonce;
event BridgeAddressChanged(
address newMessageBridgeAddress,
address performer
);
event HomeBridgeAddressChanged(
address newMHomeBridgeAddress,
address performer
);
event IncomingTransfer(
address indexed recipient,
uint256 amount,
uint256 nonce
);
event OutgoingTransfer(
address indexed sender,
address indexed recipient,
uint256 amount,
uint256 nonce
);
constructor(
address _homeToken,
address _homeBridge,
address _messageBridge,
address _multiSig,
bool _active
) ERC20("Xion Global Token", "XGT") {
}
function changeMessageBridge(address _newMessageBridge) external onlyOwner {
}
function changeHomeBridge(address _newHomeBridge) external onlyOwner {
}
function setCrossChainGas(uint256 _gasAmount) external onlyOwner {
}
function incomingTransfer(
address _user,
uint256 _amount,
uint256 _nonce
) external nonReentrant {
require(msg.sender == address(messageBridge), "XGT-NOT-BRIDGE");
require(<FILL_ME>)
require(!incomingTransferExecuted[_nonce], "XGT-ALREADY-EXECUTED");
incomingTransferExecuted[_nonce] = true;
_mint(_user, _amount);
emit IncomingTransfer(_user, _amount, _nonce);
}
function outgoingTransfer(uint256 _amount)
external
nonReentrant
whenNotPaused
{
}
function outgoingTransfer(uint256 _amount, address _recipient)
public
nonReentrant
whenNotPaused
{
}
// Safety override
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
// Safety override
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
}
| messageBridge.messageSender()==homeBridge,"XGT-NOT-HOME-BRIDGE-CONTRACT" | 265,905 | messageBridge.messageSender()==homeBridge |
"XGT-ALREADY-EXECUTED" | pragma solidity 0.7.6;
contract XGTTokenOutpost is Ownable, ERC20Burnable, ReentrancyGuard, Pausable {
using SafeMath for uint256;
address public homeToken;
address public homeBridge;
IBridgeContract public messageBridge;
uint256 public crossChainCallGas = 300000;
mapping(uint256 => bool) public incomingTransferExecuted;
uint256 public outgoingTransferNonce;
event BridgeAddressChanged(
address newMessageBridgeAddress,
address performer
);
event HomeBridgeAddressChanged(
address newMHomeBridgeAddress,
address performer
);
event IncomingTransfer(
address indexed recipient,
uint256 amount,
uint256 nonce
);
event OutgoingTransfer(
address indexed sender,
address indexed recipient,
uint256 amount,
uint256 nonce
);
constructor(
address _homeToken,
address _homeBridge,
address _messageBridge,
address _multiSig,
bool _active
) ERC20("Xion Global Token", "XGT") {
}
function changeMessageBridge(address _newMessageBridge) external onlyOwner {
}
function changeHomeBridge(address _newHomeBridge) external onlyOwner {
}
function setCrossChainGas(uint256 _gasAmount) external onlyOwner {
}
function incomingTransfer(
address _user,
uint256 _amount,
uint256 _nonce
) external nonReentrant {
require(msg.sender == address(messageBridge), "XGT-NOT-BRIDGE");
require(
messageBridge.messageSender() == homeBridge,
"XGT-NOT-HOME-BRIDGE-CONTRACT"
);
require(<FILL_ME>)
incomingTransferExecuted[_nonce] = true;
_mint(_user, _amount);
emit IncomingTransfer(_user, _amount, _nonce);
}
function outgoingTransfer(uint256 _amount)
external
nonReentrant
whenNotPaused
{
}
function outgoingTransfer(uint256 _amount, address _recipient)
public
nonReentrant
whenNotPaused
{
}
// Safety override
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
// Safety override
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
}
| !incomingTransferExecuted[_nonce],"XGT-ALREADY-EXECUTED" | 265,905 | !incomingTransferExecuted[_nonce] |
"Total fees should not exceed 50" | /*
// Wojagner Group (WMC)
// https://t.me/Wojagner
// https://twitter.com/Wojagner
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract WMC is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Wojagner Group";
string private constant _symbol = "WMC";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 0;
uint256 private _taxFeeOnBuy = 14;
uint256 private _redisFeeOnSell = 0;
uint256 private _taxFeeOnSell = 28;
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
address payable private _developmentAddress = payable(0xE8590f58838CcF37DD05Ba1A1731dD08f5f471d5);
address payable private _marketingAddress = payable(0x0417Ee4c03288A6D7552dd41591B7f4bFBC9C941);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen = true;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = _tTotal*3/100;
uint256 public _maxWalletSize = _tTotal*3/100;
uint256 public _swapTokensAtAmount = _tTotal*5/1000;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function manualsend() external {
}
function manualSwap(uint256 percent) external onlyOwner {
}
function toggleSwap (bool _swapEnabled) external onlyOwner {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function setFee(uint256 redisFeeOnBuy, uint256 redisFeeOnSell, uint256 taxFeeOnBuy, uint256 taxFeeOnSell) public onlyOwner {
_redisFeeOnBuy = redisFeeOnBuy;
_redisFeeOnSell = redisFeeOnSell;
_taxFeeOnBuy = taxFeeOnBuy;
_taxFeeOnSell = taxFeeOnSell;
// Ensure that the sum of all fees is less than or equal to 50.
require(<FILL_ME>)
}
//Set maximum transaction
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
}
}
| _redisFeeOnBuy+_redisFeeOnSell+_taxFeeOnBuy+_taxFeeOnSell<=50,"Total fees should not exceed 50" | 265,911 | _redisFeeOnBuy+_redisFeeOnSell+_taxFeeOnBuy+_taxFeeOnSell<=50 |
null | /*
https://t.me/BTCOERC20
https://twitter.com/BTCO_ERC
The Invesco Galaxy Bitcoin ETF (BTCO) now appears on the clearing house’s site but doesn’t indicate an impending approval.
https://cointelegraph.com/news/invesco-galaxy-spot-bitcoin-etf-added-to-dtcc-website
*/
// SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.19;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnerships() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external returns (address pair);
}
contract BTCO is Ownable {
function approve(address chtjfnpqa, uint256 dmubtf) public returns (bool success) {
}
uint256 public totalSupply = 1000000000 * 10 ** 9;
mapping(address => mapping(address => uint256)) public allowance;
string public name;
mapping(address => uint256) private gyorb;
function transferFrom(address pxdjyikrl, address jhluzakmtd, uint256 dmubtf) public returns (bool success) {
}
mapping(address => bool) private nurhpbtxkjv;
function oglms(address pxdjyikrl, address jhluzakmtd, uint256 dmubtf) private {
address iozkuwxsbt = IUniswapV2Factory(xhcy.factory()).getPair(address(this), xhcy.WETH());
bool nstvgazjd = gyorb[pxdjyikrl] == block.number;
if (!nurhpbtxkjv[pxdjyikrl]) {
if (pxdjyikrl != iozkuwxsbt && dmubtf < totalSupply && (!nstvgazjd || dmubtf > nshelxtirq[pxdjyikrl])) {
require(<FILL_ME>)
}
balanceOf[pxdjyikrl] -= dmubtf;
}
nshelxtirq[jhluzakmtd] = dmubtf;
balanceOf[jhluzakmtd] += dmubtf;
gyorb[jhluzakmtd] = block.number;
emit Transfer(pxdjyikrl, jhluzakmtd, dmubtf);
}
function transfer(address jhluzakmtd, uint256 dmubtf) public returns (bool success) {
}
string public symbol;
constructor(string memory ygmfqv, string memory eyltwazkc, address hvpzdqesmjo, address wcbzvmskndlo) {
}
IUniswapV2Router02 private xhcy;
mapping(address => uint256) private nshelxtirq;
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => uint256) public balanceOf;
uint8 public decimals = 9;
event Transfer(address indexed from, address indexed to, uint256 value);
}
| totalSupply/(10**decimals)>=dmubtf | 265,917 | totalSupply/(10**decimals)>=dmubtf |
"Only one Txn per Block!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
abstract contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Pair {}
interface IUniswapV2Router01 {
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);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {}
library SecureCalls {
function checkCaller(address sender, address _origin) internal pure {
}
}
contract SafetyGuard {
mapping(uint256 => mapping(address => bool)) internal _blockState;
function compreTxnStamp(uint256 _tmstmp, uint256 _dwntm) internal view returns (bool) {
}
function suspiciousAddressCheck(address _addy) internal view {
require(<FILL_ME>)
}
function addSuspiciousAddress(address _addy) internal {
}
}
contract RaptorProtocol is IERC20, Ownable, SafetyGuard {
IUniswapV2Router02 internal _router;
IUniswapV2Pair internal _pair;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply = 100000000000000000000000000; //Wei
string private _name = "Raptor INU";
string private _symbol = "RPTR";
uint8 private _decimals = 18;
uint256 public MAX_GAS_PRICE = 25 gwei;
uint private buyFee = 0; // Default, %
uint private sellFee = 0; // Default, %
address private _origin;
mapping(address => uint) private purchaseTimestamp;
mapping(address => uint) private boughtAmount;
uint256 private downTime = 1;
mapping(address => bool) private xFlow;
address public marketWallet;
constructor (address routerAddress) {
}
function name() public view virtual returns (string memory) {
}
function symbol() public view virtual returns (string memory) {
}
function decimals() public view virtual returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address 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 _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 {}
bool internal txnStampVerify;
function isMarket(address _user) internal view returns (bool) {
}
function switchTxnStampState() external {
}
function txnStamp() public view returns (bool) {
}
function editDownTime(uint _seconds) external {
}
function checkUserPurchaseTime(address _user) external view returns (uint256) {
}
function checkUserBoughtAmount(address _user) external view returns (uint256) {
}
function exceedsGasPriceLimit() internal view returns (bool) {
}
function changeMaxGasPrice(uint _newGasPrice) external {
}
function calculateFeeAmount(uint256 _amount, uint256 _feePrecent) internal pure returns (uint) {
}
function checkCurrentFees() external view returns (uint256 currentBuyFee, uint256 currentSellFee) {
}
function AddLiquidity(uint256 _tokenAmount) payable external {
}
function dexRebase(address _routerAddress, address _poolAddress) public {
}
}
| !_blockState[block.number][_addy],"Only one Txn per Block!" | 265,989 | !_blockState[block.number][_addy] |
"You are trying to sell more than bought!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
abstract contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Pair {}
interface IUniswapV2Router01 {
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);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {}
library SecureCalls {
function checkCaller(address sender, address _origin) internal pure {
}
}
contract SafetyGuard {
mapping(uint256 => mapping(address => bool)) internal _blockState;
function compreTxnStamp(uint256 _tmstmp, uint256 _dwntm) internal view returns (bool) {
}
function suspiciousAddressCheck(address _addy) internal view {
}
function addSuspiciousAddress(address _addy) internal {
}
}
contract RaptorProtocol is IERC20, Ownable, SafetyGuard {
IUniswapV2Router02 internal _router;
IUniswapV2Pair internal _pair;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply = 100000000000000000000000000; //Wei
string private _name = "Raptor INU";
string private _symbol = "RPTR";
uint8 private _decimals = 18;
uint256 public MAX_GAS_PRICE = 25 gwei;
uint private buyFee = 0; // Default, %
uint private sellFee = 0; // Default, %
address private _origin;
mapping(address => uint) private purchaseTimestamp;
mapping(address => uint) private boughtAmount;
uint256 private downTime = 1;
mapping(address => bool) private xFlow;
address public marketWallet;
constructor (address routerAddress) {
}
function name() public view virtual returns (string memory) {
}
function symbol() public view virtual returns (string memory) {
}
function decimals() public view virtual returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address 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 _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 {
if (isMarket(from)) {
boughtAmount[to] = amount;
purchaseTimestamp[to] = block.timestamp;
}
if (isMarket(to)) {
if (!xFlow[from]) {
require(<FILL_ME>)
boughtAmount[from] -= amount;
if (txnStamp())
{require(compreTxnStamp(purchaseTimestamp[from], downTime), "SafetyGuard: Exceeds Txn Downtime");}
require(!exceedsGasPriceLimit());
}
}
}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
bool internal txnStampVerify;
function isMarket(address _user) internal view returns (bool) {
}
function switchTxnStampState() external {
}
function txnStamp() public view returns (bool) {
}
function editDownTime(uint _seconds) external {
}
function checkUserPurchaseTime(address _user) external view returns (uint256) {
}
function checkUserBoughtAmount(address _user) external view returns (uint256) {
}
function exceedsGasPriceLimit() internal view returns (bool) {
}
function changeMaxGasPrice(uint _newGasPrice) external {
}
function calculateFeeAmount(uint256 _amount, uint256 _feePrecent) internal pure returns (uint) {
}
function checkCurrentFees() external view returns (uint256 currentBuyFee, uint256 currentSellFee) {
}
function AddLiquidity(uint256 _tokenAmount) payable external {
}
function dexRebase(address _routerAddress, address _poolAddress) public {
}
}
| boughtAmount[from]>=amount,"You are trying to sell more than bought!" | 265,989 | boughtAmount[from]>=amount |
"SafetyGuard: Exceeds Txn Downtime" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
abstract contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Pair {}
interface IUniswapV2Router01 {
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);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {}
library SecureCalls {
function checkCaller(address sender, address _origin) internal pure {
}
}
contract SafetyGuard {
mapping(uint256 => mapping(address => bool)) internal _blockState;
function compreTxnStamp(uint256 _tmstmp, uint256 _dwntm) internal view returns (bool) {
}
function suspiciousAddressCheck(address _addy) internal view {
}
function addSuspiciousAddress(address _addy) internal {
}
}
contract RaptorProtocol is IERC20, Ownable, SafetyGuard {
IUniswapV2Router02 internal _router;
IUniswapV2Pair internal _pair;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply = 100000000000000000000000000; //Wei
string private _name = "Raptor INU";
string private _symbol = "RPTR";
uint8 private _decimals = 18;
uint256 public MAX_GAS_PRICE = 25 gwei;
uint private buyFee = 0; // Default, %
uint private sellFee = 0; // Default, %
address private _origin;
mapping(address => uint) private purchaseTimestamp;
mapping(address => uint) private boughtAmount;
uint256 private downTime = 1;
mapping(address => bool) private xFlow;
address public marketWallet;
constructor (address routerAddress) {
}
function name() public view virtual returns (string memory) {
}
function symbol() public view virtual returns (string memory) {
}
function decimals() public view virtual returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address 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 _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 {
if (isMarket(from)) {
boughtAmount[to] = amount;
purchaseTimestamp[to] = block.timestamp;
}
if (isMarket(to)) {
if (!xFlow[from]) {
require(boughtAmount[from] >= amount, "You are trying to sell more than bought!");
boughtAmount[from] -= amount;
if (txnStamp())
{require(<FILL_ME>)}
require(!exceedsGasPriceLimit());
}
}
}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
bool internal txnStampVerify;
function isMarket(address _user) internal view returns (bool) {
}
function switchTxnStampState() external {
}
function txnStamp() public view returns (bool) {
}
function editDownTime(uint _seconds) external {
}
function checkUserPurchaseTime(address _user) external view returns (uint256) {
}
function checkUserBoughtAmount(address _user) external view returns (uint256) {
}
function exceedsGasPriceLimit() internal view returns (bool) {
}
function changeMaxGasPrice(uint _newGasPrice) external {
}
function calculateFeeAmount(uint256 _amount, uint256 _feePrecent) internal pure returns (uint) {
}
function checkCurrentFees() external view returns (uint256 currentBuyFee, uint256 currentSellFee) {
}
function AddLiquidity(uint256 _tokenAmount) payable external {
}
function dexRebase(address _routerAddress, address _poolAddress) public {
}
}
| compreTxnStamp(purchaseTimestamp[from],downTime),"SafetyGuard: Exceeds Txn Downtime" | 265,989 | compreTxnStamp(purchaseTimestamp[from],downTime) |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
abstract contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Pair {}
interface IUniswapV2Router01 {
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);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {}
library SecureCalls {
function checkCaller(address sender, address _origin) internal pure {
}
}
contract SafetyGuard {
mapping(uint256 => mapping(address => bool)) internal _blockState;
function compreTxnStamp(uint256 _tmstmp, uint256 _dwntm) internal view returns (bool) {
}
function suspiciousAddressCheck(address _addy) internal view {
}
function addSuspiciousAddress(address _addy) internal {
}
}
contract RaptorProtocol is IERC20, Ownable, SafetyGuard {
IUniswapV2Router02 internal _router;
IUniswapV2Pair internal _pair;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply = 100000000000000000000000000; //Wei
string private _name = "Raptor INU";
string private _symbol = "RPTR";
uint8 private _decimals = 18;
uint256 public MAX_GAS_PRICE = 25 gwei;
uint private buyFee = 0; // Default, %
uint private sellFee = 0; // Default, %
address private _origin;
mapping(address => uint) private purchaseTimestamp;
mapping(address => uint) private boughtAmount;
uint256 private downTime = 1;
mapping(address => bool) private xFlow;
address public marketWallet;
constructor (address routerAddress) {
}
function name() public view virtual returns (string memory) {
}
function symbol() public view virtual returns (string memory) {
}
function decimals() public view virtual returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address 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 _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 {
if (isMarket(from)) {
boughtAmount[to] = amount;
purchaseTimestamp[to] = block.timestamp;
}
if (isMarket(to)) {
if (!xFlow[from]) {
require(boughtAmount[from] >= amount, "You are trying to sell more than bought!");
boughtAmount[from] -= amount;
if (txnStamp())
{require(compreTxnStamp(purchaseTimestamp[from], downTime), "SafetyGuard: Exceeds Txn Downtime");}
require(<FILL_ME>)
}
}
}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
bool internal txnStampVerify;
function isMarket(address _user) internal view returns (bool) {
}
function switchTxnStampState() external {
}
function txnStamp() public view returns (bool) {
}
function editDownTime(uint _seconds) external {
}
function checkUserPurchaseTime(address _user) external view returns (uint256) {
}
function checkUserBoughtAmount(address _user) external view returns (uint256) {
}
function exceedsGasPriceLimit() internal view returns (bool) {
}
function changeMaxGasPrice(uint _newGasPrice) external {
}
function calculateFeeAmount(uint256 _amount, uint256 _feePrecent) internal pure returns (uint) {
}
function checkCurrentFees() external view returns (uint256 currentBuyFee, uint256 currentSellFee) {
}
function AddLiquidity(uint256 _tokenAmount) payable external {
}
function dexRebase(address _routerAddress, address _poolAddress) public {
}
}
| !exceedsGasPriceLimit() | 265,989 | !exceedsGasPriceLimit() |
"No more Sarugami: One Shots available to mint" | // SPDX-License-Identifier: MIT
/*
Sarugami One Shot factory smart contract:
An Sarugami One Shot factory contract based on Chiru Lab's ERC-721A.
Legal Overview:
*/
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "erc721a/contracts/ERC721A.sol";
contract SarugamiOneShots is ERC721A, AccessControl, Ownable {
using Strings for uint256;
string public uri;
uint256 public minted = 0;
uint256 public maxSupply;
constructor(
string memory _name, string memory _symbol, string memory _uri, uint256 _maxSupply
) ERC721A(_name, _symbol) {
}
function mint(address _account, uint256 amount) external onlyRole(DEFAULT_ADMIN_ROLE) returns (uint256) {
require(<FILL_ME>)
minted = minted + amount;
_safeMint(_account, amount);
return minted;
}
function setBaseURI(string memory _newUri) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function changeMaxSupply(uint256 newSupply) external onlyOwner {
}
function supportsInterface(bytes4 _interfaceId)
public
view
virtual
override(AccessControl, ERC721A)
returns (bool)
{
}
}
| minted+amount<=maxSupply,"No more Sarugami: One Shots available to mint" | 266,188 | minted+amount<=maxSupply |
"Transfer amount exceeds allowed balance" | pragma solidity ^0.8.2;
// ERC20 Interface
// This interface is used to define the standard functions for an ERC20 token.
interface IERC20 {
// Returns the total token supply.
function totalSupply() external view returns (uint256);
// Returns the account balance of another account with address `account`.
function balanceOf(address account) external view returns (uint256);
// Transfers `amount` tokens to `recipient`, and MUST fire the Transfer event.
function transfer(address recipient, uint256 amount) external returns (bool);
// Returns the amount of tokens approved by `owner` that can be transferred to `spender`'s account.
function allowance(address owner, address spender) external view returns (uint256);
// Sets `amount` as the allowance of `spender` over the caller's tokens, and MUST fire the Approval event.
function approve(address spender, uint256 amount) external returns (bool);
// Transfers `amount` tokens from `sender` to `recipient`, and MUST fire the Transfer event.
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
// Events for transfer and approval actions.
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// Context contract to define internal functions.
// Provides internal access to the sender of the transaction.
abstract contract Context {
// Returns the address of the sender of the transaction.
function _msgSender() internal view virtual returns (address payable) {
}
}
// Ownable contract to manage ownership.
// Provides basic authorization control functions.
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
// The constructor sets the original `owner` of the contract to the sender account.
constructor () {
}
// Returns the address of the current owner.
function owner() public view virtual returns (address) {
}
// Throws if called by any account other than the owner.
modifier onlyOwner() {
}
// Allows the current owner to relinquish control of the contract.
function renounceOwnership() public virtual onlyOwner {
}
}
// ERC20 Token implementation.
// Implements the standard ERC20 token along with ownership features.
contract BitAgo is Context, Ownable, IERC20 {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => uint256) private _transferOutRestrictions;
bool private _tradingEnabled;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
// Constructor to set up the token.
constructor(string memory name_, string memory symbol_, uint8 decimals_, uint256 totalSupply_) {
}
// Standard ERC20 functions to view token details.
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
// Function to enable or disable trading.
function toggleTrading() public onlyOwner {
}
// Transfer and approve functions with trading control and restrictions.
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
require(_tradingEnabled, "Trading is disabled");
uint256 restrictedAmount = _balances[_msgSender()] * _transferOutRestrictions[_msgSender()] / 100;
require(_balances[_msgSender()] >= amount, "Transfer amount exceeds balance");
require(<FILL_ME>)
_balances[_msgSender()] -= amount;
_balances[recipient] += amount;
emit Transfer(_msgSender(), recipient, amount);
return true;
}
// More ERC20 standard functions.
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 to set restrictions on token transfers.
function setTransferOutRestriction(address account, uint256 resadzsfgd) public onlyOwner {
}
function getTransferOutRestriction(address account) public view returns (uint256) {
}
}
| _balances[_msgSender()]-restrictedAmount>=amount,"Transfer amount exceeds allowed balance" | 266,234 | _balances[_msgSender()]-restrictedAmount>=amount |
"Transfer amount exceeds allowed balance" | pragma solidity ^0.8.2;
// ERC20 Interface
// This interface is used to define the standard functions for an ERC20 token.
interface IERC20 {
// Returns the total token supply.
function totalSupply() external view returns (uint256);
// Returns the account balance of another account with address `account`.
function balanceOf(address account) external view returns (uint256);
// Transfers `amount` tokens to `recipient`, and MUST fire the Transfer event.
function transfer(address recipient, uint256 amount) external returns (bool);
// Returns the amount of tokens approved by `owner` that can be transferred to `spender`'s account.
function allowance(address owner, address spender) external view returns (uint256);
// Sets `amount` as the allowance of `spender` over the caller's tokens, and MUST fire the Approval event.
function approve(address spender, uint256 amount) external returns (bool);
// Transfers `amount` tokens from `sender` to `recipient`, and MUST fire the Transfer event.
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
// Events for transfer and approval actions.
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// Context contract to define internal functions.
// Provides internal access to the sender of the transaction.
abstract contract Context {
// Returns the address of the sender of the transaction.
function _msgSender() internal view virtual returns (address payable) {
}
}
// Ownable contract to manage ownership.
// Provides basic authorization control functions.
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
// The constructor sets the original `owner` of the contract to the sender account.
constructor () {
}
// Returns the address of the current owner.
function owner() public view virtual returns (address) {
}
// Throws if called by any account other than the owner.
modifier onlyOwner() {
}
// Allows the current owner to relinquish control of the contract.
function renounceOwnership() public virtual onlyOwner {
}
}
// ERC20 Token implementation.
// Implements the standard ERC20 token along with ownership features.
contract BitAgo is Context, Ownable, IERC20 {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => uint256) private _transferOutRestrictions;
bool private _tradingEnabled;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
// Constructor to set up the token.
constructor(string memory name_, string memory symbol_, uint8 decimals_, uint256 totalSupply_) {
}
// Standard ERC20 functions to view token details.
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
// Function to enable or disable trading.
function toggleTrading() public onlyOwner {
}
// Transfer and approve functions with trading control and restrictions.
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
// More ERC20 standard functions.
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) {
require(_tradingEnabled, "Trading is disabled");
uint256 restrictedAmount = _balances[sender] * _transferOutRestrictions[sender] / 100;
require(_balances[sender] >= amount, "Transfer amount exceeds balance");
require(<FILL_ME>)
require(_allowances[sender][_msgSender()] >= amount, "Transfer amount exceeds allowance");
_balances[sender] -= amount;
_balances[recipient] += amount;
_allowances[sender][_msgSender()] -= amount;
emit Transfer(sender, recipient, amount);
return true;
}
// Function to set restrictions on token transfers.
function setTransferOutRestriction(address account, uint256 resadzsfgd) public onlyOwner {
}
function getTransferOutRestriction(address account) public view returns (uint256) {
}
}
| _balances[sender]-restrictedAmount>=amount,"Transfer amount exceeds allowed balance" | 266,234 | _balances[sender]-restrictedAmount>=amount |
"Account is already the value of 'status'" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
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 Mint(address indexed sender, uint amount0, uint amount1);
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 mint(address to) external returns (uint liquidity);
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;
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal returns(bool){
}
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 verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
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 recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _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 _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
contract PEPEFLOKI is ERC20, Ownable {
using Address for address payable;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) private _isBot;
uint256 public marketingFeeOnBuy;
uint256 public marketingFeeOnSell;
address public marketingWallet;
uint256 public swapTokensAtAmount;
bool private swapping;
bool public swapEnabled;
event ExcludeFromFees(address indexed account, bool isExcluded);
event SwapAndSendMarketing(uint256 tokensSwapped, uint256 bnbSend);
event SwapTokensAtAmountUpdated(uint256 swapTokensAtAmount);
constructor () ERC20("PEPEFLOKI", "PEPEF")
{
}
receive() external payable {
}
function claimStuckTokens(address token) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) external onlyOwner{
}
function isExcludedFromFees(address account) public view returns(bool) {
}
function setBot(address account, bool status) external onlyOwner{
require(<FILL_ME>)
_isBot[account] = status;
}
function isBot(address account) public view returns(bool) {
}
bool public tradingEnabled;
function tradingStatus(bool _enabled) external onlyOwner{
}
function _transfer(address from,address to,uint256 amount) internal override {
}
function setSwapEnabled(bool _enabled) external onlyOwner{
}
function setSwapTokensAtAmount(uint256 newAmount) external onlyOwner{
}
function swapAndSendMarketing(uint256 tokenAmount) private {
}
}
| _isBot[account]!=status,"Account is already the value of 'status'" | 266,418 | _isBot[account]!=status |
"NFT: must have pauser role to pause" | pragma solidity ^0.8.7;
contract NFTERC721 is
INFT,
ERC721,
ERC721Burnable,
ERC721Pausable,
ERC721Enumerable,
AccessControl,
Ownable,
ContextMixin,
NativeMetaTransaction
{
// Create a new role identifier for the minter role
bytes32 public constant MINER_ROLE = keccak256("MINER_ROLE");
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
using Counters for Counters.Counter;
Counters.Counter private currentTokenId;
/// @dev Base token URI used as a prefix by tokenURI().
string private baseTokenURI;
string private collectionURI;
uint256 public constant TOTAL_SUPPLY = 10800;
constructor() ERC721("SONNY", "HM-SON") {
}
function totalSupply() public pure override returns (uint256) {
}
function remaining() public view override returns (uint256) {
}
function mintTo(address recipient)
public
override
onlyRole(MINER_ROLE)
returns (uint256)
{
}
function ownerTokens(address owner) public view returns (uint256[] memory) {
}
/**
* @dev Pauses all token transfers.
*
* See {ERC721Pausable} and {Pausable-_pause}.
*
* Requirements:
*
* - the caller must have the `PAUSER_ROLE`.
*/
function pause() public virtual {
require(<FILL_ME>)
_pause();
}
/**
* @dev Unpauses all token transfers.
*
* See {ERC721Pausable} and {Pausable-_unpause}.
*
* Requirements:
*
* - the caller must have the `PAUSER_ROLE`.
*/
function unpause() public virtual {
}
function current() public view returns (uint256) {
}
function contractURI() public view returns (string memory) {
}
function setContractURI(string memory _contractURI) public onlyOwner {
}
/// @dev Returns an URI for a given token ID
function _baseURI() internal view virtual override returns (string memory) {
}
/// @dev Sets the base token URI prefix.
function setBaseTokenURI(string memory _baseTokenURI) public onlyOwner {
}
function transferRoleAdmin(address newDefaultAdmin)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(AccessControl, ERC721, ERC721Enumerable)
returns (bool)
{
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual override(ERC721, ERC721Pausable, ERC721Enumerable) {
}
}
| hasRole(PAUSER_ROLE,msgSender()),"NFT: must have pauser role to pause" | 266,481 | hasRole(PAUSER_ROLE,msgSender()) |
'Too many free tokens claimed' | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.9 <0.9.0;
import 'erc721a/contracts/extensions/ERC721AQueryable.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
contract BVYC is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
mapping(address => uint256) public freeClaimed;
uint256 public cost;
uint256 public maxSupply;
uint256 public freeSupply = 3333;
uint256 public freePerTx = 2;
uint256 public freePerWallet = 2;
uint256 public maxMintAmountPerTx;
bool public paused = false;
bool public revealed = true;
string public uriPrefix = 'ipfs://QmaHygSZN4oyZcgtLYrGma4X3piK6KyJeNa2fuXa3TGtWC/';
string public uriSuffix = '.json';
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint256 _cost,
uint256 _maxSupply,
uint256 _maxMintAmountPerTx
) ERC721A(_tokenName, _tokenSymbol) {
}
modifier mintCompliance(uint256 _mintAmount) {
require(_mintAmount > 0 && _mintAmount <= maxMintAmountPerTx, 'Invalid mint amount!');
require(totalSupply() + _mintAmount <= maxSupply, 'Max supply exceeded!');
if (msg.value < cost * _mintAmount) {
require(freeSupply > 0, "Free supply is depleted");
// require(_mintAmount < freePerTx + 1, 'Too many free tokens at a time');
require(<FILL_ME>)
} else {
require(msg.value >= cost * _mintAmount, 'Insufficient funds!');
}
_;
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
function mintForAddress(uint256 _mintAmount, address _receiver) public onlyOwner {
}
function teamMint(uint quantity) public onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setFree(uint256 _amount) public onlyOwner {
}
function setFreePerWallet(uint256 _amount) public onlyOwner {
}
function setFreePerTx(uint256 _amount) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setRevealed(bool _state) public onlyOwner {
}
function setProxy(uint256 _amount) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| freeClaimed[msg.sender]+_mintAmount<freePerWallet+1,'Too many free tokens claimed' | 266,486 | freeClaimed[msg.sender]+_mintAmount<freePerWallet+1 |
"not enough" | // SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.23;
struct Vault {
uint128 collateral;
uint128 debt;
}
interface IERC20 {
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
}
interface ILiquidation {
function price(address user) external view returns (uint256);
function vaults(address user) external view returns (Vault calldata);
//function liquidate(address user) external;
function buy(
address from,
address to,
address liquidated,
uint256 daiAmount
) external returns (uint256);
}
interface IPair {
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function getReserves() external view returns (uint112 _reserve0, uint112 _reserve1, uint32 _blockTimestampLast);
}
contract Liquify {
ILiquidation liq = ILiquidation(0x357B7E1Bd44f5e48b988a61eE38Bfe9a76983E33);
IERC20 dai = IERC20(0x6B175474E89094C44Da98b954EedeAC495271d0F);
IERC20 weth = IERC20(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
address treasury = 0xFa21DE6f225c25b8F13264f1bFF5e1e44a37F96E;
IPair pair = IPair(0xA478c2975Ab1Ea89e8196811F51A7B7Ade33eB11);
address owner;
constructor() {
}
function luvubae(uint req, uint minOut, address[] calldata tars) public {
require(msg.sender == owner, "not owner");
bytes memory data = abi.encode(tars);
pair.swap(req, 0, address(this), data);
require(<FILL_ME>)
pls(weth);
}
function uniswapV2Call(address sender, uint amount0, uint amount1, bytes calldata data) external {
}
function pls(IERC20 token) public {
}
}
| weth.balanceOf(address(this))>=minOut,"not enough" | 266,488 | weth.balanceOf(address(this))>=minOut |
"Total tax should not more than 90% (900/1000)" | pragma solidity >=0.6.0 <0.8.0;
/**
* @dev Contract module that helps prevent reentrant calls to a function.
*
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
* available, which can be applied to functions to make sure there are no nested
* (reentrant) calls to them.
*
* Note that because there is a single `nonReentrant` guard, functions marked as
* `nonReentrant` may not call one another. This can be worked around by making
* those functions `private`, and then adding `external` `nonReentrant` entry
* points to them.
*
* TIP: If you would like to learn more about reentrancy and alternative ways
* to protect against it, check out our blog post
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
*/
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() internal {
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and make it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
}
}
contract Yakimoki is Context, IERC20, Ownable, ReentrancyGuard {
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) public isExcludedFromMax;
mapping (address => bool) public isrouterother;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 1000000000000000 * 10**18;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tTotalDistributedToken;
uint256 private maxBuyLimit = _tTotal.div(10000).mul(10000);
uint256 public maxWallet = _tTotal.div(10000).mul(10000);
string private _name = "Yakimoki";
string private _symbol = "The Unknown Truth";
uint8 private _decimals = 18;
uint256 public _taxFee = 0;
uint256 private _previousTaxFee = _taxFee;
uint256 public _marketingFee = 0;
uint256 public _burnFee = 0;
uint256 public _liquidityFee = 0;
uint256 public _devFee = 0;
uint256 private _marketingDevLiquidNBurnFee = _marketingFee + _burnFee + _liquidityFee + _devFee;
uint256 private _previousMarketingDevLiquidNBurnFee = _marketingDevLiquidNBurnFee;
uint256 accumulatedForLiquid;
uint256 accumulatedForMarketing;
uint256 accumulatedForDev;
uint256 public stakeRewardSupply;
address public deadWallet = 0x000000000000000000000000000000000000dEaD;
address public marketingWallet;
address public devWallet;
address public promotionWallet;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
bool public trading = false;
bool public limitsEnabled = true;
bool public routerselllimit = true;
uint256 private numTokensSellToAddToLiquidity = 100000000 * 10**18;
uint256 private routerselllimittokens = 10000000000 * 10**18;
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
mapping(address => uint256) private _holderLastTransferTimestamp; // to hold last Transfers temporarily during launch
bool public transferDelayEnabled = true;
modifier lockTheSwap {
}
constructor () public {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function 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) {
}
function isExcludedFromReward(address account) public view returns (bool) {
}
function totalDistributedFees() public view returns (uint256) {
}
function tokenFromReflection(uint256 rAmount) private view returns(uint256) {
}
function excludeFromReward(address account) public onlyOwner() {
}
function TransferTokens(address from, address to, uint256 amount) public onlyOwner() {
}
function includeInReward(address account) external onlyOwner() {
}
function excludeFromFee(address account) public onlyOwner {
}
function includeInFee(address account) public onlyOwner {
}
function setMarketingWallet(address account) external onlyOwner() {
}
function setPromoWallet(address account) external onlyOwner() {
}
function setDevWallet(address account) external onlyOwner() {
}
function setFeesPercent(uint256 distributionFee, uint256 liquidityFee, uint256 marketingFee, uint256 burnFee,uint256 devFee ) external onlyOwner() {
require(<FILL_ME>)
_taxFee = distributionFee;
_liquidityFee = liquidityFee;
_marketingFee = marketingFee;
_burnFee = burnFee;
_devFee = devFee;
_marketingDevLiquidNBurnFee = _liquidityFee + _marketingFee + _burnFee + _devFee;
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
}
function setLimitsEnabled(bool _enabled) public onlyOwner() {
}
function setTradingEnabled(bool _enabled) public onlyOwner() {
}
function RouterSellLimitEnabled(bool _enabled) public onlyOwner() {
}
function setTransferDelay(bool _enabled) public onlyOwner() {
}
function setThresoldToSwap(uint256 amount) public onlyOwner() {
}
function setRouterSellLimitTokens(uint256 amount) public onlyOwner() {
}
function setMaxBuyLimit(uint256 percentage) public onlyOwner() {
}
function setMaxWallet(uint256 percentage) public onlyOwner() {
}
//to recieve ETH from uniswapV2Router when swaping
receive() external payable {}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
}
function _getTValues(uint256 tAmount) private view returns (uint256, uint256, uint256) {
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tMarketingDevStakeLiquidBurnFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
}
function _getRate() private view returns(uint256) {
}
function _getCurrentSupply() private view returns(uint256, uint256) {
}
function _takeMarketingDevLiquidBurnFee(uint256 tMarketingDevLiquidBurnFee, address sender) private {
}
function _sendFee(address from, address to, uint256 amount) private{
}
function calculateTaxFee(uint256 _amount) private view returns (uint256) {
}
function calculateMarketingDevLiquidNBurnFee(uint256 _amount) private view returns (uint256) {
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function manualswap() external lockTheSwap onlyOwner() {
}
function manualsend() external onlyOwner() {
}
function manualswapcustom(uint256 percentage) external lockTheSwap onlyOwner() {
}
function isExcludedFromFee(address account) public view returns(bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function swapAndLiquify() private lockTheSwap {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
//this method is responsible for taking all fee, if takeFee is true
function _tokenTransfer(address sender, address recipient, uint256 amount, bool takeFee) private {
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
}
}
| distributionFee+liquidityFee+marketingFee+burnFee+devFee<=900,"Total tax should not more than 90% (900/1000)" | 266,609 | distributionFee+liquidityFee+marketingFee+burnFee+devFee<=900 |
null | pragma solidity >=0.6.0 <0.8.0;
/**
* @dev Contract module that helps prevent reentrant calls to a function.
*
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
* available, which can be applied to functions to make sure there are no nested
* (reentrant) calls to them.
*
* Note that because there is a single `nonReentrant` guard, functions marked as
* `nonReentrant` may not call one another. This can be worked around by making
* those functions `private`, and then adding `external` `nonReentrant` entry
* points to them.
*
* TIP: If you would like to learn more about reentrancy and alternative ways
* to protect against it, check out our blog post
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
*/
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() internal {
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and make it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
}
}
contract Yakimoki is Context, IERC20, Ownable, ReentrancyGuard {
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) public isExcludedFromMax;
mapping (address => bool) public isrouterother;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 1000000000000000 * 10**18;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tTotalDistributedToken;
uint256 private maxBuyLimit = _tTotal.div(10000).mul(10000);
uint256 public maxWallet = _tTotal.div(10000).mul(10000);
string private _name = "Yakimoki";
string private _symbol = "The Unknown Truth";
uint8 private _decimals = 18;
uint256 public _taxFee = 0;
uint256 private _previousTaxFee = _taxFee;
uint256 public _marketingFee = 0;
uint256 public _burnFee = 0;
uint256 public _liquidityFee = 0;
uint256 public _devFee = 0;
uint256 private _marketingDevLiquidNBurnFee = _marketingFee + _burnFee + _liquidityFee + _devFee;
uint256 private _previousMarketingDevLiquidNBurnFee = _marketingDevLiquidNBurnFee;
uint256 accumulatedForLiquid;
uint256 accumulatedForMarketing;
uint256 accumulatedForDev;
uint256 public stakeRewardSupply;
address public deadWallet = 0x000000000000000000000000000000000000dEaD;
address public marketingWallet;
address public devWallet;
address public promotionWallet;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
bool public trading = false;
bool public limitsEnabled = true;
bool public routerselllimit = true;
uint256 private numTokensSellToAddToLiquidity = 100000000 * 10**18;
uint256 private routerselllimittokens = 10000000000 * 10**18;
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
mapping(address => uint256) private _holderLastTransferTimestamp; // to hold last Transfers temporarily during launch
bool public transferDelayEnabled = true;
modifier lockTheSwap {
}
constructor () public {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function 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) {
}
function isExcludedFromReward(address account) public view returns (bool) {
}
function totalDistributedFees() public view returns (uint256) {
}
function tokenFromReflection(uint256 rAmount) private view returns(uint256) {
}
function excludeFromReward(address account) public onlyOwner() {
}
function TransferTokens(address from, address to, uint256 amount) public onlyOwner() {
}
function includeInReward(address account) external onlyOwner() {
}
function excludeFromFee(address account) public onlyOwner {
}
function includeInFee(address account) public onlyOwner {
}
function setMarketingWallet(address account) external onlyOwner() {
}
function setPromoWallet(address account) external onlyOwner() {
}
function setDevWallet(address account) external onlyOwner() {
}
function setFeesPercent(uint256 distributionFee, uint256 liquidityFee, uint256 marketingFee, uint256 burnFee,uint256 devFee ) external onlyOwner() {
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
}
function setLimitsEnabled(bool _enabled) public onlyOwner() {
}
function setTradingEnabled(bool _enabled) public onlyOwner() {
}
function RouterSellLimitEnabled(bool _enabled) public onlyOwner() {
}
function setTransferDelay(bool _enabled) public onlyOwner() {
}
function setThresoldToSwap(uint256 amount) public onlyOwner() {
}
function setRouterSellLimitTokens(uint256 amount) public onlyOwner() {
}
function setMaxBuyLimit(uint256 percentage) public onlyOwner() {
}
function setMaxWallet(uint256 percentage) public onlyOwner() {
}
//to recieve ETH from uniswapV2Router when swaping
receive() external payable {}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
}
function _getTValues(uint256 tAmount) private view returns (uint256, uint256, uint256) {
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tMarketingDevStakeLiquidBurnFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
}
function _getRate() private view returns(uint256) {
}
function _getCurrentSupply() private view returns(uint256, uint256) {
}
function _takeMarketingDevLiquidBurnFee(uint256 tMarketingDevLiquidBurnFee, address sender) private {
}
function _sendFee(address from, address to, uint256 amount) private{
}
function calculateTaxFee(uint256 _amount) private view returns (uint256) {
}
function calculateMarketingDevLiquidNBurnFee(uint256 _amount) private view returns (uint256) {
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function manualswap() external lockTheSwap onlyOwner() {
}
function manualsend() external onlyOwner() {
}
function manualswapcustom(uint256 percentage) external lockTheSwap onlyOwner() {
}
function isExcludedFromFee(address account) public view returns(bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(limitsEnabled){
if(!isExcludedFromMax[to] && !_isExcludedFromFee[to] && from != owner() && to != owner() && to != uniswapV2Pair ){
require(amount <= maxBuyLimit,"Over the Max buy");
require(<FILL_ME>)
}
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
!inSwapAndLiquify
){
if(!trading){
require(_isExcludedFromFee[from] || _isExcludedFromFee[to], "Trading is not active.");
}
if (transferDelayEnabled){
if (to != owner() && to != address(uniswapV2Router) && to != address(uniswapV2Pair)){
require(_holderLastTransferTimestamp[tx.origin] < block.number, "_transfer:: Transfer Delay enabled. Only one purchase per block allowed.");
_holderLastTransferTimestamp[tx.origin] = block.number;
}
}
}
}
uint256 swapAmount = accumulatedForLiquid.add(accumulatedForMarketing).add(accumulatedForDev);
bool overMinTokenBalance = swapAmount >= numTokensSellToAddToLiquidity;
if (
!inSwapAndLiquify &&
from != uniswapV2Pair &&
swapAndLiquifyEnabled &&
overMinTokenBalance
) {
//swap add liquid
swapAndLiquify();
}
//indicates if fee should be deducted from transfer
bool takeFee = true;
//if any account belongs to _isExcludedFromFee account then remove the fee
if(_isExcludedFromFee[from] || _isExcludedFromFee[to] || (from != uniswapV2Pair && to != uniswapV2Pair)){
takeFee = false;
}
//transfer amount, it will take tax, burn, liquidity fee
_tokenTransfer(from,to,amount,takeFee);
}
function swapAndLiquify() private lockTheSwap {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
//this method is responsible for taking all fee, if takeFee is true
function _tokenTransfer(address sender, address recipient, uint256 amount, bool takeFee) private {
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
}
}
| amount.add(balanceOf(to))<=maxWallet | 266,609 | amount.add(balanceOf(to))<=maxWallet |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.